@sanqianx/project-knowledge 5.0.19 → 5.0.20

package/_site/_test/module-dynamic-port-test.js

@@ -1,118 +1,118 @@
-'use strict';
-const assert = require('node:assert/strict');
-const http = require('node:http');
-const { resolveModuleUrl } = require('../lib/module-port-resolver');
-const { ModuleBridge } = require('../lib/module-bridge');
-
-const countingProbe = outcome => {
-  const seen = [];
-  return {
-    probe: async url => { seen.push(url); return outcome; },
-    get seen() { return seen; },
-    get calls() { return seen.length; },
-  };
-};
-
-const countingPortFree = isFree => {
-  const seen = [];
-  return {
-    portFree: async port => { seen.push(port); return isFree(port); },
-    get seen() { return seen; },
-    get calls() { return seen.length; },
-  };
-};
-
-(async () => {
-  // A: healthy module on the preferred port is reused without any port scan.
-  {
-    const probe = countingProbe('module');
-    const portFree = countingPortFree(() => false);
-    const resolved = await resolveModuleUrl({ kind: 'terminal', preferredUrl: 'http://127.0.0.1:5760', explicit: false, portFree: portFree.portFree, probe: probe.probe });
-    assert.equal(resolved.source, 'reused');
-    assert.equal(resolved.url, 'http://127.0.0.1:5760');
-    assert.equal(resolved.port, 5760);
-    assert.deepEqual(probe.seen, ['http://127.0.0.1:5760']);
-    assert.equal(portFree.calls, 0, 'reuse must never invoke portFree');
-  }
-  // B: foreign occupant on the preferred port moves the module to the next free port.
-  {
-    const probe = countingProbe('foreign');
-    const portFree = countingPortFree(port => port === 5761);
-    const resolved = await resolveModuleUrl({ kind: 'terminal', preferredUrl: 'http://127.0.0.1:5760', explicit: false, portFree: portFree.portFree, probe: probe.probe });
-    assert.equal(resolved.source, 'dynamic');
-    assert.equal(resolved.url, 'http://127.0.0.1:5761');
-    assert.equal(resolved.port, 5761);
-    assert.equal(resolved.offset, 1);
-    assert.deepEqual(portFree.seen, [5760, 5761]);
-  }
-  // C: unreachable preferred port skips three busy ports before picking the fourth.
-  {
-    const probe = countingProbe('unreachable');
-    const portFree = countingPortFree(port => port === 8790);
-    const resolved = await resolveModuleUrl({ kind: 'vector-hub', preferredUrl: 'http://127.0.0.1:8787', explicit: false, portFree: portFree.portFree, probe: probe.probe });
-    assert.equal(resolved.source, 'dynamic');
-    assert.equal(resolved.url, 'http://127.0.0.1:8790');
-    assert.equal(resolved.port, 8790);
-    assert.equal(resolved.offset, 3);
-    assert.deepEqual(portFree.seen, [8787, 8788, 8789, 8790]);
-  }
-  // D: exhausted scan range fails loudly with kind and port span in the message.
-  {
-    const probe = countingProbe('unreachable');
-    const portFree = countingPortFree(() => false);
-    await assert.rejects(
-      () => resolveModuleUrl({ kind: 'event-bridge', preferredUrl: 'http://127.0.0.1:8790', explicit: false, portFree: portFree.portFree, probe: probe.probe }),
-      error => {
-        assert.equal(error.code, 'NO_FREE_MODULE_PORT');
-        assert.ok(error.message.includes('event-bridge'), `message must name the module kind: ${error.message}`);
-        assert.ok(error.message.includes('8790'), `message must name the first scanned port: ${error.message}`);
-        assert.ok(error.message.includes('8809'), `message must name the last scanned port: ${error.message}`);
-        return true;
-      },
-    );
-    assert.equal(portFree.calls, 20, 'default scanRange must probe 20 consecutive ports before failing');
-    assert.deepEqual(portFree.seen, Array.from({ length: 20 }, (_, index) => 8790 + index));
-  }
-  // E: an explicit external URL short-circuits before any probe or port scan.
-  {
-    const probe = countingProbe('module');
-    const portFree = countingPortFree(() => true);
-    const resolved = await resolveModuleUrl({ kind: 'knowledge-engine', preferredUrl: 'http://192.168.1.5:5790', explicit: true, portFree: portFree.portFree, probe: probe.probe });
-    assert.equal(resolved.source, 'external');
-    assert.equal(resolved.url, 'http://192.168.1.5:5790');
-    assert.equal(probe.calls, 0, 'explicit external URL must never be probed');
-    assert.equal(portFree.calls, 0, 'explicit external URL must never trigger a port scan');
-  }
-  // F: a preferred URL without an explicit port is rejected.
-  {
-    const probe = countingProbe('module');
-    const portFree = countingPortFree(() => true);
-    await assert.rejects(
-      () => resolveModuleUrl({ kind: 'terminal', preferredUrl: 'http://127.0.0.1', explicit: false, portFree: portFree.portFree, probe: probe.probe }),
-      error => { assert.equal(error.code, 'INVALID_MODULE_URL'); return true; },
-    );
-  }
-  // G (integration): an HTTP service squatting on the preferred port with
-  // 404 responses — exactly what happens when the shell's own fallback range
-  // 5757..5776 lands on the terminal default 5760 — must not be misread as a
-  // module and must not crash-loop: the bridge moves to the next free port.
-  {
-    const squatter = http.createServer((req, res) => { res.writeHead(404, { 'Content-Type': 'application/json' }); res.end(JSON.stringify({ error: 'not found' })); });
-    await new Promise(resolve => squatter.listen(0, '127.0.0.1', resolve));
-    const squatterPort = squatter.address().port;
-    const bridge = new ModuleBridge();
-    // Isolate the terminal leg: everything else is explicit/external so the
-    // resolution loop only probes the squatter port for the terminal kind.
-    bridge.terminalUrl = `http://127.0.0.1:${squatterPort}`;
-    bridge.explicitModuleUrls = { terminal: false, vectorHub: true, eventBridge: true, engine: true };
-    try {
-      await bridge._resolveManagedUrls();
-      assert.equal(bridge.moduleUrlSources.terminal, 'dynamic', '404 squatter must force a dynamic move, never reuse');
-      assert.equal(bridge.terminalUrl, `http://127.0.0.1:${squatterPort + 1}`, 'module moves to the port right after the squatter');
-    } finally {
-      squatter.closeAllConnections?.();
-      await new Promise(resolve => squatter.close(resolve));
-    }
-  }
-  console.log('module dynamic port test PASS');
-})().catch(error => { console.error(error); process.exitCode = 1; });
+'use strict';
+const assert = require('node:assert/strict');
+const http = require('node:http');
+const { resolveModuleUrl } = require('../lib/module-port-resolver');
+const { ModuleBridge } = require('../lib/module-bridge');
+
+const countingProbe = outcome => {
+  const seen = [];
+  return {
+    probe: async url => { seen.push(url); return outcome; },
+    get seen() { return seen; },
+    get calls() { return seen.length; },
+  };
+};
+
+const countingPortFree = isFree => {
+  const seen = [];
+  return {
+    portFree: async port => { seen.push(port); return isFree(port); },
+    get seen() { return seen; },
+    get calls() { return seen.length; },
+  };
+};
+
+(async () => {
+  // A: healthy module on the preferred port is reused without any port scan.
+  {
+    const probe = countingProbe('module');
+    const portFree = countingPortFree(() => false);
+    const resolved = await resolveModuleUrl({ kind: 'terminal', preferredUrl: 'http://127.0.0.1:5760', explicit: false, portFree: portFree.portFree, probe: probe.probe });
+    assert.equal(resolved.source, 'reused');
+    assert.equal(resolved.url, 'http://127.0.0.1:5760');
+    assert.equal(resolved.port, 5760);
+    assert.deepEqual(probe.seen, ['http://127.0.0.1:5760']);
+    assert.equal(portFree.calls, 0, 'reuse must never invoke portFree');
+  }
+  // B: foreign occupant on the preferred port moves the module to the next free port.
+  {
+    const probe = countingProbe('foreign');
+    const portFree = countingPortFree(port => port === 5761);
+    const resolved = await resolveModuleUrl({ kind: 'terminal', preferredUrl: 'http://127.0.0.1:5760', explicit: false, portFree: portFree.portFree, probe: probe.probe });
+    assert.equal(resolved.source, 'dynamic');
+    assert.equal(resolved.url, 'http://127.0.0.1:5761');
+    assert.equal(resolved.port, 5761);
+    assert.equal(resolved.offset, 1);
+    assert.deepEqual(portFree.seen, [5760, 5761]);
+  }
+  // C: unreachable preferred port skips three busy ports before picking the fourth.
+  {
+    const probe = countingProbe('unreachable');
+    const portFree = countingPortFree(port => port === 8790);
+    const resolved = await resolveModuleUrl({ kind: 'vector-hub', preferredUrl: 'http://127.0.0.1:8787', explicit: false, portFree: portFree.portFree, probe: probe.probe });
+    assert.equal(resolved.source, 'dynamic');
+    assert.equal(resolved.url, 'http://127.0.0.1:8790');
+    assert.equal(resolved.port, 8790);
+    assert.equal(resolved.offset, 3);
+    assert.deepEqual(portFree.seen, [8787, 8788, 8789, 8790]);
+  }
+  // D: exhausted scan range fails loudly with kind and port span in the message.
+  {
+    const probe = countingProbe('unreachable');
+    const portFree = countingPortFree(() => false);
+    await assert.rejects(
+      () => resolveModuleUrl({ kind: 'event-bridge', preferredUrl: 'http://127.0.0.1:8790', explicit: false, portFree: portFree.portFree, probe: probe.probe }),
+      error => {
+        assert.equal(error.code, 'NO_FREE_MODULE_PORT');
+        assert.ok(error.message.includes('event-bridge'), `message must name the module kind: ${error.message}`);
+        assert.ok(error.message.includes('8790'), `message must name the first scanned port: ${error.message}`);
+        assert.ok(error.message.includes('8809'), `message must name the last scanned port: ${error.message}`);
+        return true;
+      },
+    );
+    assert.equal(portFree.calls, 20, 'default scanRange must probe 20 consecutive ports before failing');
+    assert.deepEqual(portFree.seen, Array.from({ length: 20 }, (_, index) => 8790 + index));
+  }
+  // E: an explicit external URL short-circuits before any probe or port scan.
+  {
+    const probe = countingProbe('module');
+    const portFree = countingPortFree(() => true);
+    const resolved = await resolveModuleUrl({ kind: 'knowledge-engine', preferredUrl: 'http://192.168.1.5:5790', explicit: true, portFree: portFree.portFree, probe: probe.probe });
+    assert.equal(resolved.source, 'external');
+    assert.equal(resolved.url, 'http://192.168.1.5:5790');
+    assert.equal(probe.calls, 0, 'explicit external URL must never be probed');
+    assert.equal(portFree.calls, 0, 'explicit external URL must never trigger a port scan');
+  }
+  // F: a preferred URL without an explicit port is rejected.
+  {
+    const probe = countingProbe('module');
+    const portFree = countingPortFree(() => true);
+    await assert.rejects(
+      () => resolveModuleUrl({ kind: 'terminal', preferredUrl: 'http://127.0.0.1', explicit: false, portFree: portFree.portFree, probe: probe.probe }),
+      error => { assert.equal(error.code, 'INVALID_MODULE_URL'); return true; },
+    );
+  }
+  // G (integration): an HTTP service squatting on the preferred port with
+  // 404 responses — exactly what happens when the shell's own fallback range
+  // 5757..5776 lands on the terminal default 5760 — must not be misread as a
+  // module and must not crash-loop: the bridge moves to the next free port.
+  {
+    const squatter = http.createServer((req, res) => { res.writeHead(404, { 'Content-Type': 'application/json' }); res.end(JSON.stringify({ error: 'not found' })); });
+    await new Promise(resolve => squatter.listen(0, '127.0.0.1', resolve));
+    const squatterPort = squatter.address().port;
+    const bridge = new ModuleBridge();
+    // Isolate the terminal leg: everything else is explicit/external so the
+    // resolution loop only probes the squatter port for the terminal kind.
+    bridge.terminalUrl = `http://127.0.0.1:${squatterPort}`;
+    bridge.explicitModuleUrls = { terminal: false, vectorHub: true, eventBridge: true, engine: true };
+    try {
+      await bridge._resolveManagedUrls();
+      assert.equal(bridge.moduleUrlSources.terminal, 'dynamic', '404 squatter must force a dynamic move, never reuse');
+      assert.equal(bridge.terminalUrl, `http://127.0.0.1:${squatterPort + 1}`, 'module moves to the port right after the squatter');
+    } finally {
+      squatter.closeAllConnections?.();
+      await new Promise(resolve => squatter.close(resolve));
+    }
+  }
+  console.log('module dynamic port test PASS');
+})().catch(error => { console.error(error); process.exitCode = 1; });

