@sanqianx/project-knowledge 5.0.18 → 5.0.20-rc.1

package/_site/_test/team-knowledge-store-test.js

@@ -1,132 +1,132 @@
-const assert = require('assert');
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-const { execFileSync } = require('child_process');
-const { spawnServer } = require('./helpers/spawn-server');
-const freePort = require('./helpers/free-port');
-const githubTeamStore = require('../lib/github-team-store');
-
-const ROOT = path.resolve(__dirname, '..', '..');
-let PORT, BASE_URL;
-const TEMP = fs.mkdtempSync(path.join(os.tmpdir(), `kb-team-v2-${process.pid}-`));
-const DATA_DIR = path.join(TEMP, 'data');
-const SOURCE_ONE = path.join(TEMP, 'source-one');
-const SOURCE_TWO = path.join(TEMP, 'source-two');
-const SOURCE_BAD = path.join(TEMP, 'source-bad');
-const TEAM_STORE = path.join(TEMP, 'team-store');
-const TEAM_REMOTE = path.join(TEMP, 'team-remote');
-const TEAM_CLONE = path.join(TEMP, 'team-clone');
-
-function git(cwd, args) {
-  return execFileSync('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim();
-}
-
-function initializeRepo(cwd, title) {
-  fs.mkdirSync(cwd, { recursive: true });
-  git(cwd, ['init', '--initial-branch=main']);
-  git(cwd, ['config', 'user.name', 'Team Test']);
-  git(cwd, ['config', 'user.email', 'team@example.test']);
-  fs.writeFileSync(path.join(cwd, 'README.md'), `# ${title}\n`, 'utf8');
-  git(cwd, ['add', '.']);
-  git(cwd, ['commit', '-m', 'baseline']);
-}
-
-async function waitForServer() {
-  for (let attempt = 0; attempt < 100; attempt += 1) {
-    try { if ((await fetch(`${BASE_URL}/api/health`)).ok) return; } catch {}
-    await new Promise(resolve => setTimeout(resolve, 100));
-  }
-  throw new Error('server did not start');
-}
-
-async function json(method, route, body) {
-  const response = await fetch(`${BASE_URL}${route}`, {
-    method,
-    headers: body ? { 'Content-Type': 'application/json' } : undefined,
-    body: body ? JSON.stringify(body) : undefined,
-  });
-  const text = await response.text();
-  return { response, body: text ? JSON.parse(text) : {} };
-}
-
-(async () => {
-  PORT = process.env.KB_TEAM_KNOWLEDGE_PORT ? Number(process.env.KB_TEAM_KNOWLEDGE_PORT) : await freePort(); BASE_URL = `http://127.0.0.1:${PORT}`;
-  let spawned;
-  try {
-    initializeRepo(SOURCE_ONE, 'Source one');
-    initializeRepo(SOURCE_TWO, 'Source two');
-    initializeRepo(SOURCE_BAD, 'Source bad');
-    initializeRepo(TEAM_STORE, 'Team store');
-    fs.mkdirSync(path.join(TEAM_STORE, 'acc'), { recursive: true });
-    fs.writeFileSync(path.join(TEAM_STORE, 'acc', 'README.md'), '# ACC shared knowledge\n', 'utf8');
-    git(TEAM_STORE, ['add', '.']);
-    git(TEAM_STORE, ['commit', '-m', 'add team knowledge']);
-    git(TEAM_STORE, ['remote', 'add', 'origin', TEAM_STORE]);
-
-    initializeRepo(TEAM_REMOTE, 'Remote team store');
-    fs.mkdirSync(path.join(TEAM_REMOTE, 'acc'), { recursive: true });
-    fs.writeFileSync(path.join(TEAM_REMOTE, 'acc', 'README.md'), '# ACC from remote\n', 'utf8');
-    git(TEAM_REMOTE, ['add', '.']);
-    git(TEAM_REMOTE, ['commit', '-m', 'add remote knowledge']);
-
-    const providerConfigPath = path.join(TEMP, 'providers.json');
-    fs.writeFileSync(providerConfigPath, `\uFEFF${JSON.stringify({ gitea: { webBaseUrl: 'https://gitea.example.test', oauthClientId: 'client', oauthClientSecret: 'secret' } })}`, 'utf8');
-    const providerFile = githubTeamStore.readProviderFileConfig(providerConfigPath);
-    const publicProviders = githubTeamStore.providerPublicConfig(githubTeamStore.defaultConfig(), {}, providerFile);
-    assert.strictEqual(publicProviders.gitea.configured, true);
-    assert.strictEqual(publicProviders.gitea.oauthClientSecret, undefined);
-    assert.strictEqual(publicProviders.gitea.oauthClientSecretConfigured, true);
-    assert.strictEqual(githubTeamStore.proxyUrlForTarget('http://127.0.0.1:3000/api/v1/user', { KB_GIT_PROXY: 'http://127.0.0.1:7890' }), '');
-
-    const scanned = await githubTeamStore.scanLocalStore({ localPath: TEAM_STORE });
-    assert(scanned.ok && scanned.store.knowledgeBases.some(item => item.path === 'acc'), JSON.stringify(scanned));
-    const checkedOut = await githubTeamStore.checkoutStore({ cloneUrl: TEAM_REMOTE, branch: 'main', localPath: TEAM_CLONE });
-    assert(checkedOut.ok, JSON.stringify(checkedOut));
-    assert.match(fs.readFileSync(path.join(TEAM_CLONE, 'acc', 'README.md'), 'utf8'), /from remote/);
-
-    spawned = spawnServer({ root: ROOT, port: PORT, dataDir: DATA_DIR, tag: 'team-kb-v2' });
-    let output = '';
-    spawned.child.stdout.on('data', chunk => { output += chunk; });
-    spawned.child.stderr.on('data', chunk => { output += chunk; });
-    await waitForServer();
-    let result = await json('PATCH', '/api/settings', { knowledge: { rootPath: path.join(TEMP, 'personal-knowledge') } });
-    assert(result.response.ok, JSON.stringify(result.body));
-
-    result = await json('POST', '/api/projects/import', {
-      projectId: 'team-project-one', localPath: SOURCE_ONE,
-      teamKnowledgeBase: {
-        storeLocalPath: TEAM_STORE, storeRemoteUrl: 'https://github.com/org/knowledge.git',
-        storeFullName: 'org/knowledge', storeId: 'team-store', kbId: 'kb-acc', kbSlug: 'acc', kbSubdir: 'acc', displayName: 'ACC',
-      },
-    });
-    assert.strictEqual(result.response.status, 201, `${JSON.stringify(result.body)}\n${output}`);
-    assert.strictEqual(path.resolve(result.body.config.knowledgePath), path.resolve(TEAM_STORE, 'acc'));
-    assert.strictEqual(result.body.config.teamBinding.provider, 'github');
-    assert.strictEqual(result.body.config.teamBinding.kbId, 'kb-acc');
-    assert.strictEqual(result.body.config.teamBinding.kbSubdir, 'acc');
-    const registryText = fs.readFileSync(path.join(DATA_DIR, 'projects.json'), 'utf8');
-    assert(!registryText.includes(TEAM_STORE), 'minimal v2 registry must not contain the external team path');
-
-    result = await json('POST', '/api/projects/import', {
-      projectId: 'team-project-bad', localPath: SOURCE_BAD,
-      teamKnowledgeBase: { storeLocalPath: TEAM_STORE, kbSubdir: '../escape' },
-    });
-    assert.strictEqual(result.response.status, 403, 'team binding traversal must be rejected');
-
-    result = await json('POST', '/api/projects/import', {
-      projectId: 'team-project-two', localPath: SOURCE_TWO,
-      teamKnowledgeBase: { storeLocalPath: TEAM_CLONE, storeRemoteUrl: TEAM_REMOTE, storeId: 'clone', kbId: 'kb-acc', kbSubdir: 'acc' },
-    });
-    assert.strictEqual(result.response.status, 201, JSON.stringify(result.body));
-    assert.strictEqual(path.resolve(result.body.config.knowledgePath), path.resolve(TEAM_CLONE, 'acc'));
-
-    result = await json('DELETE', '/api/projects/team-project-one', { deleteKnowledge: true, confirmationToken: 'team-project-one' });
-    assert(result.response.ok, JSON.stringify(result.body));
-    assert.strictEqual(result.body.removedKnowledge, false, 'team knowledge is externally owned');
-    assert(fs.existsSync(path.join(TEAM_STORE, 'acc', 'README.md')), 'team knowledge must survive project deletion');
-    console.log('team knowledge store test passed');
-  } finally {
-    if (spawned) spawned.child.kill();
-  }
-})().catch(error => { console.error(error); process.exitCode = 1; });
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execFileSync } = require('child_process');
+const { spawnServer } = require('./helpers/spawn-server');
+const freePort = require('./helpers/free-port');
+const githubTeamStore = require('../lib/github-team-store');
+
+const ROOT = path.resolve(__dirname, '..', '..');
+let PORT, BASE_URL;
+const TEMP = fs.mkdtempSync(path.join(os.tmpdir(), `kb-team-v2-${process.pid}-`));
+const DATA_DIR = path.join(TEMP, 'data');
+const SOURCE_ONE = path.join(TEMP, 'source-one');
+const SOURCE_TWO = path.join(TEMP, 'source-two');
+const SOURCE_BAD = path.join(TEMP, 'source-bad');
+const TEAM_STORE = path.join(TEMP, 'team-store');
+const TEAM_REMOTE = path.join(TEMP, 'team-remote');
+const TEAM_CLONE = path.join(TEMP, 'team-clone');
+
+function git(cwd, args) {
+  return execFileSync('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim();
+}
+
+function initializeRepo(cwd, title) {
+  fs.mkdirSync(cwd, { recursive: true });
+  git(cwd, ['init', '--initial-branch=main']);
+  git(cwd, ['config', 'user.name', 'Team Test']);
+  git(cwd, ['config', 'user.email', 'team@example.test']);
+  fs.writeFileSync(path.join(cwd, 'README.md'), `# ${title}\n`, 'utf8');
+  git(cwd, ['add', '.']);
+  git(cwd, ['commit', '-m', 'baseline']);
+}
+
+async function waitForServer() {
+  for (let attempt = 0; attempt < 100; attempt += 1) {
+    try { if ((await fetch(`${BASE_URL}/api/health`)).ok) return; } catch {}
+    await new Promise(resolve => setTimeout(resolve, 100));
+  }
+  throw new Error('server did not start');
+}
+
+async function json(method, route, body) {
+  const response = await fetch(`${BASE_URL}${route}`, {
+    method,
+    headers: body ? { 'Content-Type': 'application/json' } : undefined,
+    body: body ? JSON.stringify(body) : undefined,
+  });
+  const text = await response.text();
+  return { response, body: text ? JSON.parse(text) : {} };
+}
+
+(async () => {
+  PORT = process.env.KB_TEAM_KNOWLEDGE_PORT ? Number(process.env.KB_TEAM_KNOWLEDGE_PORT) : await freePort(); BASE_URL = `http://127.0.0.1:${PORT}`;
+  let spawned;
+  try {
+    initializeRepo(SOURCE_ONE, 'Source one');
+    initializeRepo(SOURCE_TWO, 'Source two');
+    initializeRepo(SOURCE_BAD, 'Source bad');
+    initializeRepo(TEAM_STORE, 'Team store');
+    fs.mkdirSync(path.join(TEAM_STORE, 'acc'), { recursive: true });
+    fs.writeFileSync(path.join(TEAM_STORE, 'acc', 'README.md'), '# ACC shared knowledge\n', 'utf8');
+    git(TEAM_STORE, ['add', '.']);
+    git(TEAM_STORE, ['commit', '-m', 'add team knowledge']);
+    git(TEAM_STORE, ['remote', 'add', 'origin', TEAM_STORE]);
+
+    initializeRepo(TEAM_REMOTE, 'Remote team store');
+    fs.mkdirSync(path.join(TEAM_REMOTE, 'acc'), { recursive: true });
+    fs.writeFileSync(path.join(TEAM_REMOTE, 'acc', 'README.md'), '# ACC from remote\n', 'utf8');
+    git(TEAM_REMOTE, ['add', '.']);
+    git(TEAM_REMOTE, ['commit', '-m', 'add remote knowledge']);
+
+    const providerConfigPath = path.join(TEMP, 'providers.json');
+    fs.writeFileSync(providerConfigPath, `\uFEFF${JSON.stringify({ gitea: { webBaseUrl: 'https://gitea.example.test', oauthClientId: 'client', oauthClientSecret: 'secret' } })}`, 'utf8');
+    const providerFile = githubTeamStore.readProviderFileConfig(providerConfigPath);
+    const publicProviders = githubTeamStore.providerPublicConfig(githubTeamStore.defaultConfig(), {}, providerFile);
+    assert.strictEqual(publicProviders.gitea.configured, true);
+    assert.strictEqual(publicProviders.gitea.oauthClientSecret, undefined);
+    assert.strictEqual(publicProviders.gitea.oauthClientSecretConfigured, true);
+    assert.strictEqual(githubTeamStore.proxyUrlForTarget('http://127.0.0.1:3000/api/v1/user', { KB_GIT_PROXY: 'http://127.0.0.1:7890' }), '');
+
+    const scanned = await githubTeamStore.scanLocalStore({ localPath: TEAM_STORE });
+    assert(scanned.ok && scanned.store.knowledgeBases.some(item => item.path === 'acc'), JSON.stringify(scanned));
+    const checkedOut = await githubTeamStore.checkoutStore({ cloneUrl: TEAM_REMOTE, branch: 'main', localPath: TEAM_CLONE });
+    assert(checkedOut.ok, JSON.stringify(checkedOut));
+    assert.match(fs.readFileSync(path.join(TEAM_CLONE, 'acc', 'README.md'), 'utf8'), /from remote/);
+
+    spawned = spawnServer({ root: ROOT, port: PORT, dataDir: DATA_DIR, tag: 'team-kb-v2' });
+    let output = '';
+    spawned.child.stdout.on('data', chunk => { output += chunk; });
+    spawned.child.stderr.on('data', chunk => { output += chunk; });
+    await waitForServer();
+    let result = await json('PATCH', '/api/settings', { knowledge: { rootPath: path.join(TEMP, 'personal-knowledge') } });
+    assert(result.response.ok, JSON.stringify(result.body));
+
+    result = await json('POST', '/api/projects/import', {
+      projectId: 'team-project-one', localPath: SOURCE_ONE,
+      teamKnowledgeBase: {
+        storeLocalPath: TEAM_STORE, storeRemoteUrl: 'https://github.com/org/knowledge.git',
+        storeFullName: 'org/knowledge', storeId: 'team-store', kbId: 'kb-acc', kbSlug: 'acc', kbSubdir: 'acc', displayName: 'ACC',
+      },
+    });
+    assert.strictEqual(result.response.status, 201, `${JSON.stringify(result.body)}\n${output}`);
+    assert.strictEqual(path.resolve(result.body.config.knowledgePath), path.resolve(TEAM_STORE, 'acc'));
+    assert.strictEqual(result.body.config.teamBinding.provider, 'github');
+    assert.strictEqual(result.body.config.teamBinding.kbId, 'kb-acc');
+    assert.strictEqual(result.body.config.teamBinding.kbSubdir, 'acc');
+    const registryText = fs.readFileSync(path.join(DATA_DIR, 'projects.json'), 'utf8');
+    assert(!registryText.includes(TEAM_STORE), 'minimal v2 registry must not contain the external team path');
+
+    result = await json('POST', '/api/projects/import', {
+      projectId: 'team-project-bad', localPath: SOURCE_BAD,
+      teamKnowledgeBase: { storeLocalPath: TEAM_STORE, kbSubdir: '../escape' },
+    });
+    assert.strictEqual(result.response.status, 403, 'team binding traversal must be rejected');
+
+    result = await json('POST', '/api/projects/import', {
+      projectId: 'team-project-two', localPath: SOURCE_TWO,
+      teamKnowledgeBase: { storeLocalPath: TEAM_CLONE, storeRemoteUrl: TEAM_REMOTE, storeId: 'clone', kbId: 'kb-acc', kbSubdir: 'acc' },
+    });
+    assert.strictEqual(result.response.status, 201, JSON.stringify(result.body));
+    assert.strictEqual(path.resolve(result.body.config.knowledgePath), path.resolve(TEAM_CLONE, 'acc'));
+
+    result = await json('DELETE', '/api/projects/team-project-one', { deleteKnowledge: true, confirmationToken: 'team-project-one' });
+    assert(result.response.ok, JSON.stringify(result.body));
+    assert.strictEqual(result.body.removedKnowledge, false, 'team knowledge is externally owned');
+    assert(fs.existsSync(path.join(TEAM_STORE, 'acc', 'README.md')), 'team knowledge must survive project deletion');
+    console.log('team knowledge store test passed');
+  } finally {
+    if (spawned) spawned.child.kill();
+  }
+})().catch(error => { console.error(error); process.exitCode = 1; });

package/_site/_test/test-server-cleanup-test.js

@@ -1,35 +1,35 @@
-'use strict';
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const path = require('node:path');
-const { spawnServer } = require('./helpers/spawn-server');
-const freePort = require('./helpers/free-port');
-const { readEndpoint } = require('../lib/runtime-endpoint');
-const { spawn } = require('node:child_process');
-
-(async () => {
-  const port = await freePort();
-  const spawned = spawnServer({ root: path.resolve(__dirname, '../..'), port, tag: 'graceful-cleanup' });
-  let stopped = false;
-  try {
-    for (let attempt = 0; attempt < 100; attempt++) {
-      const endpoint = readEndpoint(spawned.dataDir);
-      if (endpoint && (await fetch(`http://127.0.0.1:${port}/api/health`).catch(() => null))?.ok) break;
-      await new Promise(resolve => setTimeout(resolve, 100));
-    }
-    assert.equal(readEndpoint(spawned.dataDir)?.pid, spawned.child.pid);
-    let output = '';
-    spawned.child.stderr.on('data', bytes => { output += bytes; });
-    const locker = process.platform === 'win32' ? spawn(process.execPath, ['-e', 'process.stdout.write("holding-cwd\\n");setTimeout(()=>process.exit(0),2500)'], { cwd: spawned.dataDir, windowsHide: true, stdio: ['ignore', 'pipe', 'pipe'] }) : null;
-    if (locker) await new Promise((resolve, reject) => { locker.once('error', reject); locker.stdout.once('data', resolve); });
-    try { await spawned.cleanup(); stopped = true; }
-    finally { if (locker?.exitCode === null) { locker.kill(); await new Promise(resolve => locker.once('close', resolve)); } }
-    assert.notEqual(spawned.child.exitCode, null, output);
-    assert.equal(spawned.child.signalCode, null, 'normal cleanup must drain the server instead of force killing it');
-    assert.equal(spawned.child.exitCode, 0, output);
-    assert.ok(!fs.existsSync(spawned.dataDir));
-    assert.ok(!fs.existsSync(spawned.bridgeHome));
-    await assert.rejects(fetch(`http://127.0.0.1:${port}/api/health`));
-    console.log('test-server-cleanup-test PASS (verified graceful shutdown before fixture removal)');
-  } finally { if (!stopped) await spawned.cleanup(); }
-})().catch(error => { console.error(error); process.exitCode = 1; });
+'use strict';
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const { spawnServer } = require('./helpers/spawn-server');
+const freePort = require('./helpers/free-port');
+const { readEndpoint } = require('../lib/runtime-endpoint');
+const { spawn } = require('node:child_process');
+
+(async () => {
+  const port = await freePort();
+  const spawned = spawnServer({ root: path.resolve(__dirname, '../..'), port, tag: 'graceful-cleanup' });
+  let stopped = false;
+  try {
+    for (let attempt = 0; attempt < 100; attempt++) {
+      const endpoint = readEndpoint(spawned.dataDir);
+      if (endpoint && (await fetch(`http://127.0.0.1:${port}/api/health`).catch(() => null))?.ok) break;
+      await new Promise(resolve => setTimeout(resolve, 100));
+    }
+    assert.equal(readEndpoint(spawned.dataDir)?.pid, spawned.child.pid);
+    let output = '';
+    spawned.child.stderr.on('data', bytes => { output += bytes; });
+    const locker = process.platform === 'win32' ? spawn(process.execPath, ['-e', 'process.stdout.write("holding-cwd\\n");setTimeout(()=>process.exit(0),2500)'], { cwd: spawned.dataDir, windowsHide: true, stdio: ['ignore', 'pipe', 'pipe'] }) : null;
+    if (locker) await new Promise((resolve, reject) => { locker.once('error', reject); locker.stdout.once('data', resolve); });
+    try { await spawned.cleanup(); stopped = true; }
+    finally { if (locker?.exitCode === null) { locker.kill(); await new Promise(resolve => locker.once('close', resolve)); } }
+    assert.notEqual(spawned.child.exitCode, null, output);
+    assert.equal(spawned.child.signalCode, null, 'normal cleanup must drain the server instead of force killing it');
+    assert.equal(spawned.child.exitCode, 0, output);
+    assert.ok(!fs.existsSync(spawned.dataDir));
+    assert.ok(!fs.existsSync(spawned.bridgeHome));
+    await assert.rejects(fetch(`http://127.0.0.1:${port}/api/health`));
+    console.log('test-server-cleanup-test PASS (verified graceful shutdown before fixture removal)');
+  } finally { if (!stopped) await spawned.cleanup(); }
+})().catch(error => { console.error(error); process.exitCode = 1; });

package/_site/_test/test-server-module-isolation-test.js

@@ -1,37 +1,37 @@
-'use strict';
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const path = require('node:path');
-const vm = require('node:vm');
-
-const helper = path.join(__dirname, 'helpers/spawn-server.js');
-const calls = [];
-const moduleObject = { exports: {} };
-const inherited = {
-  KB_TERMINAL_URL: 'http://127.0.0.1:5760',
-  KB_VECTORHUB_URL: 'http://127.0.0.1:8787',
-  KB_EVENTBRIDGE_URL: 'http://127.0.0.1:8790',
-  KB_KNOWLEDGE_ENGINE_URL: 'http://127.0.0.1:5790',
-};
-vm.runInNewContext(fs.readFileSync(helper, 'utf8'), {
-  module: moduleObject,
-  require(id) {
-    if (id === 'child_process') return { spawn: (...args) => { calls.push(args); return { pid: 1 }; } };
-    if (id === 'fs') return { mkdtempSync: prefix => prefix + 'owned' };
-    if (id === '../../lib/runtime-control' || id === '../../lib/runtime-endpoint') return {};
-    return require(id);
-  },
-  process: { execPath: process.execPath, pid: process.pid, env: inherited },
-});
-const spawnServer = moduleObject.exports.spawnServer;
-spawnServer({ root: path.resolve(__dirname, '../..'), port: 0, dataDir: 'isolated-data' });
-const defaults = calls[0][2].env;
-for (const key of Object.keys(inherited)) assert.equal(defaults[key], 'http://127.0.0.1:0', key + ' must not consult a live user module');
-assert.equal(defaults.KB_DATA_DIR, 'isolated-data');
-assert.equal(defaults.KB_MODULES_AUTOSTART, '0');
-assert.equal(defaults.KB_MODULES_REGISTER, '0');
-assert.notEqual(defaults.AI_CODING_EVENT_BRIDGE_HOME, process.env.AI_CODING_EVENT_BRIDGE_HOME);
-const ownUrls = Object.fromEntries(Object.keys(inherited).map(key => [key, 'http://127.0.0.1:12345']));
-spawnServer({ root: path.resolve(__dirname, '../..'), port: 0, dataDir: 'isolated-data', extraEnv: ownUrls });
-for (const key of Object.keys(inherited)) assert.equal(calls[1][2].env[key], ownUrls[key], 'explicit owned fixture remains supported');
-console.log('test-server-module-isolation-test PASS');
+'use strict';
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const vm = require('node:vm');
+
+const helper = path.join(__dirname, 'helpers/spawn-server.js');
+const calls = [];
+const moduleObject = { exports: {} };
+const inherited = {
+  KB_TERMINAL_URL: 'http://127.0.0.1:5760',
+  KB_VECTORHUB_URL: 'http://127.0.0.1:8787',
+  KB_EVENTBRIDGE_URL: 'http://127.0.0.1:8790',
+  KB_KNOWLEDGE_ENGINE_URL: 'http://127.0.0.1:5790',
+};
+vm.runInNewContext(fs.readFileSync(helper, 'utf8'), {
+  module: moduleObject,
+  require(id) {
+    if (id === 'child_process') return { spawn: (...args) => { calls.push(args); return { pid: 1 }; } };
+    if (id === 'fs') return { mkdtempSync: prefix => prefix + 'owned' };
+    if (id === '../../lib/runtime-control' || id === '../../lib/runtime-endpoint') return {};
+    return require(id);
+  },
+  process: { execPath: process.execPath, pid: process.pid, env: inherited },
+});
+const spawnServer = moduleObject.exports.spawnServer;
+spawnServer({ root: path.resolve(__dirname, '../..'), port: 0, dataDir: 'isolated-data' });
+const defaults = calls[0][2].env;
+for (const key of Object.keys(inherited)) assert.equal(defaults[key], 'http://127.0.0.1:0', key + ' must not consult a live user module');
+assert.equal(defaults.KB_DATA_DIR, 'isolated-data');
+assert.equal(defaults.KB_MODULES_AUTOSTART, '0');
+assert.equal(defaults.KB_MODULES_REGISTER, '0');
+assert.notEqual(defaults.AI_CODING_EVENT_BRIDGE_HOME, process.env.AI_CODING_EVENT_BRIDGE_HOME);
+const ownUrls = Object.fromEntries(Object.keys(inherited).map(key => [key, 'http://127.0.0.1:12345']));
+spawnServer({ root: path.resolve(__dirname, '../..'), port: 0, dataDir: 'isolated-data', extraEnv: ownUrls });
+for (const key of Object.keys(inherited)) assert.equal(calls[1][2].env[key], ownUrls[key], 'explicit owned fixture remains supported');
+console.log('test-server-module-isolation-test PASS');

package/_site/_test/tracking-start-test.js

@@ -93,47 +93,47 @@ function commit(target, name) {
   await reconciler.processCommitEvent({ projectId: 'project-existing', commitSha: nextCommit, branch: 'main' });
   assert.strictEqual(projects.readState('project-existing').lastAnalyzedCommit, nextCommit);
   assert.strictEqual(processorCalls, 1);
-  await reconciler.processCommitEvent({ projectId: 'project-existing', commitSha: laterCommit, branch: 'main' });
-  assert.strictEqual(projects.readState('project-existing').lastAnalyzedCommit, laterCommit, 'an event SHA remains valid even after HEAD advances');
-  assert.strictEqual(processorCalls, 2);
-
-  const terminalFailedCommit = 'a'.repeat(40);
-  await projects.updateState('project-existing', state => {
-    state.analysis.activeClaim = {
-      schema: 'commit-claim/v1', projectId: 'project-existing', commitSha: terminalFailedCommit, parents: [], requirementIds: [], requirementBinding: 'unavailable',
-      promptTemplateVersion: 'v1', promptHash: 'prompt', patchHash: 'patch', evidenceHash: 'evidence', evidenceManifestHash: 'manifest', retrievalManifestHash: 'retrieval', knowledgePath: knowledgeRoot,
-      runId: 'failed-run', operationId: 'failed-operation', phase: 'failed', attempt: 1, fingerprint: 'failed-fingerprint', error: { code: 'EPERM', retryable: false },
-    };
-    state.analysis.status = 'failed';
-  });
-  const explicitAfterFailure = commit(existingRepo, 'after-terminal-failure');
-  await reconciler.processCommitEvent({ projectId: 'project-existing', commitSha: explicitAfterFailure, branch: 'main' });
-  assert.strictEqual(projects.readState('project-existing').lastAnalyzedCommit, explicitAfterFailure, 'only the new explicit Hook SHA may proceed after a terminal failure');
-  assert.strictEqual(processorCalls, 3, 'terminal failed claims must not retry their old SHA');
-
-  const retryableFailedCommit = 'b'.repeat(40);
-  await projects.updateState('project-existing', state => {
-    state.analysis.activeClaim = {
-      schema: 'commit-claim/v1', projectId: 'project-existing', commitSha: retryableFailedCommit, parents: [], requirementIds: [], requirementBinding: 'unavailable',
-      promptTemplateVersion: 'v1', promptHash: 'prompt', patchHash: 'patch', evidenceHash: 'evidence', evidenceManifestHash: 'manifest', retrievalManifestHash: 'retrieval', knowledgePath: knowledgeRoot,
-      runId: 'retryable-run', operationId: 'retryable-operation', phase: 'failed', attempt: 1, fingerprint: 'retryable-fingerprint', error: { code: 'EAGAIN', retryable: true },
-    };
-    state.analysis.status = 'failed';
-  });
-  const blockedByRetryable = commit(existingRepo, 'after-retryable-failure');
-  const blockedResult = await reconciler.processCommitEvent({ projectId: 'project-existing', commitSha: blockedByRetryable, branch: 'main' });
-  assert.strictEqual(blockedResult.status, 'failed');
-  assert.strictEqual(processorCalls, 3, 'retryable claims must remain blocked instead of being silently superseded');
-  assert.strictEqual(projects.readState('project-existing').analysis.activeClaim.commitSha, retryableFailedCommit);
+  await reconciler.processCommitEvent({ projectId: 'project-existing', commitSha: laterCommit, branch: 'main' });
+  assert.strictEqual(projects.readState('project-existing').lastAnalyzedCommit, laterCommit, 'an event SHA remains valid even after HEAD advances');
+  assert.strictEqual(processorCalls, 2);
+
+  const terminalFailedCommit = 'a'.repeat(40);
+  await projects.updateState('project-existing', state => {
+    state.analysis.activeClaim = {
+      schema: 'commit-claim/v1', projectId: 'project-existing', commitSha: terminalFailedCommit, parents: [], requirementIds: [], requirementBinding: 'unavailable',
+      promptTemplateVersion: 'v1', promptHash: 'prompt', patchHash: 'patch', evidenceHash: 'evidence', evidenceManifestHash: 'manifest', retrievalManifestHash: 'retrieval', knowledgePath: knowledgeRoot,
+      runId: 'failed-run', operationId: 'failed-operation', phase: 'failed', attempt: 1, fingerprint: 'failed-fingerprint', error: { code: 'EPERM', retryable: false },
+    };
+    state.analysis.status = 'failed';
+  });
+  const explicitAfterFailure = commit(existingRepo, 'after-terminal-failure');
+  await reconciler.processCommitEvent({ projectId: 'project-existing', commitSha: explicitAfterFailure, branch: 'main' });
+  assert.strictEqual(projects.readState('project-existing').lastAnalyzedCommit, explicitAfterFailure, 'only the new explicit Hook SHA may proceed after a terminal failure');
+  assert.strictEqual(processorCalls, 3, 'terminal failed claims must not retry their old SHA');
+
+  const retryableFailedCommit = 'b'.repeat(40);
+  await projects.updateState('project-existing', state => {
+    state.analysis.activeClaim = {
+      schema: 'commit-claim/v1', projectId: 'project-existing', commitSha: retryableFailedCommit, parents: [], requirementIds: [], requirementBinding: 'unavailable',
+      promptTemplateVersion: 'v1', promptHash: 'prompt', patchHash: 'patch', evidenceHash: 'evidence', evidenceManifestHash: 'manifest', retrievalManifestHash: 'retrieval', knowledgePath: knowledgeRoot,
+      runId: 'retryable-run', operationId: 'retryable-operation', phase: 'failed', attempt: 1, fingerprint: 'retryable-fingerprint', error: { code: 'EAGAIN', retryable: true },
+    };
+    state.analysis.status = 'failed';
+  });
+  const blockedByRetryable = commit(existingRepo, 'after-retryable-failure');
+  const blockedResult = await reconciler.processCommitEvent({ projectId: 'project-existing', commitSha: blockedByRetryable, branch: 'main' });
+  assert.strictEqual(blockedResult.status, 'failed');
+  assert.strictEqual(processorCalls, 3, 'retryable claims must remain blocked instead of being silently superseded');
+  assert.strictEqual(projects.readState('project-existing').analysis.activeClaim.commitSha, retryableFailedCommit);
 
   const emptyRepo = repo('empty-repo', false);
   const emptyImported = await lifecycle.importProject({ localPath: emptyRepo, projectId: 'project-empty', aiProfileId: 'test-profile' });
   assert.strictEqual(emptyImported.state.trackingMode, 'empty-repo');
   assert.strictEqual(emptyImported.state.trackingStartCommit, null);
   const firstCommit = commit(emptyRepo, 'first');
-  await reconciler.processCommitEvent({ projectId: 'project-empty', commitSha: firstCommit, branch: 'main' });
-  assert.strictEqual(projects.readState('project-empty').lastAnalyzedCommit, firstCommit, 'first commit after empty import must be analyzed');
-  assert.strictEqual(processorCalls, 4);
+  await reconciler.processCommitEvent({ projectId: 'project-empty', commitSha: firstCommit, branch: 'main' });
+  assert.strictEqual(projects.readState('project-empty').lastAnalyzedCommit, firstCommit, 'first commit after empty import must be analyzed');
+  assert.strictEqual(processorCalls, 4);
 
   console.log('tracking-start-test PASS');
 })().catch(error => {

package/_site/_test/workbench-context-receipts-test.js

@@ -0,0 +1,22 @@
+'use strict';
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const vm = require('node:vm');
+const source = fs.readFileSync(path.join(__dirname, '../../ui/product.js'), 'utf8');
+const code = source.slice(source.indexOf('  function frameContext('), source.indexOf('  function setView('));
+const messages = [], frame = { ready: false }, state = { epoch: 1, scope: 'project' };
+const project = { projectId: 'a', workspacePath: '/workspace', modules: { terminal: { projectId: 'context-a' } } };
+const ctx = vm.createContext({ state, frames: { terminal: frame }, activeProject: () => project,
+  document: { documentElement: { dataset: { theme: 'light' } } }, frameVisible: () => true,
+  post: (_key, message) => messages.push(message) });
+vm.runInContext(code, ctx);
+vm.runInContext('frameContext("terminal")', ctx);
+assert.equal(messages.length, 0);
+frame.ready = true;
+vm.runInContext('frameContext("terminal"); frameContext("terminal")', ctx);
+assert.equal(messages.filter(m => m.type === 'kb:select-project').length, 1, 'identical context receipts are not repeated');
+state.epoch++;
+vm.runInContext('frameContext("terminal")', ctx);
+assert.equal(messages.filter(m => m.type === 'kb:select-project').length, 2, 'a real selection still reaches the iframe');
+console.log('workbench-context-receipts-test PASS');

package/_site/_test/workspace-ui-contract-test.js

@@ -1,31 +1,31 @@
-'use strict';
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const path = require('node:path');
-const root = path.resolve(__dirname, '../..');
-const html = fs.readFileSync(path.join(root, 'ui/index.html'), 'utf8');
-const script = fs.readFileSync(path.join(root, 'ui/product.js'), 'utf8');
-const css = fs.readFileSync(path.join(root, 'ui/product.css'), 'utf8');
-for (const view of ['home', 'work', 'search', 'memory', 'projects', 'activity']) {
-  assert.equal((html.match(new RegExp(`data-view="${view}"`, 'g')) || []).length, 1);
-  assert.ok(html.includes(`id="view-${view}"`));
-}
-assert.equal((html.match(/data-view=/g) || []).length, 6, 'diagnostics must not become another primary product');
-assert.match(html, /<select\b[^>]*id="projectSelect"[^>]*\bdisabled\b/, 'project selection is disabled until the initial registry snapshot has loaded');
-for (const id of ['workFrame', 'vectorFrame', 'bridgeFrame', 'engineFrame', 'importDialog', 'importCode', 'importKnowledge', 'importDomain', 'setupImportRoot', 'createDomain', 'logsDialog', 'systemDrawer', 'copyReference']) assert.equal((html.match(new RegExp(`id="${id}"`, 'g')) || []).length, 1);
-assert.ok(html.includes('data-action="import"') && html.includes('不分析全部历史'));
-assert.ok(!html.includes('srcdoc') && !/data-simulate|data-analyze|data-install-hook/.test(html));
-assert.equal((script.match(/\.src = /g) || []).length, 1, 'frames initialize once, not on project/theme/page changes');
-for (const contract of ['kb:theme', 'kb:select-project', 'kb:scope', 'kb:knowledge', 'kb:ready']) assert.ok(script.includes(contract));
-assert.ok(script.includes('event.origin !== location.origin') && script.includes('contentWindow === event.source'), 'module messages must be from the expected frame and origin');
-assert.ok(script.includes('state.epoch++') && script.includes('referenceEpoch') && script.includes('logEpoch'), 'late project/reference/log feedback must be isolated');
-assert.match(script, /on\('domainForm'[\s\S]*?await refreshRegistry\(true\)/, 'domain writes must invalidate pre-mutation reads');
-assert.match(script, /registered = true;[\s\S]*?await refreshRegistry\(true\)/, 'import must not reuse a pre-import snapshot');
-assert.ok(script.includes('esc(r.title)') && script.includes('esc(m.text)') && script.includes('esc(project.name)'));
-assert.ok(script.includes('text.textContent = record.message') && script.includes("'logs/appended'"), 'diagnostics stay inert and stream live');
-assert.ok(script.includes('URL.revokeObjectURL(url)') && script.includes('logStream?.close()'));
-assert.ok(script.includes('resumeImport = true') && script.includes("$('importDialog').showModal()") && script.includes("p.code === 'KNOWLEDGE_ROOT_MISSING'"), 'first import can return from setup without resetting its input');
-assert.ok(css.includes('height:100%') && css.includes('.view.module-view{padding:0;overflow:hidden}') && css.includes('overflow-wrap:anywhere'));
-assert.ok(css.includes('html[data-theme=dark]') && css.includes('prefers-reduced-motion'));
-assert.doesNotThrow(() => new Function(script));
-console.log('workspace UI contract test PASS (source contract; not browser acceptance)');
+'use strict';
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const root = path.resolve(__dirname, '../..');
+const html = fs.readFileSync(path.join(root, 'ui/index.html'), 'utf8');
+const script = fs.readFileSync(path.join(root, 'ui/product.js'), 'utf8');
+const css = fs.readFileSync(path.join(root, 'ui/product.css'), 'utf8');
+for (const view of ['home', 'work', 'search', 'memory', 'projects', 'activity']) {
+  assert.equal((html.match(new RegExp(`data-view="${view}"`, 'g')) || []).length, 1);
+  assert.ok(html.includes(`id="view-${view}"`));
+}
+assert.equal((html.match(/data-view=/g) || []).length, 6, 'diagnostics must not become another primary product');
+assert.match(html, /<select\b[^>]*id="projectSelect"[^>]*\bdisabled\b/, 'project selection is disabled until the initial registry snapshot has loaded');
+for (const id of ['workFrame', 'vectorFrame', 'bridgeFrame', 'engineFrame', 'importDialog', 'importCode', 'importKnowledge', 'importDomain', 'setupImportRoot', 'createDomain', 'logsDialog', 'systemDrawer', 'copyReference']) assert.equal((html.match(new RegExp(`id="${id}"`, 'g')) || []).length, 1);
+assert.ok(html.includes('data-action="import"') && html.includes('不分析全部历史'));
+assert.ok(!html.includes('srcdoc') && !/data-simulate|data-analyze|data-install-hook/.test(html));
+assert.equal((script.match(/\.src = /g) || []).length, 1, 'frames initialize once, not on project/theme/page changes');
+for (const contract of ['kb:theme', 'kb:select-project', 'kb:scope', 'kb:knowledge', 'kb:ready']) assert.ok(script.includes(contract));
+assert.ok(script.includes('event.origin !== location.origin') && script.includes('contentWindow === event.source'), 'module messages must be from the expected frame and origin');
+assert.ok(script.includes('state.epoch++') && script.includes('referenceEpoch') && script.includes('logEpoch'), 'late project/reference/log feedback must be isolated');
+assert.match(script, /on\('domainForm'[\s\S]*?await refreshRegistry\(true\)/, 'domain writes must invalidate pre-mutation reads');
+assert.match(script, /registered = true;[\s\S]*?await refreshRegistry\(true\)/, 'import must not reuse a pre-import snapshot');
+assert.ok(script.includes('esc(r.title)') && script.includes('esc(m.text)') && script.includes('esc(project.name)'));
+assert.ok(script.includes('text.textContent = record.message') && script.includes("'logs/appended'"), 'diagnostics stay inert and stream live');
+assert.ok(script.includes('URL.revokeObjectURL(url)') && script.includes('logStream?.close()'));
+assert.ok(script.includes('resumeImport = true') && script.includes("$('importDialog').showModal()") && script.includes("p.code === 'KNOWLEDGE_ROOT_MISSING'"), 'first import can return from setup without resetting its input');
+assert.ok(css.includes('height:100%') && css.includes('.view.module-view{padding:0;overflow:hidden}') && css.includes('overflow-wrap:anywhere'));
+assert.ok(css.includes('html[data-theme=dark]') && css.includes('prefers-reduced-motion'));
+assert.doesNotThrow(() => new Function(script));
+console.log('workspace UI contract test PASS (source contract; not browser acceptance)');