feat(ql3): establish 3.0 incubation baseline

packages/ql3-cluster-control/test/aiProductionApplication.test.cjs

@@ -0,0 +1,268 @@
+const assert = require('node:assert/strict');
+const { chmod, mkdtemp, rm, writeFile } = require('node:fs/promises');
+const { tmpdir } = require('node:os');
+const { join } = require('node:path');
+const { test } = require('node:test');
+
+const {
+  ProductionClusterAiConfigError,
+  loadProductionClusterAiConfig,
+  startProductionClusterAiControlApplication,
+} = require('@qinglong/cluster-control/ai-production');
+const {
+  canonicalPluginPackagePromptOutputKeyringManifest,
+  PLUGIN_PACKAGE_PROMPT_OUTPUT_KEYRING_MANIFEST_SCHEMA,
+} = require('@qinglong/ai/plugin-package-prompt-output-keyring-manifest');
+
+function enabledEnvironment(overrides = {}) {
+  return {
+    QL3_CLUSTER_AI_ENABLED: 'true',
+    QL3_CLUSTER_AI_PROVIDER_AUTHORITY_FILE: '/var/run/qinglong/ai/providers.json',
+    QL3_CLUSTER_AI_SECRET_ROOT: '/var/run/qinglong/ai/provider-secrets',
+    ...overrides,
+  };
+}
+
+function controlConfig() {
+  return {
+    enabled: true,
+    profile: 'cluster-control',
+    http: { host: '127.0.0.1', port: 5800 },
+    database: {
+      connection: {
+        host: '127.0.0.1',
+        port: 5432,
+        database: 'qinglong',
+        user: 'ql3_runtime',
+        password: 'test-only',
+        tls: { mode: 'disable' },
+      },
+      pool: { maxConnections: 8 },
+    },
+    security: { apiCredentialPepper: 'test-only' },
+  };
+}
+
+test('AI config is fail-closed and bounded behind the explicit process flag', () => {
+  assert.throws(
+    () => loadProductionClusterAiConfig({}),
+    (error) =>
+      error instanceof ProductionClusterAiConfigError &&
+      error.code === 'QL3_CLUSTER_AI_CONFIG_INVALID',
+  );
+  assert.deepEqual(loadProductionClusterAiConfig(enabledEnvironment()), {
+    enabled: true,
+    providerAuthorityFile: '/var/run/qinglong/ai/providers.json',
+    secretRootDirectory: '/var/run/qinglong/ai/provider-secrets',
+    maxConcurrent: 4,
+    recoveryLimit: 32,
+    databaseMaxConnections: 4,
+  });
+  assert.throws(
+    () =>
+      loadProductionClusterAiConfig(
+        enabledEnvironment({ QL3_CLUSTER_AI_MAX_CONCURRENT: '65' }),
+      ),
+    /between 1 and 64/,
+  );
+  assert.throws(
+    () =>
+      loadProductionClusterAiConfig(
+        enabledEnvironment({
+          QL3_CLUSTER_AI_PROMPT_OUTPUT_ENABLED: 'true',
+        }),
+      ),
+    /QL3_CLUSTER_AI_PROMPT_OUTPUT_KEYRING_ROOT is invalid/,
+  );
+});
+
+test('explicit AI composition injects one reviewed Prompt capability and drains it after HTTP control', async () => {
+  const secretRoot = await mkdtemp(join(tmpdir(), 'ql3-cluster-ai-secret-'));
+  const events = [];
+  const promptCatalog = Object.freeze({ inspect() {} });
+  const promptExecutions = Object.freeze({ execute() {} });
+  const promptExecutionInspections = Object.freeze({ inspectAuthorized() {} });
+  let promptOptions;
+  let controlOptions;
+  const neverUnavailable = new Promise(() => {});
+  try {
+    const application = await startProductionClusterAiControlApplication({
+      control: { config: controlConfig() },
+      ai: {
+        enabled: true,
+        providerAuthorityFile: '/unused/providers.json',
+        secretRootDirectory: secretRoot,
+        maxConcurrent: 3,
+        recoveryLimit: 11,
+        databaseMaxConnections: 2,
+      },
+      audit() {},
+      async bootstrapPrompt(options) {
+        promptOptions = options;
+        return {
+          status: 'active',
+          profile: 'cluster',
+          readiness: {},
+          capability: {},
+          prompts: {},
+          promptCatalog,
+          promptExecutions,
+          promptExecutionInspections,
+          async stop() {
+            events.push('stop-prompt');
+            return 'stopped';
+          },
+        };
+      },
+      async startControl(options) {
+        controlOptions = options;
+        return {
+          status: 'active',
+          address: { host: '127.0.0.1', port: 5800 },
+          evidence: {},
+          recovery: { safe: true, remaining: 0, failed: 0 },
+          unavailable: neverUnavailable,
+          availabilityStatus() {
+            return 'ready';
+          },
+          async stop() {
+            events.push('stop-control');
+            return 'stopped';
+          },
+        };
+      },
+    });
+
+    assert.equal(application.status, 'active');
+    assert.equal(application.availabilityStatus(), 'ready');
+    assert.equal(promptOptions.enabled, true);
+    assert.equal(promptOptions.maxConcurrent, 3);
+    assert.equal(promptOptions.recoveryLimit, 11);
+    assert.equal(controlOptions.promptCatalog.capability, promptCatalog);
+    assert.equal(controlOptions.promptExecution.capability, promptExecutions);
+    assert.equal(
+      controlOptions.promptExecutionInspection.capability,
+      promptExecutionInspections,
+    );
+    assert.equal('promptOutputRead' in controlOptions, false);
+    assert.equal(await application.stop(), 'stopped');
+    assert.equal(await application.stop(), 'stopped');
+    assert.deepEqual(events, ['stop-control', 'stop-prompt']);
+  } finally {
+    await rm(secretRoot, { recursive: true, force: true });
+  }
+});
+
+test('output-enabled AI composition wires exact and request-keyed protected reads', async () => {
+  const secretRoot = await mkdtemp(join(tmpdir(), 'ql3-cluster-ai-secret-'));
+  const outputRoot = await mkdtemp(join(tmpdir(), 'ql3-cluster-ai-output-'));
+  const manifest = canonicalPluginPackagePromptOutputKeyringManifest({
+    schema: PLUGIN_PACKAGE_PROMPT_OUTPUT_KEYRING_MANIFEST_SCHEMA,
+    generation: 1,
+    activeKeyId: 'prompt-key-1',
+    keys: { 'prompt-key-1': Buffer.alloc(32, 7).toString('base64url') },
+    retirements: {},
+  });
+  await writeFile(join(outputRoot, 'keyring.json'), manifest, { mode: 0o440 });
+  await chmod(join(outputRoot, 'keyring.json'), 0o440);
+  let promptOptions;
+  let controlOptions;
+  const promptOutputs = Object.freeze({ read() {} });
+  const promptExecutionOutputs = Object.freeze({ read() {} });
+  try {
+    const application = await startProductionClusterAiControlApplication({
+      control: { config: controlConfig() },
+      ai: {
+        enabled: true,
+        providerAuthorityFile: '/unused/providers.json',
+        secretRootDirectory: secretRoot,
+        promptOutputKeyringRootDirectory: outputRoot,
+        maxConcurrent: 1,
+        recoveryLimit: 1,
+        databaseMaxConnections: 1,
+      },
+      audit() {},
+      async bootstrapPrompt(options) {
+        promptOptions = options;
+        return {
+          status: 'active',
+          profile: 'cluster',
+          readiness: {},
+          capability: {},
+          prompts: {},
+          promptCatalog: { inspect() {} },
+          promptExecutions: { execute() {} },
+          promptExecutionInspections: { inspectAuthorized() {} },
+          promptOutputs,
+          promptExecutionOutputs,
+          async stop() { return 'stopped'; },
+        };
+      },
+      async startControl(options) {
+        controlOptions = options;
+        return {
+          status: 'active',
+          address: { host: '127.0.0.1', port: 5800 },
+          evidence: {},
+          recovery: { safe: true, remaining: 0, failed: 0 },
+          unavailable: new Promise(() => {}),
+          availabilityStatus() { return 'ready'; },
+          async stop() { return 'stopped'; },
+        };
+      },
+    });
+    assert.equal(typeof promptOptions.promptOutputKeys.resolve, 'function');
+    assert.equal(
+      typeof promptOptions.promptOutputRead.authorizer.authorize,
+      'function',
+    );
+    assert.equal(controlOptions.promptOutputRead.capability, promptOutputs);
+    assert.equal(
+      controlOptions.promptExecutionOutputRead.capability,
+      promptExecutionOutputs,
+    );
+    assert.equal(await application.stop(), 'stopped');
+  } finally {
+    manifest.fill(0);
+    await rm(secretRoot, { recursive: true, force: true });
+    await rm(outputRoot, { recursive: true, force: true });
+  }
+});
+
+test('AI composition fails closed and drains a non-active Prompt bootstrap', async () => {
+  const secretRoot = await mkdtemp(join(tmpdir(), 'ql3-cluster-ai-secret-'));
+  let stops = 0;
+  try {
+    await assert.rejects(
+      startProductionClusterAiControlApplication({
+        control: { config: controlConfig() },
+        ai: {
+          enabled: true,
+          providerAuthorityFile: '/unused/providers.json',
+          secretRootDirectory: secretRoot,
+          maxConcurrent: 1,
+          recoveryLimit: 1,
+          databaseMaxConnections: 1,
+        },
+        audit() {},
+        async bootstrapPrompt() {
+          return {
+            status: 'disabled',
+            profile: 'cluster',
+            async stop() {
+              stops += 1;
+              return 'stopped';
+            },
+          };
+        },
+        async startControl() {
+          throw new Error('control must not start');
+        },
+      }),
+      /Prompt application did not activate/,
+    );
+    assert.equal(stops, 1);
+  } finally {
+    await rm(secretRoot, { recursive: true, force: true });
+  }
+});