@sanqianx/project-knowledge 4.6.1

package/_site/_test/claude-executable-discovery-test.js

@@ -0,0 +1,90 @@
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const runner = require('../lib/claude-cli-runner');
+
+const temp = fs.mkdtempSync(path.join(os.tmpdir(), 'claude-discovery-test-'));
+
+(async () => {
+  try {
+    const nativeExe = path.join(temp, 'claude.exe');
+    const npmRoot = path.join(temp, 'npm');
+    const extensionlessNpmShim = path.join(npmRoot, 'claude');
+    const npmShim = path.join(npmRoot, 'claude.cmd');
+    const npmCli = path.join(npmRoot, 'node_modules', '@anthropic-ai', 'claude-code', 'cli.js');
+    const npmExe = path.join(npmRoot, 'node_modules', '@anthropic-ai', 'claude-code', 'bin', 'claude.exe');
+    fs.mkdirSync(path.dirname(npmExe), { recursive: true });
+    fs.writeFileSync(nativeExe, 'test');
+    fs.writeFileSync(extensionlessNpmShim, '#!/bin/sh');
+    fs.writeFileSync(npmShim, '@echo off');
+    fs.writeFileSync(npmCli, '#!/usr/bin/env node');
+    fs.writeFileSync(npmExe, 'native executable');
+
+    const fromEnv = await runner.findClaudeExecutableForSdk({
+      platform: 'win32',
+      env: { CLAUDE_CODE_EXECPATH: nativeExe },
+      runCommand: () => ({ status: 1, stdout: '' }),
+    });
+    assert.equal(fromEnv.cmd, nativeExe);
+    assert.equal(fromEnv.source, 'CLAUDE_CODE_EXECPATH');
+
+    const fromPath = await runner.findClaudeExecutableForSdk({
+      platform: 'win32',
+      env: {},
+      runCommand: () => ({ status: 0, stdout: `${nativeExe}\r\n` }),
+    });
+    assert.equal(fromPath.cmd, nativeExe);
+    assert.equal(fromPath.source, 'PATH');
+
+    const fromExtensionlessNpmShim = await runner.findClaudeExecutableForSdk({
+      platform: 'win32',
+      env: {},
+      runCommand: () => ({ status: 0, stdout: `${extensionlessNpmShim}\r\n${npmShim}\r\n` }),
+    });
+    assert.equal(fromExtensionlessNpmShim.cmd, npmExe,
+      'extensionless npm shell shim should resolve to the package native executable');
+
+    const fromCmdNpmShim = await runner.findClaudeExecutableForSdk({
+      platform: 'win32',
+      env: { CLAUDE_CODE_EXECPATH: npmShim },
+      runCommand: () => ({ status: 1, stdout: '' }),
+    });
+    assert.equal(fromCmdNpmShim.cmd, npmExe,
+      'configured npm .cmd shim should resolve to the package native executable');
+    assert.equal(fromCmdNpmShim.runtimeExecutable, null,
+      'native Claude executable should not need a JavaScript runtime launcher');
+
+    fs.rmSync(npmExe);
+    const fromCliScript = await runner.findClaudeExecutableForSdk({
+      platform: 'win32',
+      env: { CLAUDE_CODE_EXECPATH: npmShim },
+      runtimeExecutable: process.execPath,
+      runCommand: () => ({ status: 1, stdout: '' }),
+    });
+    assert.equal(fromCliScript.cmd, npmCli,
+      'npm shim should fall back to the installed Claude cli.js');
+    assert.equal(fromCliScript.runtimeExecutable, process.execPath,
+      'Claude cli.js must use the current runtime instead of PATH node');
+    const scriptLaunch = spawnSync(fromCliScript.runtimeExecutable, [fromCliScript.cmd], {
+      encoding: 'utf8',
+      windowsHide: true,
+    });
+    assert.equal(scriptLaunch.status, 0,
+      `resolved Claude cli.js should launch through the selected runtime: ${scriptLaunch.stderr}`);
+
+    const missing = await runner.findClaudeExecutableForSdk({
+      platform: 'win32',
+      env: {},
+      exists: () => false,
+      runCommand: () => ({ status: 1, stdout: '' }),
+    });
+    assert.equal(missing.cmd, null);
+    assert.match(missing.reason, /Claude Code was not found/);
+
+    console.log('claude-executable-discovery-test: PASS');
+  } finally {
+    fs.rmSync(temp, { recursive: true, force: true });
+  }
+})();

