sleep2agi
diff --git a/‎agent-node/package.json‎
Lines changed: 1 addition & 1 deletion b/‎agent-node/package.json‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎agent-node/src/cli.ts‎
Lines changed: 30 additions & 1 deletion b/‎agent-node/src/cli.ts‎
Lines changed: 30 additions & 1 deletion
diff --git a/‎agent-node/src/grok-isolated-cwd.test.ts‎
Lines changed: 197 additions & 0 deletions b/‎agent-node/src/grok-isolated-cwd.test.ts‎
Lines changed: 197 additions & 0 deletions
diff --git a/‎agent-node/src/grok-isolated-cwd.ts‎
Lines changed: 120 additions & 0 deletions b/‎agent-node/src/grok-isolated-cwd.ts‎
Lines changed: 120 additions & 0 deletions
@@ -1,6 +1,6 @@
 {
   "name": "@sleep2agi/agent-node",
-  "version": "2.4.7-preview.6",
+  "version": "2.4.7-preview.7",
   "description": "AI Agent runtime for CommHub networks. Supports Claude Agent SDK, Codex SDK, and OpenAI/Anthropic-compatible HTTP API.",
   "bin": {
     "agent-node": "dist/cli.js"
 
@@ -1335,11 +1335,40 @@ async function processWithGrok(task: string, from: string, images?: string[]): P
     url: `${COMMHUB_URL}/mcp`,
     headers,
   }];
