@sleep2agi/commhub-server 0.9.0-preview.119 → 0.9.0-preview.120

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sleep2agi/commhub-server",
-  "version": "0.9.0-preview.119",
+  "version": "0.9.0-preview.120",
   "description": "CommHub Server — AI Agent communication hub with MCP protocol, multi-network isolation, user auth, and MCP tools (17 collaboration-core + node/provider ops tools; authoritative list: docs-site/docs/api/mcp-tools.md).",
   "type": "module",
   "main": "src/index.ts",

package/src/ack-create-request-transport.test.ts

@@ -98,6 +98,29 @@ beforeEach(() => {
 afterAll(cleanup);
 
 describe("#344 ack_create_request real in-process MCP transport", () => {
+  test("explicit launch proof survives transport while malformed booleans are rejected", async () => {
+    const requestId = 'cr_transport_verified';
+    seedRequest(requestId);
+    const { client, server } = await connectClient();
+    try {
+      const read = () => db.get<{ launch_verified_at: number | null }>(
+        'SELECT launch_verified_at FROM node_create_requests WHERE request_id=?1', requestId);
+      const bad = await client.callTool({ name: 'ack_create_request', arguments: {
+        request_id: requestId, status: 'started', child_pid: 7777, launch_verified: 'true',
+      } });
+      expectTransportValidationError(bad);
+      expect(read()?.launch_verified_at).toBeNull();
+      const good = await client.callTool({ name: 'ack_create_request', arguments: {
+        request_id: requestId, status: 'started', child_pid: 7777, launch_verified: true,
+      } });
+      expect(responseJson(good).ok).toBe(true);
+      expect(read()?.launch_verified_at).toBeGreaterThan(0);
+    } finally {
+      await client.close();
+      await server.close();
+    }
+  });
+
   test("accepts runtime_capability_check_failed plus string runtime through the SDK zod gate", async () => {
     const requestId = "cr_transport_accept";
     seedRequest(requestId);

package/src/ack-create-request.test.ts

@@ -138,8 +138,8 @@ async function callAck(handler: ToolHandler, args: any): Promise<AckReply> {
 }
 
 function readRequest(request_id: string) {
-  return db.get<{ status: string; error: string | null; acked_at: number | null }>(
-    `SELECT status, error, acked_at FROM node_create_requests WHERE request_id = ?1`,
+  return db.get<{ status: string; error: string | null; acked_at: number | null; launch_verified_at: number | null }>(
+    `SELECT status, error, acked_at, launch_verified_at FROM node_create_requests WHERE request_id = ?1`,
     request_id,
   );
 }
@@ -297,6 +297,29 @@ describe("ack_create_request HANDLER — B2 audit_log daemon_capability_lied", (
 });
 
 describe("ack_create_request HANDLER — pre-existing happy-path stays green (regression)", () => {
+  for (const status of ['failed', 'rejected', 'runtime_capability_check_failed']) {
+    test(`late ${status} after registration cannot leave succeeded with a revoked token`, async () => {
+      seedDaemonWorld();
+      const request_id = `cr_late_${status}`;
+      const child_token_id = `tok_late_${status}`;
+      seedCreateRequest({ request_id, child_token_id, status: 'succeeded' });
+      const handler = buildAckHandler();
+      await callAck(handler, { request_id, status: 'started', child_pid: 7777, launch_verified: true });
+      expect(readRequest(request_id)?.launch_verified_at).toBeGreaterThan(0);
+      const reply = await callAck(handler, { request_id, status, error: 'post-register launch verdict' });
+      expect(reply).toMatchObject({ ok: true, status });
+      expect(readRequest(request_id)?.status).toBe(status);
+      expect(readRequest(request_id)?.error).toBe('post-register launch verdict');
+      expect(readRequest(request_id)?.acked_at).toBeGreaterThan(0);
+      expect(readToken(child_token_id)?.revoked_at).not.toBeNull();
+      // Delayed success must not resurrect either the request or its token.
+      await callAck(handler, { request_id, status: 'started', child_pid: 7777, launch_verified: true });
+      expect(readRequest(request_id)?.status).toBe(status);
+      expect(readRequest(request_id)?.launch_verified_at).toBeNull();
+      expect(readToken(child_token_id)?.revoked_at).not.toBeNull();
+    });
+  }
+
   test("status='started' still flips acked_at without terminal teardown", async () => {
     seedDaemonWorld();
     const reqId = "cr_ack_started_regression";
@@ -310,10 +333,30 @@ describe("ack_create_request HANDLER — pre-existing happy-path stays green (re
     // 'started' doesn't flip to terminal; status stays 'delivered'.
     expect(row?.status).toBe("delivered");
     expect(row?.acked_at).toBeGreaterThan(0);
+    expect(row?.launch_verified_at).toBeNull();
     // child ntok is NOT revoked on 'started'.
     expect(readToken(childTok)?.revoked_at).toBeNull();
   });
 
+  for (const status of ['pending', 'delivered', 'succeeded'] as const) {
+    test(`verified launch persists independently of registration: ${status}`, async () => {
+      seedDaemonWorld();
+      const request_id = `cr_verified_${status}`;
+      seedCreateRequest({ request_id, child_token_id: `tok_verified_${status}`, status });
+      const handler = buildAckHandler();
+      expect(readRequest(request_id)?.launch_verified_at).toBeNull();
+      const bad = await callAck(handler, { request_id, status: 'started', launch_verified: true });
+      expect(bad.ok).toBe(false);
+      expect(readRequest(request_id)?.launch_verified_at).toBeNull();
+      await callAck(handler, { request_id, status: 'started', child_pid: 7777, launch_verified: true });
+      const first = readRequest(request_id)!;
+      expect(first.status).toBe(status);
+      expect(first.launch_verified_at).toBeGreaterThan(0);
+      await callAck(handler, { request_id, status: 'started', child_pid: 7777, launch_verified: true });
+      expect(readRequest(request_id)?.launch_verified_at).toBe(first.launch_verified_at);
+    });
+  }
+
   test("status='failed' still revokes child + flips to failed (no audit_log daemon_capability_lied)", async () => {
     seedDaemonWorld();
     const reqId = "cr_ack_failed_regression";

package/src/create-node-tool-schema.test.ts

@@ -17,6 +17,15 @@ function captureSchemas(): Record<string, Record<string, any>> {
 }
 
 describe("create_node MCP schema", () => {
+  test("#829 rejects misplaced V2 controls instead of stripping them", () => {
+    const nodeSpec = captureSchemas().create_node.node_spec;
+    const base = { name: "v2-node", runtime: "opencode-cli" };
+    expect(nodeSpec.safeParse({ ...base, opencodeGeneration: "v2" }).success).toBe(false);
+    expect(nodeSpec.safeParse({ ...base, opencodeUnsafeTools: true }).success).toBe(false);
+    const flags = { opencodeGeneration: "v2", opencodeUnsafeTools: true };
+    expect(nodeSpec.parse({ ...base, flags }).flags).toEqual(flags);
+    expect(nodeSpec.parse(base)).toEqual(base);
+  });
   test("model is optional on daemon create specs but empty strings stay invalid", () => {
     const schemas = captureSchemas();
     const nodeSpec = schemas.create_node.node_spec;

package/src/create-node-validate.ts

@@ -52,7 +52,7 @@ export type Runtime = typeof RUNTIMES[number];
 // 🔴 故意放在 flags 里而不是 node_spec 顶层:老 hub 的 zod 会静默丢弃未知顶层字段、老 daemon 也静默忽略
 //    —— 那正是 #584 的形状(用户选了共存,拿到无头节点,没有任何报错)。flags 的未知键在老 hub(这份
 //    FLAG_KEYS)和老 daemon(buildAnetArgsDaemon)都**拒绝**,新 app 撞到老组件得到的是一条报错。
-export const FLAG_KEYS = ["permissionMode", "dangerouslySkipPermissions", "maxTurns", "budget", "timeout", "copresence"] as const;
+export const FLAG_KEYS = ["permissionMode", "dangerouslySkipPermissions", "maxTurns", "budget", "timeout", "copresence", "opencodeGeneration", "opencodeUnsafeTools"] as const;
 
 /** #584 —— 只有这些 runtime 认 `flags.copresence`。目前只有 codex-app-server 的共存靠 config 字段
  *  (`codexCopresence`)决定;grok-build-cli / opencode-cli 各有自己的字段,接进来之前一律拒,不静默吞。 */
@@ -137,6 +137,12 @@ export function isValidTimeoutMs(v: unknown): v is number {
 
 export function validateFlagValue(k: string, v: unknown): void {
   switch (k) {
+    case "opencodeGeneration":
+      if (v !== "v1" && v !== "v2") throw new ValidationError("flag_value_invalid", { field: k, reason: "must be v1 or v2" });
+      return;
+    case "opencodeUnsafeTools":
+      if (typeof v !== "boolean") throw new ValidationError("flag_value_invalid", { field: k, reason: "must be boolean" });
+      return;
     case "permissionMode":
       if (typeof v !== "string" || !(PERMISSION_MODES as readonly string[]).includes(v)) {
         throw new ValidationError("flag_value_invalid", { field: k, reason: "must be one of default/acceptEdits/plan/bypassPermissions" });
@@ -171,8 +177,21 @@ export function validateFlagValue(k: string, v: unknown): void {
 /** #584 —— 逐键校验之外的跨字段一条:`copresence` 只对 COPRESENCE_FLAG_RUNTIMES 有意义。
  *  在别的 runtime 上收下它而什么都不做,就是又一个「选了共存、拿到无头」。 */
 export function validateFlagsForRuntime(runtime: string, flags: Record<string, unknown> | undefined | null): void {
-  if (!flags || !Object.prototype.hasOwnProperty.call(flags, "copresence")) return;
-  if (!(COPRESENCE_FLAG_RUNTIMES as readonly string[]).includes(runtime)) {
+  if (!flags) return;
+  // Strict flags envelope: old Hub/daemon reject these keys rather than dropping
+  // unknown node_spec fields. Opt-in must be explicit on this create request.
+  for (const field of ["opencodeGeneration", "opencodeUnsafeTools"]) {
+    if (!Object.prototype.hasOwnProperty.call(flags, field)) continue;
+    validateFlagValue(field, flags[field]);
+    if (runtime !== "opencode-cli") throw new ValidationError("flag_not_applicable_to_runtime", { field, runtime, applicable: ["opencode-cli"] });
+  }
+  if (Object.prototype.hasOwnProperty.call(flags, "opencodeUnsafeTools") && flags.opencodeGeneration !== "v2") {
+    throw new ValidationError("opencode_unsafe_requires_v2", { reason: "opencodeUnsafeTools requires explicit opencodeGeneration=v2" });
+  }
+  if (flags.opencodeGeneration === "v2" && flags.opencodeUnsafeTools !== true) {
+    throw new ValidationError("opencode_v2_requires_unsafe_opt_in", { reason: "V2 preview enables every local tool; trusted tasks only. Explicit opencodeUnsafeTools=true required." });
+  }
+  if (Object.prototype.hasOwnProperty.call(flags, "copresence") && !(COPRESENCE_FLAG_RUNTIMES as readonly string[]).includes(runtime)) {
     throw new ValidationError("flag_not_applicable_to_runtime", {
       field: "copresence", runtime, applicable: [...COPRESENCE_FLAG_RUNTIMES],
     });
@@ -318,6 +337,9 @@ function kebab(k: string): string {
 // shell, no string concat). Each value has already passed type/enum
 // validation, so String() coercion is safe.
 export function buildAnetArgs(spec: NodeSpec): string[] {
+  for (const field of ["opencodeGeneration", "opencodeUnsafeTools"]) {
+    if (Object.prototype.hasOwnProperty.call(spec, field)) throw new ValidationError("flag_location_invalid", { field, reason: "use node_spec.flags" });
+  }
   validateName(spec.name);
   validateRuntime(spec.runtime);
   validateModel(spec.model);
@@ -333,6 +355,7 @@ export function buildAnetArgs(spec: NodeSpec): string[] {
       validateFlagValue(k, v);
       // `anet node create --copresence` 是布尔开关,不吃值。
       if (k === "copresence") { if (v === true) args.push("--copresence"); continue; }
+      if (k === "opencodeUnsafeTools") { if (v === true) args.push("--opencode-unsafe-tools"); continue; }
       args.push(`--${kebab(k)}`, String(v));
     }
     validateFlagsForRuntime(spec.runtime, spec.flags);

package/src/create-node-workdir.test.ts

@@ -107,6 +107,27 @@ describe("daemonDefaultWorkdirRoot — sanitize the self-report", () => {
 });
 
 describe("create_node + workdir", () => {
+  test("#829 V2 flags survive Hub storage and daemon pull", async () => {
+    seed({ runtimes_supported: ["opencode-cli"] });
+    const flags = { opencodeGeneration: "v2", opencodeUnsafeTools: true, timeout: 600000 };
+    const r = await call(tools().create_node, { daemon_node_id: DAEMON_ID, node_spec: { name: "v2-child", runtime: "opencode-cli", model: "stub/model", flags } });
+    expect(r.ok).toBe(true);
+    const row = db.get<{ flags_json: string }>("SELECT flags_json FROM node_create_requests WHERE request_id = ?1", r.request_id);
+    expect(JSON.parse(row!.flags_json)).toEqual(flags);
+    const pulled = await call(tools(DAEMON_TOK).get_create_request, { request_id: r.request_id });
+    expect(pulled.ok).toBe(true);
+    expect(pulled.node_spec.flags).toEqual(flags);
+  });
+
+  test("#829 missing opt-in rejected before request or child token mint", async () => {
+    seed({ runtimes_supported: ["opencode-cli"] });
+    const tokenCount = () => db.get<{ n: number }>("SELECT COUNT(*) AS n FROM api_tokens WHERE network_id = ?1", NET)!.n;
+    const before = tokenCount();
+    const r = await call(tools().create_node, { daemon_node_id: DAEMON_ID, node_spec: { name: "v2-child", runtime: "opencode-cli", flags: { opencodeGeneration: "v2" } } });
+    expect(r.error).toBe("opencode_v2_requires_unsafe_opt_in");
+    expect(rowCount()).toBe(0);
+    expect(tokenCount()).toBe(before);
+  });
   test("🔴 old daemon (no default_workdir_root) + workdir → workdir_not_supported_by_daemon, NO row", async () => {
     seed({});
     const r = await call(tools().create_node, { daemon_node_id: DAEMON_ID, node_spec: { ...baseSpec, workdir: `${ROOT}/wd-child` } });

package/src/db.ts

@@ -771,6 +771,14 @@ try {
   if (!/duplicate column|already exists/i.test(e?.message || "")) throw e;
 }
 
+// Registration also stamps acked_at, so it cannot prove daemon launch checks.
+// Keep old rows NULL; run after the legacy model-nullability table rebuild.
+try {
+  db.exec(`ALTER TABLE node_create_requests ADD COLUMN launch_verified_at BIGINT`);
+} catch (e: any) {
+  if (!/duplicate column|already exists/i.test(e?.message || "")) throw e;
+}
+
 // #1493 — 把 user_inbox.network_id 升到 **schema 级 NOT NULL**(belt-and-suspenders,
 // 叠在 send_desktop_message 的代码级三闸之上:canWrite / `!effectiveNetId` return /
 // getUserNetworkRole,tools.ts)。「不产生 network_id=NULL 孤儿」现是代码级保证 + #1492

package/src/node-create-request-status-http.test.ts

@@ -78,6 +78,19 @@ describe("GET /api/node-create-requests?request_id=", () => {
     const { body } = await get("/api/node-create-requests?request_id=cr_b_pending", bToken);
     expect(body.request.status).toBe("pending");
     expect(body.request.error).toBeNull();
+    expect(body.request.child_node_id).toBeNull();
+    expect(body.request.launch_verified_at).toBeNull();
+  });
+  test("registration timestamp is not launch proof; explicit proof and identity round-trip", async () => {
+    const { db } = await import('./db.js');
+    db.run(`UPDATE node_create_requests SET status='succeeded', child_node_id='node_verified', acked_at=1234 WHERE request_id='cr_b_pending'`);
+    const registered = await get('/api/node-create-requests?request_id=cr_b_pending', bToken);
+    expect(registered.body.request.acked_at).toBe(1234);
+    expect(registered.body.request.launch_verified_at).toBeNull();
+    db.run(`UPDATE node_create_requests SET launch_verified_at=5678 WHERE request_id='cr_b_pending'`);
+    const verified = await get('/api/node-create-requests?request_id=cr_b_pending', bToken);
+    expect(verified.body.request).toMatchObject({ child_node_id: 'node_verified', launch_verified_at: 5678 });
+    expect((await get('/api/node-create-requests?request_id=cr_b_pending', aToken)).status).toBe(404);
   });
   test("missing request_id → 400", async () => {
     const { status, body } = await get("/api/node-create-requests", aToken);

package/src/server.ts

@@ -4489,7 +4489,7 @@ return Bun.serve({
       }
       const params: any[] = [requestId];
       let sql = `SELECT request_id, daemon_node_id, child_name, network_id, runtime, model, status, error,
-                        created_at, delivered_at, acked_at
+                        created_at, delivered_at, acked_at, child_node_id, launch_verified_at
                  FROM node_create_requests WHERE request_id = ?1`;
       sql = addNetworkScope(sql, params, restScope);
       const row = db.get<Record<string, unknown>>(sql, ...params);

package/src/tools.ts

@@ -4279,6 +4279,10 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
         model: z.string().min(1).max(100).optional().nullable(),
         flags: z.record(z.string(), z.unknown()).optional(),
         env_refs: z.array(z.string().max(64)).optional(),
+        // Wrong placement must fail, not silently create a legacy V1 node.
+        // These options belong under the strict flags envelope.
+        opencodeGeneration: z.never().optional(),
+        opencodeUnsafeTools: z.never().optional(),
         channels: z.array(z.unknown()).optional(),
         // app「新建节点」确认页的工作目录(绝对路径或 ~/…,daemon 侧展开并校验)。
         // 缺席 = 老行为:落 daemon 的 cwd。
@@ -4753,8 +4757,9 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
       error: z.string().max(1000).optional(),
       child_pid: z.number().int().optional(),
       runtime: z.string().max(64).optional(),   // populated by daemon when status=runtime_capability_check_failed
+      launch_verified: z.boolean().optional(), // finite launcher exit + live generation proof, not mere registration/spawn
     },
-    async ({ request_id, status, error: ackError, child_pid: _pid, runtime: ackRuntime }) => {
+    async ({ request_id, status, error: ackError, child_pid: _pid, runtime: ackRuntime, launch_verified }) => {
       const callerDaemon = resolveCallerDaemonTokenBound();
       if (!callerDaemon.ok) {
         return { content: [{ type: "text" as const, text: JSON.stringify({ ok: false, error: callerDaemon.error }) }] };
@@ -4772,6 +4777,15 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
       }
       const ackedAt = Date.now();
       if (status === "started") {
+        if (launch_verified === true && (!Number.isInteger(_pid) || _pid! <= 0)) {
+          return { content: [{ type: "text" as const, text: JSON.stringify({ ok: false, error: "verified_child_pid_required" }) }] };
+        }
+        if (launch_verified === true) {
+          // A child can register before this acknowledgement arrives. Preserve
+          // both event orders, but a late success must never revive a failure.
+          db.run(`UPDATE node_create_requests SET launch_verified_at = COALESCE(launch_verified_at, ?1)
+                  WHERE request_id = ?2 AND status IN ('pending', 'delivered', 'succeeded')`, [ackedAt, request_id]);
+        }
         // Don't flip to 'succeeded' here — that happens via content-
         // match when the child actually registers. We just stamp ack.
         db.run(
@@ -4781,12 +4795,14 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
         return { content: [{ type: "text" as const, text: JSON.stringify({ ok: true, status: "awaiting_register" }) }] };
       }
       // failed / rejected / runtime_capability_check_failed — revoke
-      // child-ntok + mark request terminal.
+      // child-ntok + mark request terminal. Registration can precede the
+      // daemon's final capability verdict; don't leave succeeded visible
+      // while this same failure acknowledgement revokes its child token.
       if (row.child_token_id) {
         db.run(`UPDATE api_tokens SET revoked_at = datetime('now') WHERE token_id = ?1 AND revoked_at IS NULL`, [row.child_token_id]);
       }
       db.run(
-        `UPDATE node_create_requests SET status = ?1, error = ?2, acked_at = ?3 WHERE request_id = ?4 AND status IN ('pending', 'delivered')`,
+        `UPDATE node_create_requests SET status = ?1, error = ?2, acked_at = ?3, launch_verified_at = NULL WHERE request_id = ?4 AND status IN ('pending', 'delivered', 'succeeded')`,
         [status, ackError || null, ackedAt, request_id],
       );
       // RFC-026 §9.3 D2 — surface declaration↔reality gap on a