package/_site/_test/claude-session-lifecycle-sweep-test.js

@@ -0,0 +1,252 @@
+// Run: node _site/_test/claude-session-lifecycle-sweep-test.js
+//
+// Regression test for the stale-active-session sweep in claude-cli-runner.
+//
+// Without the sweeper, three failure modes leave sessions stuck in
+// state=running forever after the subprocess is gone:
+//   1. dashboard restart kills the SDK parent query; claude.exe becomes
+//      orphaned; on reload the persisted record still says "running"
+//   2. SIGKILL of the dashboard before the SDK for-await loop emits its
+//      terminal message
+//   3. child Claude.exe dies under IPC drop; in-memory session has
+//      subprocess=null while state=running
+//
+// Symptom in production: a project keeps showing the pulsing "running"
+// badge and the embedded terminal view stays empty because no live
+// subprocess streams into it. Until the sweeper ships, the only manual
+// workaround is a dashboard restart that the user has to remember.
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const TMP_DATA = fs.mkdtempSync(path.join(os.tmpdir(), `kb-sweep-test-${process.pid}-`));
+process.env.KB_DATA_DIR = TMP_DATA;
+process.env.KB_STALE_ACTIVE_MS = '60000';
+require(path.resolve(__dirname, '..', '..', '_site', 'lib', 'data-dir'))._resetCache();
+
+// Seed the v2 registry and per-project config/state before loading the runner.
+const PROJECT_IDS = ['demo-zombie-persisted', 'demo-zombie-memory', 'demo-fresh', 'demo-broadcast', 'demo-callback'];
+const { defaultProjectConfig, defaultProjectState } = require('../lib/project-store');
+const now = new Date().toISOString();
+fs.mkdirSync(path.join(TMP_DATA, 'projects'), { recursive: true });
+for (const projectId of PROJECT_IDS) {
+  const knowledgePath = path.join(TMP_DATA, 'knowledge', projectId);
+  const metadataPath = path.join(TMP_DATA, 'projects', projectId);
+  fs.mkdirSync(knowledgePath, { recursive: true });
+  fs.mkdirSync(metadataPath, { recursive: true });
+  fs.writeFileSync(path.join(metadataPath, 'config.json'), JSON.stringify(defaultProjectConfig(projectId, {
+    displayName: projectId, storageName: projectId, repoPath: TMP_DATA, knowledgePath,
+  }), null, 2) + '\n', 'utf8');
+  fs.writeFileSync(path.join(metadataPath, 'state.json'), JSON.stringify(defaultProjectState(), null, 2) + '\n', 'utf8');
+}
+fs.writeFileSync(path.join(TMP_DATA, 'projects.json'), JSON.stringify({
+  schema: 'project-registry/v2', schemaVersion: 2, projectOrder: PROJECT_IDS,
+  projects: Object.fromEntries(PROJECT_IDS.map(projectId => [projectId, { createdAt: now, displayNameSnapshot: projectId }])),
+  revision: 1, updatedAt: now,
+}, null, 2) + '\n', 'utf8');
+fs.writeFileSync(path.join(TMP_DATA, 'claude-prompts.json'), '{"schema":"prompts/v1","prompts":{}}', 'utf-8');
+
+const runner = require('../lib/claude-cli-runner');
+const {
+  createSession,
+  demoteStaleActiveSessions,
+  ACTIVE_STATES,
+  TERMINAL_STATES,
+  listSessions,
+  subscribeList,
+} = runner;
+
+function assert(cond, msg) { if (!cond) throw new Error('ASSERT: ' + msg); }
+
+function writePersistedRecord(projectSlug, record) {
+  const aiDir = path.join(TMP_DATA, 'runtime', 'claude-sessions', projectSlug);
+  fs.mkdirSync(aiDir, { recursive: true });
+  const target = path.join(aiDir, `${record.sessionId}.json`);
+  // Default updatedAt to the same stale time used for startedAt so the
+  // sweeper treats the record as orphan-aged. Callers can override either.
+  const longAgo = record.startedAt || new Date(Date.now() - 10 * 60 * 1000).toISOString();
+  fs.writeFileSync(target, JSON.stringify({
+    schema: 'claude-workbench-session/v1',
+    updatedAt: record.updatedAt || longAgo,
+    ...record,
+  }, null, 2) + '\n', 'utf-8');
+  return target;
+}
+
+function makeStalePersistedRecord(projectSlug, sessionId, state) {
+  const longAgo = new Date(Date.now() - 10 * 60 * 1000).toISOString();
+  return writePersistedRecord(projectSlug, {
+    sessionId,
+    projectSlug,
+    projectPath: 'D:/proj/' + projectSlug,
+    kbPath: path.join(TMP_DATA, 'knowledge', projectSlug),
+    promptKey: 'post-commit-automation',
+    runner: 'sdk',
+    state,
+    startedAt: longAgo,
+    endedAt: null,
+    exitCode: null,
+    turns: 1,
+    error: null,
+    pendingPermission: null,
+    source: 'git-hook',
+    automation: true,
+    automationRunId: 'auto-test-1',
+    metadata: { source: 'git-hook', automation: true, automationRunId: 'auto-test-1' },
+    permissionMode: 'bypassPermissions',
+    events: [{ type: 'claude/system-prompt', text: 'fake', promptKey: 'post-commit-automation' }],
+  });
+}
+
+(() => {
+  // The sweeper itself is the unit under test.
+  assert(typeof demoteStaleActiveSessions === 'function',
+    'demoteStaleActiveSessions must be exported');
+  assert(ACTIVE_STATES.has('running'),
+    'ACTIVE_STATES must include running');
+  assert(TERMINAL_STATES.has('failed'),
+    'TERMINAL_STATES must include failed');
+
+  // (1) Persisted record that's been "running" for 10 minutes with no live
+  // subprocess — must be demoted. The user's exact scenario: dashboard
+  // restart orphaned the SDK parent query and the record on disk still
+  // says running.
+  {
+    const sessionId = 'sess-zombie-persisted-' + Date.now();
+    makeStalePersistedRecord('demo-zombie-persisted', sessionId, 'running');
+
+    const demoted = demoteStaleActiveSessions({ thresholdMs: 60 * 1000 });
+    const hit = demoted.find(d => d.sessionId === sessionId);
+    assert(hit, 'sweeper should have demoted the persisted zombie');
+    assert(hit.source === 'persisted', `expected source=persisted, got ${hit.source}`);
+
+    // The rehydrated session in memory should now show failed + endedAt.
+    const state = runner.getState(sessionId);
+    assert(state.state === 'failed',
+      `expected state=failed after sweep, got ${state.state}`);
+    assert(state.endedAt, 'endedAt should be set after demotion');
+    assert(state.error && /subprocess lost/i.test(state.error),
+      `error message should explain the orphan, got ${state.error}`);
+
+    // Subsequent sweeps should be idempotent — already-failed sessions are
+    // not in ACTIVE_STATES so they don't get touched again.
+    const secondSweep = demoteStaleActiveSessions({ thresholdMs: 60 * 1000 });
+    const hitAgain = secondSweep.find(d => d.sessionId === sessionId);
+    assert(!hitAgain,
+      `sweeper must not re-demote already-failed session (hit again: ${JSON.stringify(secondSweep)})`);
+  }
+
+  // (2) In-memory session with state=running AND subprocess=null AND a
+  // stale updatedAt — must be demoted. This is the runtime-orphan case:
+  // SDK query was kicked off, but the subprocess ref was cleared without
+  // a terminal setState (e.g. the dashboard process died between the
+  // subprocess=null assignment and the setState(failed) on the catch path).
+  {
+    const projectSlug = 'demo-zombie-memory';
+    const session = createSession({
+      projectSlug,
+      projectPath: 'D:/proj/' + projectSlug,
+      kbPath: path.join(TMP_DATA, 'knowledge', projectSlug),
+      promptKey: 'post-commit-automation',
+      source: 'git-hook',
+      metadata: { source: 'git-hook', automation: true, automationRunId: 'auto-mem' },
+    });
+    // Force it into the orphan shape: state=running, subprocess=null,
+    // updatedAt way in the past.
+    session.state = 'running';
+    session.subprocess = null;
+    session.updatedAt = new Date(Date.now() - 10 * 60 * 1000).toISOString();
+    session.startedAt = session.updatedAt;
+
+    const demoted = demoteStaleActiveSessions({ thresholdMs: 60 * 1000 });
+    const hit = demoted.find(d => d.sessionId === session.sessionId);
+    assert(hit, 'sweeper should have demoted the in-memory zombie');
+    assert(hit.source === 'memory', `expected source=memory, got ${hit.source}`);
+
+    const state = runner.getState(session.sessionId);
+    assert(state.state === 'failed',
+      `expected in-memory session to be failed, got ${state.state}`);
+    assert(state.error && /subprocess exited/i.test(state.error),
+      `expected subprocess-null error, got ${state.error}`);
+  }
+
+  // (3) Fresh session (started 5s ago) must NOT be demoted even if
+  // subprocess happens to be null. Threshold exists exactly to keep
+  // legitimately-thinking sessions from being killed prematurely.
+  {
+    const projectSlug = 'demo-fresh';
+    const session = createSession({
+      projectSlug,
+      projectPath: 'D:/proj/' + projectSlug,
+      kbPath: path.join(TMP_DATA, 'knowledge', projectSlug),
+      promptKey: 'post-commit-automation',
+      source: 'git-hook',
+      metadata: { source: 'git-hook', automation: true, automationRunId: 'auto-fresh' },
+    });
+    session.state = 'running';
+    session.subprocess = null;
+    // updatedAt defaults to createdAt via createSession, well under 60s old.
+
+    const demoted = demoteStaleActiveSessions({ thresholdMs: 60 * 1000 });
+    const hit = demoted.find(d => d.sessionId === session.sessionId);
+    assert(!hit,
+      `fresh session (age <60s) must NOT be demoted; demoted list = ${JSON.stringify(demoted)}`);
+
+    // Cleanup so it doesn't leak into the next test.
+    runner.deleteSession(session.sessionId);
+  }
+
+  // (4) Demotion must fire the global SSE broadcast so the UI sees the
+  // running→failed transition. Without this the blue light stays on even
+  // after the in-memory state is wrong.
+  {
+    const projectSlug = 'demo-broadcast';
+    const broadcastEvents = [];
+    subscribeList(ev => broadcastEvents.push(ev));
+
+    const sessionId = 'sess-broadcast-' + Date.now();
+    makeStalePersistedRecord(projectSlug, sessionId, 'running');
+
+    demoteStaleActiveSessions({ thresholdMs: 60 * 1000 });
+    const sawTransition = broadcastEvents.some(
+      ev => ev.sessionId === sessionId && ev.state === 'failed' && ev.kind === 'stale-active-sweep'
+    );
+    assert(sawTransition,
+      `expected SSE broadcast for ${sessionId} with state=failed kind=stale-active-sweep; got ${JSON.stringify(broadcastEvents)}`);
+  }
+
+  // (5) The onSessionEnded hook must fire for failed sessions, so the
+  // automation queue (post-commit-automation.js) can promote the next
+  // queued run. Without this, stranded sessions would also strand any
+  // queued successor forever.
+  {
+    const projectSlug = 'demo-callback';
+    const sessionId = 'sess-callback-' + Date.now();
+    makeStalePersistedRecord(projectSlug, sessionId, 'running');
+
+    let endedWithFailed = null;
+    const off = runner.onSessionEnded(s => {
+      if (s.sessionId === sessionId && s.state === 'failed') {
+        endedWithFailed = s;
+      }
+    });
+
+    demoteStaleActiveSessions({ thresholdMs: 60 * 1000 });
+    // onSessionEnded fires via setImmediate, so wait one tick.
+    return Promise.resolve()
+      .then(() => new Promise(resolve => setImmediate(resolve)))
+      .then(() => {
+        off();
+        assert(endedWithFailed,
+          `onSessionEnded should have fired for the demoted session`);
+        assert(endedWithFailed.sessionId === sessionId,
+          `wrong sessionId in callback: ${endedWithFailed && endedWithFailed.sessionId}`);
+      });
+  }
+})().then(() => {
+  console.log('claude-session-lifecycle-sweep-test PASS');
+}).catch(e => {
+  console.error(e.stack || e.message);
+  process.exit(1);
+});