+
+  // #204 preview.7 — per-node isolated cwd. preview.2 → preview.6 chain
+  // showed that even with HTTP MCP injected via ACP, Grok CLI ALSO reads
+  // the cwd `.mcp.json` and spawns a *second* commhub MCP server from
+  // there. That second instance carries whatever `COMMHUB_ALIAS=<stale>`
+  // was last written to the file (Vincent's grok-build/.mcp.json had
+  // `grok测试员` from a prior `anet node start`), and Grok's hello-
+  // message tool call routes to that stale server, breaking attribution.
+  //
+  // Fix: pass an isolated cwd to ACP `session/new` so Grok's cwd-discovery
+  // hits an empty dir (no .mcp.json) and only our ACP-injected HTTP MCP
+  // is in play. Logic extracted to `grok-isolated-cwd.ts` so it can be
+  // unit-tested without spinning up a real Grok agent (preview.7 Phase 2
+  // smoke ran into the obvious "exercising algorithm end-to-end needs
+  // real Grok + xAI auth" problem).
+  const { prepareGrokIsolatedCwd } = await import("./grok-isolated-cwd");
+  const isolatedResult = prepareGrokIsolatedCwd({
+    userCwd: process.cwd(),
+    nodeId: NODE_ID,
+    alias: ALIAS,
+    onWarn: (m) => warn(`[grok] ${m}`),
+  });
+  if (isolatedResult.isolated) {
+    log(`[grok] #204 isolated cwd: ${isolatedResult.cwd} (symlinked=${isolatedResult.symlinked}, skipped=${isolatedResult.skipped})`);
+  } else {
+    warn(`[grok] #204 isolated cwd failed: ${isolatedResult.error} — falling back to process.cwd(), may re-read project .mcp.json`);
+  }
+  const grokCwd = isolatedResult.cwd;
+
   const runOnce = async (sessionId?: string, label = "primary") => {
     const t0 = Date.now();
     const result = await runGrokAcpTurn({
       prompt: buildGrokCommhubPrompt(task, from),
-      cwd: process.cwd(),
+      cwd: grokCwd,
       sessionId,
       mcpServers: grokMcpServers,
       timeoutMs: parseInt(process.env.GROK_ACP_TIMEOUT_MS || fileConfig.flags?.grokAcpTimeoutMs || "300000"),
 
@@ -0,0 +1,197 @@
+// #204 preview.7 — unit tests for `prepareGrokIsolatedCwd`.
+//
+// We use a real (but disposable) temp tree as `home`, so the helper exercises
+// the actual fs ops (mkdir / readdir / symlink / stat) rather than mocked
+// stubs. Faster + more reliable than the Docker E2E (which needs real Grok +
+// xAI auth), and catches the same algorithm bugs the original smoke would.
+
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import {
+  chmodSync,
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  mkdtempSync,
+  readlinkSync,
+  rmSync,
+  writeFileSync,
+} from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import { prepareGrokIsolatedCwd } from "./grok-isolated-cwd";
+
+describe("prepareGrokIsolatedCwd (#204 preview.7)", () => {
+  let tmpRoot: string;
+  let userCwd: string;
+  let fakeHome: string;
+
+  beforeEach(() => {
+    tmpRoot = mkdtempSync(join(tmpdir(), "p204-iso-cwd-"));
+    userCwd = join(tmpRoot, "user-project");
+    fakeHome = join(tmpRoot, "fake-home");
+    mkdirSync(userCwd, { recursive: true });
+    mkdirSync(fakeHome, { recursive: true });
+    // Plant a realistic Vincent-style user cwd:
+    //   - .mcp.json (stale, must be skipped)
+    //   - README.md (top-level file — must be symlinked)
+    //   - docs/ (top-level dir — must be symlinked as dir)
+    //   - src/index.ts (nested file — only its parent `src` gets a top-level
+    //     symlink; the nested file is accessible via that symlink)
+    writeFileSync(join(userCwd, ".mcp.json"), '{"mcpServers":{"commhub":{"env":{"COMMHUB_ALIAS":"bogus-stale"}}}}');
+    writeFileSync(join(userCwd, "README.md"), "user project README\n");
+    mkdirSync(join(userCwd, "docs"), { recursive: true });
+    writeFileSync(join(userCwd, "docs", "intro.md"), "doc body\n");
+    mkdirSync(join(userCwd, "src"), { recursive: true });
+    writeFileSync(join(userCwd, "src", "noindex.ts"), "// app entry\n");
+  });
+
+  afterEach(() => {
+    try { rmSync(tmpRoot, { recursive: true, force: true }); } catch { /* noop */ }
+  });
+
+  it("creates per-node grok-cwd directory under home/.anet/nodes/<nodeKey>/grok-cwd", () => {
+    const r = prepareGrokIsolatedCwd({ userCwd, nodeId: "n_abc123", home: fakeHome });
+    expect(r.isolated).toBe(true);
+    expect(r.cwd).toBe(join(fakeHome, ".anet", "nodes", "n_abc123", "grok-cwd"));
+    expect(existsSync(r.cwd)).toBe(true);
+  });
+
+  it("falls back to alias when nodeId is absent", () => {
+    const r = prepareGrokIsolatedCwd({ userCwd, alias: "grok-test-A", home: fakeHome });
+    expect(r.cwd).toBe(join(fakeHome, ".anet", "nodes", "grok-test-A", "grok-cwd"));
+    expect(r.isolated).toBe(true);
+  });
+
+  it("sanitises nodeKey to avoid path traversal / weird chars", () => {
+    const r = prepareGrokIsolatedCwd({ userCwd, alias: "../escape/../bad alias.txt", home: fakeHome });
+    // Slashes / spaces / `..` segments collapse — `.` and `_` and `-` are
+    // preserved (they're not traversal-dangerous as part of a single segment).
+    // Assert: the resolved real path stays *under* fakeHome (no escape).
+    const { resolve } = require("path");
+    const resolved = resolve(r.cwd);
+    expect(resolved.startsWith(resolve(fakeHome) + "/")).toBe(true);
+    // No raw path separator slipped through.
+    const nodeKeySegment = resolved.split("/nodes/")[1].split("/")[0];
+    expect(nodeKeySegment).not.toContain("/");
+    expect(r.isolated).toBe(true);
+  });
+
+  it("skips .mcp.json (does NOT symlink it into isolated cwd)", () => {
+    const r = prepareGrokIsolatedCwd({ userCwd, nodeId: "n_skip", home: fakeHome });
+    expect(r.isolated).toBe(true);
+    expect(r.skipped).toBe(1); // exactly the .mcp.json
+    expect(existsSync(join(r.cwd, ".mcp.json"))).toBe(false);
+  });
+
+  it("symlinks top-level files (README.md) and directories (docs/, src/)", () => {
+    const r = prepareGrokIsolatedCwd({ userCwd, nodeId: "n_symlink", home: fakeHome });
+    expect(r.isolated).toBe(true);
+    // README.md is a regular-file symlink
+    const readmeLink = join(r.cwd, "README.md");
+    expect(existsSync(readmeLink)).toBe(true);
+    expect(lstatSync(readmeLink).isSymbolicLink()).toBe(true);
+    expect(readlinkSync(readmeLink)).toBe(join(userCwd, "README.md"));
+    // docs/ is a directory-symlink — and the nested file is reachable via it
+    const docsLink = join(r.cwd, "docs");
+    expect(lstatSync(docsLink).isSymbolicLink()).toBe(true);
+    expect(existsSync(join(docsLink, "intro.md"))).toBe(true);
+    // src/ likewise
+    const srcLink = join(r.cwd, "src");
+    expect(lstatSync(srcLink).isSymbolicLink()).toBe(true);
+    expect(existsSync(join(srcLink, "noindex.ts"))).toBe(true);
+    // 3 entries symlinked (README, docs, src) — .mcp.json is skipped
+    expect(r.symlinked).toBe(3);
+  });
+
+  it("is idempotent — second run sees existing symlinks and counts 0 new", () => {
+    const r1 = prepareGrokIsolatedCwd({ userCwd, nodeId: "n_idem", home: fakeHome });
+    expect(r1.symlinked).toBe(3);
+    expect(r1.skipped).toBe(1);
+
+    // Second run — same opts, same cwd. Must not throw EEXIST + must report
+    // 0 new symlinks (existing ones are kept as-is for cheapness).
+    const r2 = prepareGrokIsolatedCwd({ userCwd, nodeId: "n_idem", home: fakeHome });
+    expect(r2.isolated).toBe(true);
+    expect(r2.symlinked).toBe(0);
+    expect(r2.skipped).toBe(1);
+    // Symlinks still resolve
+    expect(existsSync(join(r2.cwd, "README.md"))).toBe(true);
+  });
+
+  it("picks up new entries on re-run (snapshot freshness)", () => {
+    const r1 = prepareGrokIsolatedCwd({ userCwd, nodeId: "n_fresh", home: fakeHome });
+    expect(r1.symlinked).toBe(3);
+    // User adds a new file after first prepare (mid-session)
+    writeFileSync(join(userCwd, "NEW.md"), "newly added\n");
+    const r2 = prepareGrokIsolatedCwd({ userCwd, nodeId: "n_fresh", home: fakeHome });
+    // Old 3 are existsSync-hit → not re-symlinked; only NEW.md is added.
+    expect(r2.symlinked).toBe(1);
+    expect(existsSync(join(r2.cwd, "NEW.md"))).toBe(true);
+  });
+
+  it("falls back to userCwd (isolated=false) when mkdir fails", () => {
+    // Make fakeHome non-writable so mkdirSync(<home>/.anet/...) fails.
+    chmodSync(fakeHome, 0o555);
+    const warns: string[] = [];
+    const r = prepareGrokIsolatedCwd({
+      userCwd,
+      nodeId: "n_perm",
+      home: fakeHome,
+      onWarn: (m) => warns.push(m),
+    });
+    chmodSync(fakeHome, 0o755); // restore for cleanup
+    expect(r.isolated).toBe(false);
+    expect(r.cwd).toBe(userCwd);
+    expect(r.error).toMatch(/mkdir failed/);
+  });
+
+  it("falls back to userCwd when userCwd does not exist (readdir fails)", () => {
+    const r = prepareGrokIsolatedCwd({
+      userCwd: join(tmpRoot, "does-not-exist"),
+      nodeId: "n_noread",
+      home: fakeHome,
+    });
+    expect(r.isolated).toBe(false);
+    // cwd echoes back input even on failure so caller has a non-empty value
+    expect(r.cwd).toContain("does-not-exist");
+    expect(r.error).toMatch(/readdir userCwd failed/);
+  });
+
+  it("does NOT throw on per-entry symlink failure — warns and continues", () => {
+    // Pre-create a *real file* at the would-be symlink target so symlinkSync
+    // would race-collide on a parallel test. Simpler: create a dst dir that
+    // is non-writable. Actually easiest: just put a regular file at the dst
+    // path so existsSync returns true and the loop skips it cleanly. This
+    // exercises the "already exists" branch; for true per-entry failure we
+    // need an unreachable src. Use a broken symlink as src:
+    const brokenSrc = join(userCwd, "broken-link");
+    // ../truly-missing → broken on resolution but readdir lists it
+    require("fs").symlinkSync(join(tmpRoot, "truly-missing"), brokenSrc);
+
+    const warns: string[] = [];
+    const r = prepareGrokIsolatedCwd({
+      userCwd,
+      nodeId: "n_broken",
+      home: fakeHome,
+      onWarn: (m) => warns.push(m),
+    });
+    expect(r.isolated).toBe(true);
+    // broken-link triggered statSync failure → onWarn called → loop continues
+    expect(warns.some((w) => w.includes("broken-link"))).toBe(true);
+    // The other 3 valid entries still got symlinked.
+    expect(r.symlinked).toBeGreaterThanOrEqual(3);
+    // .mcp.json still skipped
+    expect(r.skipped).toBe(1);
+  });
+
+  it("two different nodes get fully isolated dirs (concurrency safe by construction)", () => {
+    const a = prepareGrokIsolatedCwd({ userCwd, nodeId: "n_alpha", home: fakeHome });
+    const b = prepareGrokIsolatedCwd({ userCwd, nodeId: "n_beta", home: fakeHome });
+    expect(a.cwd).not.toBe(b.cwd);
+    expect(a.cwd).toContain("/n_alpha/");
+    expect(b.cwd).toContain("/n_beta/");
+    // Both have own copies of the symlinked README
+    expect(existsSync(join(a.cwd, "README.md"))).toBe(true);
+    expect(existsSync(join(b.cwd, "README.md"))).toBe(true);
+  });
+});
@@ -0,0 +1,120 @@
+// #204 preview.7 — per-node isolated cwd for grok-build-acp runtime.
+//
+// Why this exists (in 3 lines):
+//   1. Grok CLI auto-discovers MCP servers from <cwd>/.mcp.json on spawn.
+//   2. Vincent's user cwd can carry a stale .mcp.json (COMMHUB_ALIAS=<old node>).
+//   3. We need Grok to find NO .mcp.json — only the ACP-injected HTTP MCP.
+//
+// Strategy: pass `~/.anet/nodes/<nodeKey>/grok-cwd/` as the ACP session/new
+// `cwd` field. That dir mirrors the user's top-level entries via symlink
+// (so LLM `Read('./README.md')` still works) but explicitly omits
+// `.mcp.json` so Grok's cwd-discovery finds nothing.
+//
+// Extracted from inline processWithGrok block to make it testable: the
+// inline path was failing Docker smoke not because the algorithm is wrong
+// but because exercising it end-to-end requires a real Grok binary +
+// xAI auth. A direct bun-test against this helper is faster and more
+// reliable; the Docker self-test then only verifies install/boot.
+
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  statSync,
+  symlinkSync,
+} from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+export interface PrepareGrokIsolatedCwdInput {
+  /** User's project cwd (typically `process.cwd()`). */
+  userCwd: string;
+  /** Per-node key — used to construct the isolated dir. Prefers node_id; falls back to alias. */
+  nodeId?: string;
+  alias?: string;
+  /** Override for tests so we don't always touch `~/.anet/`. Defaults to `homedir()`. */
+  home?: string;
+  /** Optional logger for symlink failures (test can capture). Defaults to silent. */
+  onWarn?: (msg: string) => void;
+}
+
+export interface PrepareGrokIsolatedCwdResult {
+  /** The cwd to pass into ACP `session/new`. Falls back to `userCwd` on failure. */
+  cwd: string;
+  /** True when isolated dir was successfully prepared. */
+  isolated: boolean;
+  /** Number of entries symlinked this call (excludes already-existing). */
+  symlinked: number;
+  /** Number of entries skipped (only `.mcp.json` today). */
+  skipped: number;
+  /** Failure message if `isolated === false`. */
+  error?: string;
+}
+
+/**
+ * Idempotent: re-running with the same userCwd/nodeId is safe and cheap.
+ * Existing symlinks are left as-is; we never overwrite or unlink.
+ *
+ * Per-entry try/catch ensures a single bad symlink (permission denied,
+ * cross-device, etc.) doesn't break the whole loop — we warn and move on.
+ *
+ * Top-level mirroring only (no recursion). Mid-session new files in the
+ * user cwd are NOT picked up until the next `prepare` call — acceptable
+ * trade-off for #204 P0 (P3 follow-up: fs.watch + relink).
+ */
+export function prepareGrokIsolatedCwd(
+  opts: PrepareGrokIsolatedCwdInput,
+): PrepareGrokIsolatedCwdResult {
+  const userCwd = opts.userCwd;
+  const home = opts.home ?? homedir();
+  const warn = opts.onWarn ?? (() => {});
+  const rawKey = opts.nodeId || opts.alias || "default";
+  const nodeKey = rawKey.replace(/[^A-Za-z0-9._-]/g, "_");
+  const isolatedCwd = join(home, ".anet", "nodes", nodeKey, "grok-cwd");
+
+  try {
+    mkdirSync(isolatedCwd, { recursive: true });
+  } catch (e: any) {
+    return {
+      cwd: userCwd,
+      isolated: false,
+      symlinked: 0,
+      skipped: 0,
+      error: `mkdir failed: ${e?.message || e}`,
+    };
+  }
+
+  let entries: string[];
+  try {
+    entries = readdirSync(userCwd);
+  } catch (e: any) {
+    return {
+      cwd: userCwd,
+      isolated: false,
+      symlinked: 0,
+      skipped: 0,
+      error: `readdir userCwd failed: ${e?.message || e}`,
+    };
+  }
+
+  let symlinked = 0;
+  let skipped = 0;
+  for (const entry of entries) {
+    if (entry === ".mcp.json") {
+      skipped++;
+      continue;
+    }
+    const src = join(userCwd, entry);
+    const dst = join(isolatedCwd, entry);
+    if (existsSync(dst)) continue; // idempotent — restart-safe
+    try {
+      const st = statSync(src);
+      symlinkSync(src, dst, st.isDirectory() ? "dir" : "file");
+      symlinked++;
+    } catch (e: any) {
+      warn(`#204 skip symlink ${entry}: ${e?.message || e}`);
+    }
+  }
+
+  return { cwd: isolatedCwd, isolated: true, symlinked, skipped };
+}
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "@sleep2agi/agent-node",`
`3`		`- "version": "2.4.7-preview.6",`
	`3`	`+ "version": "2.4.7-preview.7",`
`4`	`4`	`"description": "AI Agent runtime for CommHub networks. Supports Claude Agent SDK, Codex SDK, and OpenAI/Anthropic-compatible HTTP API.",`
`5`	`5`	`"bin": {`
`6`	`6`	`"agent-node": "dist/cli.js"`