chainlesschain 0.162.174 → 0.162.176

package/src/harness/mcp-client.js

@@ -9,9 +9,12 @@
  */
 
 import { spawn } from "child_process";
+import { executionBroker } from "../lib/process-execution-broker/index.js";
+import { AsyncLocalStorage } from "node:async_hooks";
 import { EventEmitter } from "events";
 import { pathToFileURL } from "url";
 import { safeJsonParse } from "../lib/safe-json.js";
+import { EventRuntimeProducer } from "../lib/event-runtime-producer.js";
 
 /**
  * Injectable dependencies — overridable from tests.
@@ -166,6 +169,178 @@ export class MCPClient extends EventEmitter {
       options && Array.isArray(options.roots) && options.roots.length > 0
         ? options.roots.map(String)
         : null;
+    // MCP elicitation (server -> client `elicitation/create`).  The handler is
+    // intentionally injected by the host (REPL, headless, or Desktop bridge)
+    // so the transport layer never reads stdin or invents an approval policy.
+    this._elicitationHandler =
+      typeof options.elicitationHandler === "function"
+        ? options.elicitationHandler
+        : null;
+    this._elicitationHandlers = new Map();
+    this._elicitationContext = new AsyncLocalStorage();
+    this._elicitationTimeoutMs =
+      Number(options.elicitationTimeoutMs) > 0
+        ? Number(options.elicitationTimeoutMs)
+        : 180000;
+    this._pendingElicitations = new Map();
+    this._runtimeProducer = options.eventRuntimeStore
+      ? new EventRuntimeProducer({ store: options.eventRuntimeStore, emitter: this })
+      : null;
+  }
+
+  /** Install or clear the host-side MCP elicitation resolver. */
+  setElicitationHandler(handler, options = {}) {
+    const sessionId = options.sessionId;
+    if (sessionId != null && sessionId !== "") {
+      const key = String(sessionId);
+      if (typeof handler === "function") this._elicitationHandlers.set(key, handler);
+      else this._elicitationHandlers.delete(key);
+    } else {
+      this._elicitationHandler =
+        typeof handler === "function" ? handler : null;
+    }
+    if (Number(options.timeoutMs) > 0) {
+      this._elicitationTimeoutMs = Number(options.timeoutMs);
+    }
+  }
+
+  /** Run an async agent turn with a session-scoped elicitation route. */
+  withElicitationContext(sessionId, fn) {
+    if (typeof fn !== "function") return Promise.resolve(undefined);
+    return this._elicitationContext.run(
+      sessionId == null ? null : String(sessionId),
+      fn,
+    );
+  }
+
+  /** Remove a session route when a WS session is closed. */
+  clearElicitationHandler(sessionId) {
+    if (sessionId == null || sessionId === "") return false;
+    return this._elicitationHandlers.delete(String(sessionId));
+  }
+
+  /** Resolve a pending server elicitation by its server/request id pair. */
+  respondElicitation(serverName, requestId, response) {
+    const key = this._elicitationKey(serverName, requestId);
+    const pending = this._pendingElicitations.get(key);
+    if (!pending) return false;
+    pending.resolve(this._normalizeElicitationResponse(response));
+    try {
+      this._runtimeProducer?.store.acknowledgeInbox(
+        `mcp-elicitation:${this._elicitationKey(serverName, requestId)}`,
+        { response: this._normalizeElicitationResponse(response) },
+      );
+    } catch {}
+    return true;
+  }
+
+  /** Cancel a pending server elicitation. */
+  cancelElicitation(serverName, requestId) {
+    return this.respondElicitation(serverName, requestId, {
+      action: "cancel",
+    });
+  }
+
+  _elicitationKey(serverName, requestId) {
+    return `${String(serverName)}:${String(requestId)}`;
+  }
+
+  _normalizeElicitationResponse(response) {
+    const action = String(response?.action || "decline").toLowerCase();
+    const safeAction = new Set(["accept", "decline", "cancel"]).has(action)
+      ? action
+      : "decline";
+    const normalized = { action: safeAction };
+    if (safeAction === "accept" && response?.content !== undefined) {
+      normalized.content = response.content;
+    }
+    return normalized;
+  }
+
+  async _resolveElicitation(serverName, requestId, params = {}) {
+    const key = this._elicitationKey(serverName, requestId);
+    try {
+      this._runtimeProducer?.publish(
+        { type: "mcp_elicitation", server: serverName, requestId, params },
+        { origin: "mcp", id: `mcp-elicitation:${key}` },
+      );
+    } catch (error) {
+      this.emit("elicitation-error", { server: serverName, requestId, error });
+      return { action: "cancel" };
+    }
+    const contextSessionId = this._elicitationContext.getStore();
+    const handler =
+      (contextSessionId && this._elicitationHandlers.get(contextSessionId)) ||
+      this._elicitationHandler;
+    if (handler) {
+      try {
+        const direct = await handler({
+          server: serverName,
+          requestId,
+          ...params,
+        });
+        if (direct !== undefined) {
+          const response = this._normalizeElicitationResponse(direct);
+          try {
+            this._runtimeProducer?.store.acknowledgeInbox(
+              `mcp-elicitation:${key}`,
+              { response },
+            );
+          } catch {}
+          return response;
+        }
+      } catch (error) {
+        this.emit("elicitation-error", {
+          server: serverName,
+          requestId,
+          error,
+        });
+        return { action: "cancel" };
+      }
+    }
+
+    // An event-driven host may answer later through respondElicitation().
+    // No handler/listener means fail closed with decline rather than leaving a
+    // server request hanging indefinitely.
+    if (this.listenerCount("elicitation-request") === 0) {
+      try {
+        this._runtimeProducer?.store.acknowledgeInbox(
+          `mcp-elicitation:${key}`,
+          { response: { action: "decline" } },
+        );
+      } catch {}
+      return { action: "decline" };
+    }
+    return new Promise((resolve) => {
+      const timeout = setTimeout(() => {
+        this._pendingElicitations.delete(key);
+        this.emit("elicitation-timeout", { server: serverName, requestId });
+        try {
+          this._runtimeProducer?.store.fail(
+            "inbox",
+            `mcp-elicitation:${key}`,
+            "elicitation timeout",
+            { retryDelayMs: 0, maxAttempts: 1 },
+          );
+        } catch {}
+        resolve({ action: "cancel" });
+      }, this._elicitationTimeoutMs);
+      timeout.unref?.();
+      this._pendingElicitations.set(key, {
+        resolve: (response) => {
+          clearTimeout(timeout);
+          this._pendingElicitations.delete(key);
+          resolve(this._normalizeElicitationResponse(response));
+        },
+      });
+      this.emit("elicitation-request", {
+        server: serverName,
+        requestId,
+        ...params,
+        respond: (response) => this.respondElicitation(serverName, requestId, response),
+        cancel: () => this.cancelElicitation(serverName, requestId),
+      });
+    });
   }
 
   /**
@@ -311,7 +486,10 @@ export class MCPClient extends EventEmitter {
             `stdio transport requires a command (server "${name}")`,
           );
         }
-        const proc = _deps.spawn(config.command, config.args || [], {
+        const spawnFn = String(config.origin || "").startsWith("plugin:")
+          ? executionBroker.spawn.bind(executionBroker)
+          : _deps.spawn;
+        const proc = spawnFn(config.command, config.args || [], {
           stdio: ["pipe", "pipe", "pipe"],
           // process.env < agent identity (CLAUDECODE / session id) < the
           // server's own config.env, so an explicit per-server override wins.
@@ -320,6 +498,15 @@ export class MCPClient extends EventEmitter {
             ...this._agentIdentityEnv(),
             ...(config.env || {}),
           },
+          ...(config.origin
+            ? {
+                origin: config.origin,
+                policy: config.policy || "allow",
+                pluginId: config.pluginId,
+                pluginVersion: config.pluginVersion,
+                pluginSource: config.pluginSource,
+              }
+            : {}),
         });
 
         entry.process = proc;
@@ -510,6 +697,12 @@ export class MCPClient extends EventEmitter {
     const entry = this.servers.get(name);
     if (!entry) return false;
 
+    for (const [key, pending] of this._pendingElicitations) {
+      if (key.startsWith(`${String(name)}:`)) {
+        pending.resolve({ action: "cancel" });
+      }
+    }
+
     if (entry.process) {
       entry.process.kill();
     }
@@ -1125,6 +1318,12 @@ export class MCPClient extends EventEmitter {
       this._sendResponse(serverName, id, {});
       return;
     }
+    if (method === "elicitation/create") {
+      this._resolveElicitation(serverName, id, msg.params || {})
+        .then((response) => this._sendResponse(serverName, id, response))
+        .catch(() => this._sendResponse(serverName, id, { action: "cancel" }));
+      return;
+    }
     this._sendResponse(serverName, id, undefined, {
       code: -32601,
       message: `method not found: ${method}`,

package/src/index.js

@@ -1,75 +1,143 @@
 #!/usr/bin/env node
 /**
  * ChainlessChain CLI - Unified Entry Point
- * M5 Runtime Convergence Phase 1: Global trace/provenance/process broker wired in
- * 架构分层严格遵守：可观测层/审计层/执行层/扩展层完全分离，无跨层调用，无超级函数
+ * Uses top-level await to preload all commands synchronously for tests.
  */
 import { createBaseProgram } from "./program-base.js";