package/_site/_test/claude-workbench-test.js

@@ -0,0 +1,170 @@
+// Claude workbench regression test.
+//
+// Verifies session metadata and the SDK-only session lifecycle. The legacy
+// `claude -p` subprocess path was removed in the CC-Switch migration, so
+// the pre-turn `requirePermission` flow no longer exists — the SDK path
+// shows permission prompts via canUseTool only when an individual tool
+// is actually invoked. Tool-level prompts are exercised by the chat
+// panel integration tests.
+
+const fs = require('fs');
+const path = require('path');
+const runner = require('../lib/claude-cli-runner');
+
+const ROOT = path.resolve(__dirname, '..', '..');
+const TEMP_KB = path.join(ROOT, 'projects', 'claude-workbench-test-temp');
+const TEMP_AI = path.join(ROOT, '_site', '_ai', 'claude-workbench-test-temp');
+
+function assert(cond, msg) {
+  if (!cond) throw new Error(msg);
+}
+
+(async () => {
+  fs.rmSync(TEMP_KB, { recursive: true, force: true });
+  fs.rmSync(TEMP_AI, { recursive: true, force: true });
+  fs.mkdirSync(TEMP_KB, { recursive: true });
+
+  // 1. Default initial-analysis turn: SDK is the only mode. The session
+  //    should be created without any pre-turn permission prompt (the
+  //    SDK surfaces tool approvals lazily through canUseTool).
+  const started = runner.startSession({
+    slug: 'claude-workbench-test-temp',
+    projectPath: ROOT,
+    kbPath: TEMP_KB,
+    promptKey: 'initial-analysis',
+    aiProfile: {
+      id: 'test-profile',
+      implementation: 'claude-code-agent',
+      mainModel: 'test-model',
+    },
+    vars: {
+      SLUG: 'claude-workbench-test-temp',
+      PROJECT_PATH: ROOT,
+      PRIMARY_LANGUAGE: 'JavaScript',
+      KNOWLEDGE_LANGUAGE: 'zh-CN',
+    },
+  });
+
+  assert(started.sessionId, 'startSession should return sessionId');
+  assert(!started.pendingPermission,
+    'SDK mode should not show a pre-turn UI permission prompt');
+  assert(started.runner === 'sdk',
+    `startSession should default to runner: 'sdk', got ${started.runner}`);
+
+  const state = runner.getState(started.sessionId);
+  assert(state.runner === 'sdk',
+    `session state should record runner: 'sdk', got ${state.runner}`);
+
+  runner.deleteSession(started.sessionId);
+
+  // 1b. The embedded terminal should be able to create an idle chat
+  //     session without reading claude-prompts.json or running an
+  //     initial-analysis prompt. The user's first typed message starts
+  //     the actual SDK turn via sendInput.
+  const chat = runner.startChatSession({
+    slug: 'claude-workbench-test-temp',
+    projectPath: ROOT,
+    kbPath: TEMP_KB,
+    aiProfile: {
+      id: 'test-profile',
+      implementation: 'claude-code-agent',
+      mainModel: 'test-model',
+    },
+    permissionMode: 'default',
+  });
+  assert(chat.sessionId, 'startChatSession should return sessionId');
+  const chatState = runner.getState(chat.sessionId);
+  assert(chatState.promptKey === 'terminal-chat',
+    `chat session should use terminal-chat promptKey, got ${chatState.promptKey}`);
+  assert(chatState.state === 'idle',
+    `chat session should stay idle until user input, got ${chatState.state}`);
+  assert(chatState.turns === 0, `chat session should not start a turn, got turns=${chatState.turns}`);
+
+  // 1c. Switching AI profiles mid-session must not resume the old upstream
+  //     Claude conversation with the new provider. That used to send the
+  //     previous model (for example MiniMax-M3) to the new base URL (for
+  //     example GLM), producing "model not found" API errors.
+  const chatSession = runner.getSession(chat.sessionId);
+  chatSession.aiProfileId = 'minimax-m3';
+  chatSession.model = 'MiniMax-M3';
+  chatSession.claudeSessionId = 'old-claude-session-id';
+  const switched = runner.applyAiProfileToSession(chatSession, {
+    id: 'glm',
+    implementation: 'claude-code-agent',
+    mainModel: 'glm-5.2',
+  });
+  const switchedState = runner.getState(chat.sessionId);
+  assert(switched.resetConversation === true, 'profile switch should reset the upstream conversation');
+  assert(switchedState.claudeSessionId === null, 'profile switch should clear stale claudeSessionId');
+  assert(switchedState.aiProfileId === 'glm', `profile switch should update aiProfileId, got ${switchedState.aiProfileId}`);
+  assert(switchedState.model === 'glm-5.2', `profile switch should update model, got ${switchedState.model}`);
+  runner.deleteSession(chat.sessionId);
+
+  // Session metadata uses durable atomic replacement, but a disk fault must
+  // remain fail-open for the live Workbench session and become observable.
+  const AtomicFile = require('../lib/atomic-file');
+  const originalAtomicWrite = AtomicFile.writeJsonAtomic;
+  const persistenceLogs = [];
+  runner.setLogger({ error: async (event, message, payload) => { persistenceLogs.push({ event, message, payload }); } });
+  AtomicFile.writeJsonAtomic = () => { throw Object.assign(new Error('simulated disk full'), { code: 'ENOSPC' }); };
+  let persistenceFaultSession;
+  try {
+    persistenceFaultSession = runner.createSession({
+      projectSlug: 'claude-workbench-test-temp', projectPath: ROOT, kbPath: TEMP_KB, promptKey: 'terminal-chat',
+    });
+    assert(persistenceFaultSession.sessionId, 'persistence failure must not interrupt the live session');
+    assert(persistenceLogs.some(entry => entry.event === 'claude.session_persist_failed' && entry.payload.error.code === 'ENOSPC'), 'persistence failure must be structured and correlated');
+  } finally {
+    AtomicFile.writeJsonAtomic = originalAtomicWrite;
+    runner.setLogger(null);
+    if (persistenceFaultSession) runner.deleteSession(persistenceFaultSession.sessionId);
+  }
+
+  const executable = await runner.findClaudeExecutableForSdk();
+  if (process.platform === 'win32' && executable.cmd) {
+    assert(!/\.(cmd|bat|ps1)$/i.test(executable.cmd),
+      `SDK executable must not be a Windows shell shim: ${executable.cmd}`);
+  }
+
+  // 2. Automation raw prompt sessions must preserve the selected permission
+  //    mode. This guards against regressing back to bypassPermissions -> default.
+  process.env.KB_AUTOMATION_FAKE_CLAUDE = '1';
+  const auto = runner.startAutomationSession({
+    slug: 'claude-workbench-test-temp',
+    projectPath: ROOT,
+    kbPath: TEMP_KB,
+    userPrompt: 'automation test prompt',
+    systemPrompt: 'automation system prompt',
+    aiProfile: {
+      id: 'test-profile',
+      implementation: 'claude-code-agent',
+      mainModel: 'test-model',
+    },
+    permissionMode: 'bypassPermissions',
+    allowedTools: ['Read'],
+    safetyPolicy: {
+      kind: 'kb-automation',
+      kbPath: TEMP_KB,
+      knowledgeMode: 'requestApproval',
+      allowReadOnlyBash: false,
+      allowedTools: ['Read'],
+      canWriteKb: false,
+    },
+    metadata: { automation: true, automationRunId: 'auto-test', source: 'test' },
+  });
+  const autoState = runner.getState(auto.sessionId);
+  assert(autoState.permissionMode === 'bypassPermissions',
+    `automation session should preserve bypassPermissions, got ${autoState.permissionMode}`);
+  assert(autoState.automation === true, 'automation session should be marked automation=true');
+  runner.deleteSession(auto.sessionId);
+  delete process.env.KB_AUTOMATION_FAKE_CLAUDE;
+
+  fs.rmSync(TEMP_KB, { recursive: true, force: true });
+  fs.rmSync(TEMP_AI, { recursive: true, force: true });
+  console.log('Claude workbench test passed');
+})().catch(err => {
+  try { fs.rmSync(TEMP_KB, { recursive: true, force: true }); } catch {}
+  try { fs.rmSync(TEMP_AI, { recursive: true, force: true }); } catch {}
+  console.error(err);
+  process.exit(1);
+});