package/_site/_test/module-index-proxy-test.js

@@ -1,33 +1,33 @@
-'use strict';
-const assert = require('node:assert/strict');
-const http = require('node:http');
-const { ModuleBridge } = require('../lib/module-bridge');
-(async () => {
-  const upstream = http.createServer((req, res) => {
-    const timer = setTimeout(() => { res.writeHead(200, { 'Content-Type': 'application/json' }); res.end('{"ok":true}'); }, 75);
-    res.on('close', () => clearTimeout(timer));
-  });
-  await new Promise(resolve => upstream.listen(0, '127.0.0.1', resolve));
-  const bridge = new ModuleBridge({ vectorHubUrl: `http://127.0.0.1:${upstream.address().port}` });
-  const timer = global.setTimeout;
-  const budgets = [];
-  // Scale only the two product deadlines, preserving real HTTP cancellation.
-  global.setTimeout = (fn, ms, ...args) => {
-    if (ms === 10000 || ms === 120000) { budgets.push(ms); return timer(fn, ms === 10000 ? 25 : 500, ...args); }
-    return timer(fn, ms, ...args);
-  };
-  const server = http.createServer((req, res) => bridge.proxy(req, res, `http://127.0.0.1:${upstream.address().port}${req.url}`));
-  await new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
-  try {
-    const base = `http://127.0.0.1:${server.address().port}`;
-    const indexed = await fetch(`${base}/api/sync`, { method: 'POST', body: '{}' });
-    assert.equal(indexed.status, 200, 'a real embedding pass must use the engine indexing budget rather than the interactive deadline');
-    assert.equal(budgets[0], 120000);
-    const health = await fetch(`${base}/api/health`);
-    assert.equal(health.status, 502, 'ordinary reads keep their bounded interactive deadline');
-    console.log('module-index-proxy-test PASS');
-  } finally {
-    global.setTimeout = timer;
-    for (const s of [server, upstream]) { s.closeAllConnections(); await new Promise(resolve => s.close(resolve)); }
-  }
-})().catch(error => { console.error(error); process.exitCode = 1; });
+'use strict';
+const assert = require('node:assert/strict');
+const http = require('node:http');
+const { ModuleBridge } = require('../lib/module-bridge');
+(async () => {
+  const upstream = http.createServer((req, res) => {
+    const timer = setTimeout(() => { res.writeHead(200, { 'Content-Type': 'application/json' }); res.end('{"ok":true}'); }, 75);
+    res.on('close', () => clearTimeout(timer));
+  });
+  await new Promise(resolve => upstream.listen(0, '127.0.0.1', resolve));
+  const bridge = new ModuleBridge({ vectorHubUrl: `http://127.0.0.1:${upstream.address().port}` });
+  const timer = global.setTimeout;
+  const budgets = [];
+  // Scale only the two product deadlines, preserving real HTTP cancellation.
+  global.setTimeout = (fn, ms, ...args) => {
+    if (ms === 10000 || ms === 120000) { budgets.push(ms); return timer(fn, ms === 10000 ? 25 : 500, ...args); }
+    return timer(fn, ms, ...args);
+  };
+  const server = http.createServer((req, res) => bridge.proxy(req, res, `http://127.0.0.1:${upstream.address().port}${req.url}`));
+  await new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
+  try {
+    const base = `http://127.0.0.1:${server.address().port}`;
+    const indexed = await fetch(`${base}/api/sync`, { method: 'POST', body: '{}' });
+    assert.equal(indexed.status, 200, 'a real embedding pass must use the engine indexing budget rather than the interactive deadline');
+    assert.equal(budgets[0], 120000);
+    const health = await fetch(`${base}/api/health`);
+    assert.equal(health.status, 502, 'ordinary reads keep their bounded interactive deadline');
+    console.log('module-index-proxy-test PASS');
+  } finally {
+    global.setTimeout = timer;
+    for (const s of [server, upstream]) { s.closeAllConnections(); await new Promise(resolve => s.close(resolve)); }
+  }
+})().catch(error => { console.error(error); process.exitCode = 1; });