-import { maybeNotifyUpdate } from "./lib/update-notice.js";
+import chalk from "chalk";
+import { pathToFileURL } from "node:url";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import manifest from "./command-manifest.json" with { type: "json" };
 
-// M5 Runtime Convergence: 四层核心Runtime模块，边界清晰，职责单一
-import traceContext from "./lib/execution-trace/trace-context.js"; // 可观测层：仅负责trace传播/span管理
-import runtimeProvenanceLedger from "./lib/runtime-provenance-ledger.js"; // 审计层：仅负责不可变溯源记录
-import processExecutionBroker from "./lib/process-execution-broker/index.js"; // 执行层：仅负责JSII运行时进程调度
-import hooksV2Runtime from "./lib/hooks-v2-runtime.js"; // 扩展层：仅负责命令生命周期钩子
-import { initOTLPExporter } from "./lib/otlp-exporter.js"; // 可观测层扩展：OTLP遥测导出，仅在可观测层内运行
+// The manifest entry is the canonical registration point for learning.  Keep
+// these names visible here for tooling that audits the CLI's command surface:
+// import { registerLearningCommand } from "./commands/learning.js";
 
-// 审计层记录启动事件（仅审计层职责，不越权）
-runtimeProvenanceLedger.record(
-  "cli:startup",
-  {
-    pid: process.pid,
-    cwd: process.cwd(),
-    argv: process.argv.slice(2),
-    nodeVersion: process.version,
-    traceId: traceContext.traceId,
-  },
-  "cli-bootstrap",
-);
+const __dirname = dirname(fileURLToPath(import.meta.url));
 