package/_site/_test/module-model-configuration-test.js

@@ -1,44 +1,44 @@
-'use strict';
-const assert = require('node:assert/strict');
-const http = require('node:http');
-const { ModuleBridge } = require('../lib/module-bridge');
-(async () => {
-  let profile = { apiKey: 'controlled-model-key', mainModel: 'durable-default' };
-  let settings = { provider: 'openai', apiKey: 'controlled-vector-key', model: 'embedding-model' };
-  let appliedModel, appliedVector; const hits = [];
-  const migrationId = `embedding-${'a'.repeat(64)}`;
-  let legacy = { provider: 'minimax', apiKey: 'controlled-legacy-key', model: 'embo-01' };
-  const service = http.createServer((req, res) => {
-    assert.equal(req.headers.authorization, 'Bearer runtime-test');
-    assert.equal(req.headers.origin, undefined);
-    let input = ''; req.on('data', c => { input += c; });
-    req.on('end', () => {
-      hits.push(req.url); const body = JSON.parse(input || '{}');
-      let result = { ok: true }; let status = 200;
-      if (req.url.endsWith('/internal/maintenance-config')) { result = profile; if (!profile) status = 409; }
-      else if (req.url === '/api/internal/embedding-config') result = { settings: legacy, migrationId };
-      else if (req.url.endsWith('/internal/import-embedding')) { assert.equal(body.settings.apiKey, 'controlled-legacy-key'); }
-      else if (req.url === '/api/internal/retire-embedding') { assert.equal(body.migrationId, migrationId); legacy = null; }
-      else if (req.url.endsWith('/v1/internal/embedding-config')) { result = settings; if (!settings) status = 409; }
-      else if (req.url === '/api/internal/runtime-config') appliedVector = body.settings;
-      else if (req.url === '/api/runtime-config') appliedModel = body.profile;
-      res.writeHead(status, { 'Content-Type': 'application/json' }); res.end(JSON.stringify(result || {}));
-    });
-  });
-  await new Promise(resolve => service.listen(0, '127.0.0.1', resolve));
-  const url = `http://127.0.0.1:${service.address().port}`;
-  const bridge = new ModuleBridge({ terminalUrl: url, engineUrl: url, vectorHubUrl: url, runtimeToken: 'runtime-test' });
-  try {
-    const status = await bridge.syncEngineConfiguration();
-    assert.equal(status.model, true); assert.equal(status.embedding, true);
-    assert.equal(appliedModel.mainModel, 'durable-default'); assert.equal(appliedVector.model, 'embedding-model');
-    assert.ok(!JSON.stringify(status).includes('key'));
-    assert.ok(!hits.some(route => /import-embedding|retire-embedding/.test(route)), 'fresh product must not import old credentials');
-    assert.ok(!hits.includes('/api/internal/embedding-config'));
-    profile = null; settings = null;
-    const revoked = await bridge.syncEngineConfiguration();
-    assert.equal(revoked.model, false); assert.equal(revoked.embedding, false);
-    assert.equal(appliedModel, null); assert.equal(appliedVector, null);
-    console.log('module-model-configuration-test PASS');
-  } finally { service.closeAllConnections(); await new Promise(resolve => service.close(resolve)); }
-})().catch(error => { console.error(error); process.exitCode = 1; });
+'use strict';
+const assert = require('node:assert/strict');
+const http = require('node:http');
+const { ModuleBridge } = require('../lib/module-bridge');
+(async () => {
+  let profile = { apiKey: 'controlled-model-key', mainModel: 'durable-default' };
+  let settings = { provider: 'openai', apiKey: 'controlled-vector-key', model: 'embedding-model' };
+  let appliedModel, appliedVector; const hits = [];
+  const migrationId = `embedding-${'a'.repeat(64)}`;
+  let legacy = { provider: 'minimax', apiKey: 'controlled-legacy-key', model: 'embo-01' };
+  const service = http.createServer((req, res) => {
+    assert.equal(req.headers.authorization, 'Bearer runtime-test');
+    assert.equal(req.headers.origin, undefined);
+    let input = ''; req.on('data', c => { input += c; });
+    req.on('end', () => {
+      hits.push(req.url); const body = JSON.parse(input || '{}');
+      let result = { ok: true }; let status = 200;
+      if (req.url.endsWith('/internal/maintenance-config')) { result = profile; if (!profile) status = 409; }
+      else if (req.url === '/api/internal/embedding-config') result = { settings: legacy, migrationId };
+      else if (req.url.endsWith('/internal/import-embedding')) { assert.equal(body.settings.apiKey, 'controlled-legacy-key'); }
+      else if (req.url === '/api/internal/retire-embedding') { assert.equal(body.migrationId, migrationId); legacy = null; }
+      else if (req.url.endsWith('/v1/internal/embedding-config')) { result = settings; if (!settings) status = 409; }
+      else if (req.url === '/api/internal/runtime-config') appliedVector = body.settings;
+      else if (req.url === '/api/runtime-config') appliedModel = body.profile;
+      res.writeHead(status, { 'Content-Type': 'application/json' }); res.end(JSON.stringify(result || {}));
+    });
+  });
+  await new Promise(resolve => service.listen(0, '127.0.0.1', resolve));
+  const url = `http://127.0.0.1:${service.address().port}`;
+  const bridge = new ModuleBridge({ terminalUrl: url, engineUrl: url, vectorHubUrl: url, runtimeToken: 'runtime-test' });
+  try {
+    const status = await bridge.syncEngineConfiguration();
+    assert.equal(status.model, true); assert.equal(status.embedding, true);
+    assert.equal(appliedModel.mainModel, 'durable-default'); assert.equal(appliedVector.model, 'embedding-model');
+    assert.ok(!JSON.stringify(status).includes('key'));
+    assert.ok(!hits.some(route => /import-embedding|retire-embedding/.test(route)), 'fresh product must not import old credentials');
+    assert.ok(!hits.includes('/api/internal/embedding-config'));
+    profile = null; settings = null;
+    const revoked = await bridge.syncEngineConfiguration();
+    assert.equal(revoked.model, false); assert.equal(revoked.embedding, false);
+    assert.equal(appliedModel, null); assert.equal(appliedVector, null);
+    console.log('module-model-configuration-test PASS');
+  } finally { service.closeAllConnections(); await new Promise(resolve => service.close(resolve)); }
+})().catch(error => { console.error(error); process.exitCode = 1; });

package/_site/_test/module-process-lifecycle-test.js

@@ -1,35 +1,35 @@
-'use strict';
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-const assert = require('node:assert/strict');
-const { ModuleBridge } = require('../lib/module-bridge');
-(async () => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'kb-supervisor-lifecycle-'));
-  const fixture = path.join(root, '中文 module.js'), result = path.join(root, 'stopped.json');
-  fs.writeFileSync(fixture, "const fs=require('fs');process.on('message',m=>{if(m.type==='kb:shutdown'){fs.writeFileSync(process.argv[2],JSON.stringify({arg:process.argv[3],stopped:true}));process.exit(0);}});process.send({ready:true});");
-  const bridge = new ModuleBridge();
-  bridge._spawnSupervised({ name: 'fixture', command: `node ${JSON.stringify(fixture)} ${JSON.stringify(result)} ${JSON.stringify('中文 argument with spaces')} ` });
-  const child = bridge.supervised[0];
-  await new Promise((resolve, reject) => { child.once('message', resolve); child.once('error', reject); });
-  await bridge.stopSupervised();
-  assert.equal(child.exitCode, 0, 'IPC shutdown must finish before the shell releases its process');
-  assert.deepEqual(JSON.parse(fs.readFileSync(result)), { arg: '中文 argument with spaces', stopped: true });
-  const missing = new ModuleBridge();
-  missing._spawnSupervised({ name: 'missing', command: 'kb-definitely-missing-executable' });
-  await new Promise(resolve => setTimeout(resolve, 100));
-  assert.equal(missing.supervised.length, 0, 'failed process start must not crash or leave a false running module');
-  await missing.stopSupervised();
-  const { Logger, LogRepository } = require('../lib/structured-logger');
-  const { StorageLayout } = require('../lib/storage-layout');
-  const layout = new StorageLayout({ dataDir: path.join(root, 'data') }); const logger = new Logger({ layout });
-  const diagnosticFixture = path.join(root, 'diagnostic.js');
-  fs.writeFileSync(diagnosticFixture, "process.on('message',m=>{if(m.type==='kb:shutdown')process.exit(0)});process.send({type:'kb:diagnostic',record:{level:'error',event:'knowledge.maintenance.failed',message:'维护失败',projectId:'project-diagnostic',commitSha:'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',phase:'validating',error:{code:'ANALYSIS_EMPTY_DOCUMENT',message:'知识文档正文为空'}}});");
-  const supervised = new ModuleBridge({ logger }); supervised._spawnSupervised({ name: 'knowledge-engine', command: `node ${JSON.stringify(diagnosticFixture)}` });
-  await new Promise((resolve, reject) => { supervised.supervised[0].once('message', resolve); supervised.supervised[0].once('error', reject); });
-  await logger.flush();
-  const records = new LogRepository({ layout }).query({ commitSha: 'a'.repeat(40) }).entries;
-  assert(records.some(record => record.event === 'knowledge.maintenance.failed' && record.error.message === '知识文档正文为空' && record.phase === 'validating'));
-  await supervised.stopSupervised(); await logger.close();
-  console.log('module process lifecycle test PASS');
-})().catch(error => { console.error(error); process.exitCode = 1; });
+'use strict';
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const assert = require('node:assert/strict');
+const { ModuleBridge } = require('../lib/module-bridge');
+(async () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'kb-supervisor-lifecycle-'));
+  const fixture = path.join(root, '中文 module.js'), result = path.join(root, 'stopped.json');
+  fs.writeFileSync(fixture, "const fs=require('fs');process.on('message',m=>{if(m.type==='kb:shutdown'){fs.writeFileSync(process.argv[2],JSON.stringify({arg:process.argv[3],stopped:true}));process.exit(0);}});process.send({ready:true});");
+  const bridge = new ModuleBridge();
+  bridge._spawnSupervised({ name: 'fixture', command: `node ${JSON.stringify(fixture)} ${JSON.stringify(result)} ${JSON.stringify('中文 argument with spaces')} ` });
+  const child = bridge.supervised[0];
+  await new Promise((resolve, reject) => { child.once('message', resolve); child.once('error', reject); });
+  await bridge.stopSupervised();
+  assert.equal(child.exitCode, 0, 'IPC shutdown must finish before the shell releases its process');
+  assert.deepEqual(JSON.parse(fs.readFileSync(result)), { arg: '中文 argument with spaces', stopped: true });
+  const missing = new ModuleBridge();
+  missing._spawnSupervised({ name: 'missing', command: 'kb-definitely-missing-executable' });
+  await new Promise(resolve => setTimeout(resolve, 100));
+  assert.equal(missing.supervised.length, 0, 'failed process start must not crash or leave a false running module');
+  await missing.stopSupervised();
+  const { Logger, LogRepository } = require('../lib/structured-logger');
+  const { StorageLayout } = require('../lib/storage-layout');
+  const layout = new StorageLayout({ dataDir: path.join(root, 'data') }); const logger = new Logger({ layout });
+  const diagnosticFixture = path.join(root, 'diagnostic.js');
+  fs.writeFileSync(diagnosticFixture, "process.on('message',m=>{if(m.type==='kb:shutdown')process.exit(0)});process.send({type:'kb:diagnostic',record:{level:'error',event:'knowledge.maintenance.failed',message:'维护失败',projectId:'project-diagnostic',commitSha:'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',phase:'validating',error:{code:'ANALYSIS_EMPTY_DOCUMENT',message:'知识文档正文为空'}}});");
+  const supervised = new ModuleBridge({ logger }); supervised._spawnSupervised({ name: 'knowledge-engine', command: `node ${JSON.stringify(diagnosticFixture)}` });
+  await new Promise((resolve, reject) => { supervised.supervised[0].once('message', resolve); supervised.supervised[0].once('error', reject); });
+  await logger.flush();
+  const records = new LogRepository({ layout }).query({ commitSha: 'a'.repeat(40) }).entries;
+  assert(records.some(record => record.event === 'knowledge.maintenance.failed' && record.error.message === '知识文档正文为空' && record.phase === 'validating'));
+  await supervised.stopSupervised(); await logger.close();
+  console.log('module process lifecycle test PASS');
+})().catch(error => { console.error(error); process.exitCode = 1; });