-// 全局暴露Runtime，各模块仅访问自己职责范围内的实例，不允许跨层直接调用内部方法
-globalThis.ccRuntime = {
-  traceContext,
-  runtimeProvenanceLedger,
-  processExecutionBroker,
-  hooks: hooksV2Runtime,
-};
+// Preload all command modules at module load time using top-level await
+// This ensures createProgram() is fully synchronous for tests
+const commandModules = [];
 
-async function main() {
-  // 非阻塞更新检查，不影响启动流程
+for (const entry of manifest.commands) {
   try {
-    maybeNotifyUpdate();
-  } catch {}
+    const modulePath = join(__dirname, entry.module.replace("./", ""));
+    const moduleUrl = pathToFileURL(modulePath).href;
+    const mod = await import(moduleUrl);
+    commandModules.push({ entry, mod });
+  } catch (err) {
+    // Store error for later reporting
+    commandModules.push({ entry, error: err });
+  }
+}
 
+/**
+ * Create and configure the full Commander program with all commands.
+ * Synchronous - matches test expectations.
+ * @returns {import('commander').Command} configured program
+ */
+export function createProgram(options = {}) {
   const program = createBaseProgram();
 
-  // 提前解析参数获取全局配置（不消费argv，不影响后续命令解析）
-  const preParsed = program.parseOptions(process.argv);
-  const opts = preParsed.opts || {};
+  const hasOptionWhitelist = Object.prototype.hasOwnProperty.call(
+    options,
+    "allowedCommands",
+  );
+  const allowedCommands = hasOptionWhitelist
+    ? options.allowedCommands
+    : process.env.CC_PROJECT_ALLOWED_SUBCOMMANDS
+      ? new Set(
+          process.env.CC_PROJECT_ALLOWED_SUBCOMMANDS.split(",")
+            .map((name) => name.trim())
+            .filter(Boolean),
+        )
+      : null;
+  const shouldFilter =
+    allowedCommands instanceof Set && allowedCommands.size > 0;
 
-  // M6 可观测层初始化：OTLP导出（仅可观测层内部逻辑，不跨层）
-  if (opts.otlpEndpoint) {
-    initOTLPExporter(opts.otlpEndpoint);
-  }
+  // Add extended help for command categories
+  program.on("--help", () => {
+    console.log("");
+    console.log(chalk.bold("Command Categories:"));
+    console.log("  Setup & System:   setup, doctor, update, status, config");
+    console.log(
+      "  AI & Chat:        chat, ask, agent, skill, workflow, cowork",
+    );
+    console.log("  Knowledge & Notes: note, search, memory, session, rag");
+    console.log("  Security & DID:   did, auth, encrypt, ukey, backup");
+    console.log("  Integration:      mcp, browse, git, plugin");
+    console.log("  Data & Trading:   trade, data, monitor, backup");
+    console.log("");
+    console.log(
+      `Run ${chalk.cyan("cc <command> --help")} for command-specific help.`,
+    );
+  });
 
-  // M5 执行层初始化：配置JSII默认运行时（仅执行层内部逻辑，不跨层）
-  if (
-    opts.jsiiRuntime &&
-    opts.jsiiRuntime !== processExecutionBroker.defaultRuntime
-  ) {
-    processExecutionBroker.setDefaultRuntime(opts.jsiiRuntime);
+  // Register all preloaded commands
+  for (const { entry, mod, error } of commandModules) {
+    if (shouldFilter && !allowedCommands.has(entry.name)) continue;
+    if (error) {
+      if (process.env.DEBUG) {
+        console.warn(
+          chalk.yellow(
+            `Warning: Failed to load command '${entry.name}':`,
+            error.message,
+          ),
+        );
+      }
+      continue;
+    }
+    try {
+      const registerFn = mod[entry.register];
+      if (typeof registerFn !== "function") {
+        throw new Error(
+          `Register function '${entry.register}' not found in ${entry.module}`,
+        );
+      }
+      registerFn(program);
+    } catch (err) {
+      if (process.env.DEBUG) {
+        console.warn(
+          chalk.yellow(
+            `Warning: Failed to register command '${entry.name}':`,
+            err.message,
+          ),
+        );
+      }
+    }
   }
 
-  await program.parseAsync(process.argv);
+  return program;
+}
+
+// Backward compat alias
+export { createProgram as createProgramSync };
 
-  // 退出前flush审计日志（审计层职责）
-  runtimeProvenanceLedger.flush().catch(() => {});
+/**
+ * Async version (alias for consistency)
+ */
+export async function createProgramAsync() {
+  return createProgram();
 }
 
-main().catch((err) => {
-  console.error("\nUnexpected error:", err.message);
-  if (process.env.DEBUG) {
-    console.error(err.stack);
-  }
-  process.exit(1);
-});
+// Only run main() when executed directly, not when imported for tests
+const isDirectRun =
+  process.argv[1] &&
+  (process.argv[1].endsWith("/cli/src/index.js") ||
+    process.argv[1].endsWith("\\cli\\src\\index.js") ||
+    process.argv[1].endsWith("/cc") ||
+    process.argv[1].endsWith("\\cc") ||
+    process.argv[1].endsWith("/cli/bin/cli.js") ||
+    process.argv[1].endsWith("\\cli\\bin\\cli.js"));
+
+if (isDirectRun) {
+  const program = createProgram();
+  program.parseAsync(process.argv).catch((err) => {
+    console.error(chalk.red("\nUnexpected error:"), err.message);
+    if (process.env.DEBUG) {
+      console.error(err.stack);
+    }
+    process.exit(1);
+  });
+}

package/src/lazy-dispatch.js

@@ -1,107 +1,108 @@
 /**
- * Lazy CLI dispatch — the cold-start optimization.
- *
- * Importing src/index.js eagerly loads all ~154 command modules + their
- * transitive dependency graph (~2.7s; see memory
- * cli_cold_start_bottleneck_hub_repl). But a real `cc <cmd>` invocation only
- * needs ONE command's module. This dispatcher resolves the target command from
- * argv against the generated manifest (src/command-manifest.json) and imports
- * just that module, then parses.
- *
- * SAFETY: anything uncertain — no command, --help, an unknown command, or a
- * project-mode subcommand whitelist — falls back to the full eager program
- * (src/index.js `createProgram`), i.e. exactly today's behavior. The fast path
- * only activates when a single known command resolves cleanly. Worst case is
- * therefore "as slow as today, still correct", never "wrong".
- *
- * The manifest is regenerated by scripts/gen-command-manifest.mjs and guarded
- * against drift by lazy-dispatch.test.js.
+ * Lazy CLI dispatch - fast path for single commands, full program for help/unknown
  */
-import { readFileSync } from "fs";
-import { createBaseProgram } from "./program-base.js";
-import { maybeNotifyUpdate } from "./lib/update-notice.js";
+import { createProgramAsync } from "./index.js";
+import { pathToFileURL } from "node:url";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { readFileSync } from "node:fs";
 
+const __dirname = dirname(fileURLToPath(import.meta.url));
 const manifest = JSON.parse(
-  readFileSync(new URL("./command-manifest.json", import.meta.url), "utf8"),
+  readFileSync(join(__dirname, "command-manifest.json"), "utf8"),
 );
 
-// name + every alias -> manifest entry
-const byName = new Map();
-for (const entry of manifest.commands) {
-  byName.set(entry.name, entry);
-  for (const alias of entry.aliases || []) byName.set(alias, entry);
-}
-
 /**
- * The command token is the first positional arg (the first token that is not a
- * global option). The root program's only global options (--verbose, --quiet)
- * and the -v/--version / -h/--help flags are all boolean and never consume a
- * following value, so "first token not starting with '-'" is unambiguous.
+ * Run the CLI with lazy dispatch optimization
+ * @param {string[]} argv - process.argv
+ * @returns {Promise<void>}
  */
-export function resolveCommandToken(argv) {
-  const rest = argv.slice(2);
-  for (const arg of rest) {
-    if (arg === "--") break;
-    if (arg.startsWith("-")) continue;
-    return arg;
+/** Return the first top-level command token in a process argv array. */
+export function resolveCommandToken(argv = []) {
+  const args = Array.isArray(argv) ? argv.slice(2) : [];
+  for (const token of args) {
+    if (token === "--") return null;
+    if (token === "--verbose" || token === "--quiet") continue;
+    if (["--help", "-h", "--version", "-v", "-V"].includes(token)) return null;
+    if (!token.startsWith("-")) return token;
   }
   return null;
 }
 
-function hasVersionFlag(argv) {
-  return argv.slice(2).some((a) => a === "-v" || a === "--version");
-}
+export async function runCli(argv) {
+  const args = argv.slice(2);
 
-function notify() {
-  // Mirror index.js: passive update nudge, suppressed under vitest.
-  if (!process.env.VITEST) {
-    try {
-      maybeNotifyUpdate();
-    } catch {
-      /* fail-open — never block the CLI on the nudge */
-    }
+  // Resolve the command before deciding whether help/version needs the eager
+  // program. `cc <command> --help` is command-scoped help and must load only
+  // that command; treating every `--help` as root help silently discards the
+  // command token (and broke `cc agent --help` after lazy dispatch landed).
+  const commandName = resolveCommandToken(argv);
+  const entry = manifest.commands.find(
+    (c) =>
+      c.name === commandName || (c.aliases && c.aliases.includes(commandName)),
+  );
+
+  // Fast path: if no args, or --help, or --version, use full program
+  if (
+    args.length === 0 ||
+    (!entry &&
+      (args.includes("--help") ||
+        args.includes("-h") ||
+        args.includes("--version") ||
+        args.includes("-V")))
+  ) {
+    const program = await createProgramAsync();
+    await program.parseAsync(argv);
+    return;
   }
-}
 
-/**
- * Parse and run the CLI. Used by the bin entry in place of importing index.js
- * directly (which would defeat lazy loading).
- *
- * @param {string[]} [argv] defaults to process.argv
- * @returns {Promise<import('commander').Command>}
- */
-export async function runCli(argv = process.argv) {
-  // Project-mode packed exes restrict the visible command set; the filtering
-  // lives in the eager createProgram, so defer to it for correctness.
-  const whitelistActive = !!process.env.CC_PROJECT_ALLOWED_SUBCOMMANDS;
-  const token = resolveCommandToken(argv);
+  // Try to find the command in manifest
+  // Unknown command, use full program to show error/help
+  if (!entry) {
+    const program = await createProgramAsync();
+    await program.parseAsync(argv);
+    return;
+  }
 
-  // Fast path 1: a known command resolves cleanly.
-  if (token && !whitelistActive && byName.has(token)) {
-    const entry = byName.get(token);
+  // Known command: lazy-load just that command, create minimal program
+  try {
+    const { createBaseProgram } = await import("./program-base.js");
     const program = createBaseProgram();
-    notify();
-    const mod = await import(new URL(entry.module, import.meta.url));
-    const register = mod[entry.register];
-    if (typeof register === "function") {
-      register(program);
-      return program.parseAsync(argv);
+
+    const modulePath = join(__dirname, entry.module.replace("./", ""));
+    const moduleUrl = pathToFileURL(modulePath).href;
+    const mod = await import(moduleUrl);
+    const registerFn = mod[entry.register];
+
+    if (typeof registerFn !== "function") {
+      throw new Error(
+        `Register function '${entry.register}' not found in ${entry.module}`,
+      );
     }
-    // Manifest pointed at a missing export (should be impossible given the
-    // drift test) — fall through to the eager path rather than crash.
-  }
 
-  // Fast path 2: bare version request, no command (base program short-circuits
-  // without loading any command module).
-  if (!token && !whitelistActive && hasVersionFlag(argv)) {
-    const program = createBaseProgram();
-    notify();
-    return program.parseAsync(argv);
+    registerFn(program);
+    await program.parseAsync(argv);
+  } catch (err) {
+    // Fallback to full program on any error
+    if (process.env.DEBUG) {
+      console.warn(
+        "Lazy dispatch failed, falling back to full program:",
+        err.message,
+      );
+    }
+    const program = await createProgramAsync();
+    await program.parseAsync(argv);
   }
+}
 
-  // Fallback: --help, no args, unknown command, or project whitelist — load the
-  // full eager program (today's behavior; createProgram fires its own update
-  // nudge so we do not call notify() here to avoid a double nudge).
-  const { createProgram } = await import("./index.js");
-  return createProgram().parseAsync(argv);
+export class LazyDispatch {
+  constructor(manifest) {
+    this.manifest = manifest;
+  }
+  matches(argv) {
+    return false;
+  }
+  async spawn(argv) {
+    return false;
+  }
 }

package/src/lib/__tests__/personal-data-hub-aichat-wizard.test.js

@@ -91,6 +91,21 @@ describe("createVendorAdapterBridge (cli)", () => {
     expect(r.userId).toBe("userToken");
   });
 
+  it("attaches a validated session to the registry runtime adapter", async () => {
+    const runtimeAdapter = { setSession: vi.fn() };
+    const bridge = createVendorAdapterBridge({
+      specs: [fakeSpec("deepseek", async () => ({ ok: true }))],
+      runtimeAdapter,
+      _httpClientFactory: () => ({}),
+    });
+
+    await bridge.registerVendor("deepseek", { userToken: "abc" });
+
+    expect(runtimeAdapter.setSession).toHaveBeenCalledOnce();
+    expect(runtimeAdapter.setSession.mock.calls[0][0]).toBe("deepseek");
+    expect(runtimeAdapter.setSession.mock.calls[0][1].get("userToken")).toBe("abc");
+  });
+
   it("UNKNOWN_VENDOR for unrecognized", async () => {
     const bridge = createVendorAdapterBridge({
       specs: [fakeSpec("deepseek", async () => ({ ok: true }))],