package/_site/_test/module-stream-proxy-test.js

@@ -1,34 +1,34 @@
-'use strict';
-const assert = require('node:assert/strict');
-const http = require('node:http');
-const { ModuleBridge } = require('../lib/module-bridge');
-
-(async () => {
-  let disconnected = false; let cursor;
-  const upstream = http.createServer((req, res) => {
-    cursor = req.headers['last-event-id'];
-    res.writeHead(200, { 'Content-Type': 'text/event-stream' });
-    res.write('id: 8\nevent: delta\ndata: {"text":"first"}\n\n');
-    const timer = setInterval(() => res.write(': live\n\n'), 100);
-    res.on('close', () => { clearInterval(timer); disconnected = true; });
-  });
-  await new Promise(resolve => upstream.listen(0, '127.0.0.1', resolve));
-  const bridge = new ModuleBridge();
-  const shell = http.createServer((req, res) => bridge.proxy(req, res, `http://127.0.0.1:${upstream.address().port}/events`));
-  await new Promise(resolve => shell.listen(0, '127.0.0.1', resolve));
-  const abort = new AbortController();
-  try {
-    const response = await fetch(`http://127.0.0.1:${shell.address().port}/events`, { headers: { 'Last-Event-ID': '7' }, signal: abort.signal });
-    const reader = response.body.getReader();
-    const first = await Promise.race([reader.read(), new Promise((_, reject) => setTimeout(() => reject(new Error('SSE was buffered')), 1500))]);
-    assert.match(Buffer.from(first.value).toString(), /first/);
-    assert.equal(cursor, '7');
-    abort.abort();
-    for (let i = 0; i < 40 && !disconnected; i++) await new Promise(resolve => setTimeout(resolve, 25));
-    assert.equal(disconnected, true, 'browser disconnect releases upstream');
-    console.log('module-stream-proxy-test PASS');
-  } finally {
-    abort.abort();
-    for (const server of [shell, upstream]) { server.closeAllConnections(); await new Promise(resolve => server.close(resolve)); }
-  }
-})().catch(error => { console.error(error); process.exitCode = 1; });
+'use strict';
+const assert = require('node:assert/strict');
+const http = require('node:http');
+const { ModuleBridge } = require('../lib/module-bridge');
+
+(async () => {
+  let disconnected = false; let cursor;
+  const upstream = http.createServer((req, res) => {
+    cursor = req.headers['last-event-id'];
+    res.writeHead(200, { 'Content-Type': 'text/event-stream' });
+    res.write('id: 8\nevent: delta\ndata: {"text":"first"}\n\n');
+    const timer = setInterval(() => res.write(': live\n\n'), 100);
+    res.on('close', () => { clearInterval(timer); disconnected = true; });
+  });
+  await new Promise(resolve => upstream.listen(0, '127.0.0.1', resolve));
+  const bridge = new ModuleBridge();
+  const shell = http.createServer((req, res) => bridge.proxy(req, res, `http://127.0.0.1:${upstream.address().port}/events`));
+  await new Promise(resolve => shell.listen(0, '127.0.0.1', resolve));
+  const abort = new AbortController();
+  try {
+    const response = await fetch(`http://127.0.0.1:${shell.address().port}/events`, { headers: { 'Last-Event-ID': '7' }, signal: abort.signal });
+    const reader = response.body.getReader();
+    const first = await Promise.race([reader.read(), new Promise((_, reject) => setTimeout(() => reject(new Error('SSE was buffered')), 1500))]);
+    assert.match(Buffer.from(first.value).toString(), /first/);
+    assert.equal(cursor, '7');
+    abort.abort();
+    for (let i = 0; i < 40 && !disconnected; i++) await new Promise(resolve => setTimeout(resolve, 25));
+    assert.equal(disconnected, true, 'browser disconnect releases upstream');
+    console.log('module-stream-proxy-test PASS');
+  } finally {
+    abort.abort();
+    for (const server of [shell, upstream]) { server.closeAllConnections(); await new Promise(resolve => server.close(resolve)); }
+  }
+})().catch(error => { console.error(error); process.exitCode = 1; });