@botcord/daemon 0.2.5 → 0.2.6

package/src/__tests__/agent-workspace.test.ts

@@ -15,6 +15,7 @@ import {
   agentHomeDir,
   agentStateDir,
   agentWorkspaceDir,
+  applyAgentIdentity,
   ensureAgentWorkspace,
 } from "../agent-workspace.js";
 
@@ -134,6 +135,98 @@ describe("ensureAgentWorkspace", () => {
     });
   });
 
+  describe("applyAgentIdentity", () => {
+    it("rewrites display name + bio while preserving Role/Boundaries", () => {
+      ensureAgentWorkspace("ag_edit", {
+        displayName: "Old",
+        bio: "Old bio",
+        runtime: "claude-code",
+      });
+      const identityPath = path.join(agentWorkspaceDir("ag_edit"), "identity.md");
+      const original = readFileSync(identityPath, "utf8");
+      // User personalises Role/Boundaries — must survive identity sync.
+      const customised = original
+        .replace("_(Describe what you do and for whom. Edit this section.)_", "I write poetry.")
+        .replace("_(What you will and will not do. Edit this section.)_", "No financial advice.");
+      writeFileSync(identityPath, customised);
+
+      const result = applyAgentIdentity("ag_edit", {
+        displayName: "New Name",
+        bio: "Refreshed bio.",
+      });
+      expect(result.changed).toBe(true);
+
+      const updated = readFileSync(identityPath, "utf8");
+      expect(updated).toContain("- **Display name**: New Name");
+      expect(updated).toContain("Refreshed bio.");
+      expect(updated).not.toContain("Old bio");
+      expect(updated).toContain("I write poetry.");
+      expect(updated).toContain("No financial advice.");
+    });
+
+    it("clears bio back to placeholder when null is passed", () => {
+      ensureAgentWorkspace("ag_clearbio", { bio: "Some bio" });
+      const result = applyAgentIdentity("ag_clearbio", { bio: null });
+      expect(result.changed).toBe(true);
+      const updated = readFileSync(
+        path.join(agentWorkspaceDir("ag_clearbio"), "identity.md"),
+        "utf8",
+      );
+      expect(updated).not.toContain("Some bio");
+      expect(updated).toContain("_(none provided at provision time");
+    });
+
+    it("returns no-change when patch matches current values", () => {
+      ensureAgentWorkspace("ag_idempotent", { displayName: "Same", bio: "Same bio" });
+      const result = applyAgentIdentity("ag_idempotent", {
+        displayName: "Same",
+        bio: "Same bio",
+      });
+      expect(result.changed).toBe(false);
+      expect(result.skipped).toBe("no-change");
+    });
+
+    it("skips when identity.md is missing", () => {
+      const result = applyAgentIdentity("ag_missing", { displayName: "X" });
+      expect(result.changed).toBe(false);
+      expect(result.skipped).toBe("missing-file");
+    });
+
+    it("rewrites correctly when identity.md has no trailing sections after Bio", () => {
+      ensureAgentWorkspace("ag_eofbio", { displayName: "Old", bio: "Old bio" });
+      const identityPath = path.join(agentWorkspaceDir("ag_eofbio"), "identity.md");
+      // Strip everything after `## Bio` so the Bio section runs to EOF.
+      const truncated =
+        readFileSync(identityPath, "utf8").replace(/(## Bio\n\nOld bio)[\s\S]*$/, "$1\n");
+      writeFileSync(identityPath, truncated);
+
+      const result = applyAgentIdentity("ag_eofbio", { bio: "New bio" });
+      expect(result.changed).toBe(true);
+      const updated = readFileSync(identityPath, "utf8");
+      expect(updated).toContain("New bio");
+      expect(updated).not.toContain("Old bio");
+    });
+
+    it("returns unparseable when the canonical metadata header is missing", () => {
+      ensureAgentWorkspace("ag_corrupt", {});
+      const identityPath = path.join(agentWorkspaceDir("ag_corrupt"), "identity.md");
+      writeFileSync(identityPath, "# Identity\n\nThis file was rewritten by a user.\n");
+
+      const result = applyAgentIdentity("ag_corrupt", { displayName: "X" });
+      expect(result.changed).toBe(false);
+      expect(result.skipped).toBe("unparseable");
+    });
+
+    it("treats display names containing regex specials literally", () => {
+      ensureAgentWorkspace("ag_specials", { displayName: "old" });
+      const identityPath = path.join(agentWorkspaceDir("ag_specials"), "identity.md");
+      const result = applyAgentIdentity("ag_specials", { displayName: "$1 backref $&" });
+      expect(result.changed).toBe(true);
+      const updated = readFileSync(identityPath, "utf8");
+      expect(updated).toContain("- **Display name**: $1 backref $&");
+    });
+  });
+
   it("tightens perms on a pre-existing agent home with looser mode", () => {
     // Simulate a home dir created by an older daemon with mode 0o755.
     const home = agentHomeDir("ag_upgrade");

package/src/__tests__/daemon-config-map.test.ts

@@ -400,6 +400,27 @@ describe("buildManagedRoutes", () => {
     });
   });
 
+  it("inherits defaultRoute.extraArgs (e.g. --permission-mode bypassPermissions)", () => {
+    const withExtraArgs: GatewayRoute = {
+      runtime: "claude-code",
+      cwd: "/home/default",
+      extraArgs: ["--permission-mode", "bypassPermissions"],
+    };
+    const map = buildManagedRoutes(["ag_one"], {}, withExtraArgs);
+    expect(map.get("ag_one")?.extraArgs).toEqual([
+      "--permission-mode",
+      "bypassPermissions",
+    ]);
+    // Ensure it's a copy, not the same reference — caller should not be able
+    // to mutate the defaultRoute by editing a managed route's extraArgs.
+    expect(map.get("ag_one")?.extraArgs).not.toBe(withExtraArgs.extraArgs);
+  });
+
+  it("omits extraArgs when defaultRoute has none", () => {
+    const map = buildManagedRoutes(["ag_one"], {}, defaultRoute);
+    expect(map.get("ag_one")).not.toHaveProperty("extraArgs");
+  });
+
   it("preserves agentIds insertion order in the returned map", () => {
     const map = buildManagedRoutes(
       ["ag_b", "ag_a", "ag_c"],
@@ -414,3 +435,61 @@ describe("buildManagedRoutes", () => {
     expect(map.size).toBe(0);
   });
 });
+
+describe("openclawGateways resolution", () => {
+  it("resolves a route gateway profile name into ResolvedOpenclawGateway", () => {
+    const cfg = baseConfig({
+      defaultRoute: { adapter: "claude-code", cwd: "/home/alice" },
+      openclawGateways: [
+        { name: "local", url: "ws://127.0.0.1:1", token: "t1", defaultAgent: "main" },
+      ],
+      routes: [
+        { match: { conversationId: "rm_x" }, adapter: "openclaw-acp", cwd: "/home/alice", gateway: "local" },
+      ],
+    });
+    const gw = toGatewayConfig(cfg);
+    expect(gw.routes[0].gateway).toEqual({
+      name: "local",
+      url: "ws://127.0.0.1:1",
+      token: "t1",
+      openclawAgent: "main",
+    });
+  });
+
+  it("route.openclawAgent overrides profile.defaultAgent", () => {
+    const cfg = baseConfig({
+      openclawGateways: [{ name: "p1", url: "ws://x", defaultAgent: "main" }],
+      routes: [{ match: {}, adapter: "openclaw-acp", cwd: "/home/alice", gateway: "p1", openclawAgent: "design" }],
+    });
+    const gw = toGatewayConfig(cfg);
+    expect(gw.routes[0].gateway?.openclawAgent).toBe("design");
+  });
+
+  it("buildManagedRoutes uses credentials openclawGateway / openclawAgent", () => {
+    const cfg = baseConfig({
+      agents: ["ag_one"],
+      openclawGateways: [{ name: "p1", url: "ws://x", defaultAgent: "main" }],
+    });
+    const gw = toGatewayConfig(cfg, {
+      agentIds: ["ag_one"],
+      agentRuntimes: { ag_one: { runtime: "openclaw-acp", openclawGateway: "p1", openclawAgent: "qa" } },
+    });
+    const managed = gw.managedRoutes?.find((r) => r.match?.accountId === "ag_one");
+    expect(managed?.runtime).toBe("openclaw-acp");
+    expect(managed?.gateway?.name).toBe("p1");
+    expect(managed?.gateway?.openclawAgent).toBe("qa");
+  });
+
+  it("buildManagedRoutes skips an openclaw-acp managed route when its gateway is unknown", () => {
+    const cfg = baseConfig({
+      agents: ["ag_one"],
+      openclawGateways: [{ name: "p1", url: "ws://x" }],
+    });
+    const gw = toGatewayConfig(cfg, {
+      agentIds: ["ag_one"],
+      agentRuntimes: { ag_one: { runtime: "openclaw-acp", openclawGateway: "missing" } },
+    });
+    expect(gw.managedRoutes).toEqual([]);
+  });
+});
+

package/src/__tests__/openclaw-acp.test.ts

@@ -0,0 +1,234 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { EventEmitter } from "node:events";
+import { PassThrough } from "node:stream";
+import {
+  OpenclawAcpAdapter,
+  __resetOpenclawAcpPoolForTests,
+  buildAcpSessionKey,
+} from "../gateway/runtimes/openclaw-acp.js";
+import type { ResolvedOpenclawGateway } from "../gateway/types.js";
+
+class FakeChild extends EventEmitter {
+  stdin = new PassThrough();
+  stdout = new PassThrough();
+  stderr = new PassThrough();
+  killed = false;
+  kill(): void {
+    this.killed = true;
+  }
+}
+
+function makeSpawn(child: FakeChild): any {
+  return () => child as unknown as ReturnType<typeof import("node:child_process").spawn>;
+}
+
+function readFrames(child: FakeChild): Promise<any[]> {
+  return new Promise((resolve) => {
+    const frames: any[] = [];
+    child.stdin.on("data", (chunk: Buffer) => {
+      const lines = chunk.toString("utf8").split("\n").filter(Boolean);
+      for (const line of lines) frames.push(JSON.parse(line));
+    });
+    setTimeout(() => resolve(frames), 50);
+  });
+}
+
+afterEach(() => {
+  __resetOpenclawAcpPoolForTests();
+});
+
+describe("buildAcpSessionKey", () => {
+  it("includes accountId so two daemon agents can't collide on a gateway key", () => {
+    const a = buildAcpSessionKey({
+      openclawAgent: "main",
+      accountId: "ag_alice",
+      conversationKey: "rm_x",
+    });
+    const b = buildAcpSessionKey({
+      openclawAgent: "main",
+      accountId: "ag_bob",
+      conversationKey: "rm_x",
+    });
+    expect(a).not.toBe(b);
+    expect(a).toContain("ag_alice");
+    expect(b).toContain("ag_bob");
+  });
+});
+
+describe("OpenclawAcpAdapter.run", () => {
+  it("fails fast when gateway is not provided", async () => {
+    const adapter = new OpenclawAcpAdapter({ spawnFn: makeSpawn(new FakeChild()) });
+    const res = await adapter.run({
+      text: "hi",
+      sessionId: null,
+      cwd: "/tmp",
+      accountId: "ag_alice",
+      signal: new AbortController().signal,
+      trustLevel: "owner",
+    });
+    expect(res.error).toMatch(/missing gateway/);
+  });
+
+  it("fails when gateway has no openclawAgent resolved", async () => {
+    const adapter = new OpenclawAcpAdapter({ spawnFn: makeSpawn(new FakeChild()) });
+    const gateway: ResolvedOpenclawGateway = {
+      name: "local",
+      url: "ws://127.0.0.1:1",
+    };
+    const res = await adapter.run({
+      text: "hi",
+      sessionId: null,
+      cwd: "/tmp",
+      accountId: "ag_alice",
+      signal: new AbortController().signal,
+      trustLevel: "owner",
+      gateway,
+    });
+    expect(res.error).toMatch(/openclawAgent/);
+  });
+
+  it("performs initialize → newSession → prompt and returns final text", async () => {
+    const child = new FakeChild();
+    const spawnFn = vi.fn().mockReturnValue(child);
+    const adapter = new OpenclawAcpAdapter({ spawnFn: spawnFn as any });
+    const gateway: ResolvedOpenclawGateway = {
+      name: "local",
+      url: "ws://127.0.0.1:1",
+      openclawAgent: "main",
+    };
+
+    // Seed the child stdout with replies as soon as stdin is written.
+    let nextSessionId = "acp-uuid-1";
+    let promptId: number | null = null;
+    child.stdin.on("data", (chunk: Buffer) => {
+      for (const line of chunk.toString("utf8").split("\n").filter(Boolean)) {
+        const frame = JSON.parse(line);
+        if (frame.method === "initialize") {
+          child.stdout.write(JSON.stringify({ jsonrpc: "2.0", id: frame.id, result: { protocolVersion: 1 } }) + "\n");
+        } else if (frame.method === "session/new") {
+          child.stdout.write(JSON.stringify({ jsonrpc: "2.0", id: frame.id, result: { sessionId: nextSessionId } }) + "\n");
+        } else if (frame.method === "session/prompt") {
+          promptId = frame.id;
+          // Stream a chunk then resolve.
+          child.stdout.write(
+            JSON.stringify({
+              jsonrpc: "2.0",
+              method: "session/update",
+              params: {
+                sessionId: nextSessionId,
+                update: { sessionUpdate: "agent_message_chunk", content: { text: "hello world" } },
+              },
+            }) + "\n",
+          );
+          setTimeout(() => {
+            child.stdout.write(JSON.stringify({ jsonrpc: "2.0", id: promptId, result: { text: "hello world" } }) + "\n");
+          }, 5);
+        }
+      }
+    });
+
+    const blocks: any[] = [];
+    const res = await adapter.run({
+      text: "hi",
+      sessionId: null,
+      cwd: "/tmp",
+      accountId: "ag_alice",
+      signal: new AbortController().signal,
+      trustLevel: "owner",
+      gateway,
+      onBlock: (b) => blocks.push(b),
+    });
+
+    expect(res.error).toBeUndefined();
+    expect(res.text).toBe("hello world");
+    expect(res.newSessionId).toBe("acp-uuid-1");
+    expect(blocks.length).toBeGreaterThan(0);
+    expect(blocks[0].kind).toBe("assistant_text");
+    expect(spawnFn).toHaveBeenCalledTimes(1);
+    expect(spawnFn.mock.calls[0][1]).toEqual(["acp", "--url", "ws://127.0.0.1:1"]);
+  });
+
+  it("respawns the pooled child when gateway.url or gateway.token changes under the same name", async () => {
+    function newChild(): FakeChild {
+      const c = new FakeChild();
+      c.stdin.on("data", (chunk: Buffer) => {
+        for (const line of chunk.toString("utf8").split("\n").filter(Boolean)) {
+          const frame = JSON.parse(line);
+          if (frame.method === "initialize") {
+            c.stdout.write(JSON.stringify({ jsonrpc: "2.0", id: frame.id, result: {} }) + "\n");
+          } else if (frame.method === "session/new") {
+            c.stdout.write(
+              JSON.stringify({ jsonrpc: "2.0", id: frame.id, result: { sessionId: "s" } }) + "\n",
+            );
+          } else if (frame.method === "session/prompt") {
+            c.stdout.write(
+              JSON.stringify({ jsonrpc: "2.0", id: frame.id, result: { text: "ok" } }) + "\n",
+            );
+          }
+        }
+      });
+      return c;
+    }
+    const children = [newChild(), newChild(), newChild()];
+    const spawnFn = vi.fn().mockImplementation(() => children.shift()! as any);
+    const adapter = new OpenclawAcpAdapter({ spawnFn: spawnFn as any });
+    const baseOpts = {
+      text: "hi",
+      sessionId: null,
+      cwd: "/tmp",
+      accountId: "ag_alice",
+      signal: new AbortController().signal,
+      trustLevel: "owner" as const,
+    };
+    await adapter.run({
+      ...baseOpts,
+      gateway: { name: "p1", url: "ws://a", token: "t1", openclawAgent: "main" },
+    });
+    await adapter.run({
+      ...baseOpts,
+      gateway: { name: "p1", url: "ws://b", token: "t1", openclawAgent: "main" },
+    });
+    await adapter.run({
+      ...baseOpts,
+      gateway: { name: "p1", url: "ws://b", token: "t2", openclawAgent: "main" },
+    });
+    expect(spawnFn).toHaveBeenCalledTimes(3);
+  });
+
+  it("reuses the pooled child for the same (accountId, gateway)", async () => {
+    const child = new FakeChild();
+    const spawnFn = vi.fn().mockReturnValue(child);
+    const adapter = new OpenclawAcpAdapter({ spawnFn: spawnFn as any });
+    const gateway: ResolvedOpenclawGateway = {
+      name: "local",
+      url: "ws://127.0.0.1:1",
+      openclawAgent: "main",
+    };
+
+    child.stdin.on("data", (chunk: Buffer) => {
+      for (const line of chunk.toString("utf8").split("\n").filter(Boolean)) {
+        const frame = JSON.parse(line);
+        if (frame.method === "initialize") {
+          child.stdout.write(JSON.stringify({ jsonrpc: "2.0", id: frame.id, result: { protocolVersion: 1 } }) + "\n");
+        } else if (frame.method === "session/new") {
+          child.stdout.write(JSON.stringify({ jsonrpc: "2.0", id: frame.id, result: { sessionId: "s1" } }) + "\n");
+        } else if (frame.method === "session/prompt") {
+          child.stdout.write(JSON.stringify({ jsonrpc: "2.0", id: frame.id, result: { text: "ok" } }) + "\n");
+        }
+      }
+    });
+
+    const opts = {
+      text: "hi",
+      sessionId: null,
+      cwd: "/tmp",
+      accountId: "ag_alice",
+      signal: new AbortController().signal,
+      trustLevel: "owner" as const,
+      gateway,
+    };
+    await adapter.run(opts);
+    await adapter.run({ ...opts, sessionId: "s1" });
+    expect(spawnFn).toHaveBeenCalledTimes(1);
+  });
+});

package/src/__tests__/policy-resolver.test.ts

@@ -0,0 +1,124 @@
+import { describe, expect, it, vi } from "vitest";
+import { PolicyResolver } from "../gateway/policy-resolver.js";
+import type { AttentionPolicy } from "@botcord/protocol-core";
+
+describe("PolicyResolver", () => {
+  it("returns default policy when fetchGlobal returns undefined", async () => {
+    const resolver = new PolicyResolver({ fetchGlobal: async () => undefined });
+    const p = await resolver.resolve("ag_a", null);
+    expect(p.mode).toBe("always");
+    expect(p.keywords).toEqual([]);
+  });
+
+  it("caches the global fetch result and reuses on the next resolve", async () => {
+    const fetchGlobal = vi.fn(async () => ({ mode: "muted", keywords: [] }) as AttentionPolicy);
+    const resolver = new PolicyResolver({ fetchGlobal });
+    await resolver.resolve("ag_a", null);
+    await resolver.resolve("ag_a", null);
+    expect(fetchGlobal).toHaveBeenCalledTimes(1);
+  });
+
+  it("invalidate(agent) drops all entries for that agent", async () => {
+    const fetchGlobal = vi.fn(async () => ({ mode: "always", keywords: [] }) as AttentionPolicy);
+    const resolver = new PolicyResolver({ fetchGlobal });
+    await resolver.resolve("ag_a", null);
+    await resolver.resolve("ag_a", null);
+    expect(fetchGlobal).toHaveBeenCalledTimes(1);
+    resolver.invalidate("ag_a");
+    await resolver.resolve("ag_a", null);
+    expect(fetchGlobal).toHaveBeenCalledTimes(2);
+  });
+
+  it("invalidate(agent, room) only drops the matching room entry", async () => {
+    const policy: AttentionPolicy = { mode: "always", keywords: [] };
+    const fetchGlobal = vi.fn(async () => policy);
+    const fetchEffective = vi.fn(async () => policy);
+    const resolver = new PolicyResolver({ fetchGlobal, fetchEffective });
+
+    await resolver.resolve("ag_a", null);
+    await resolver.resolve("ag_a", "rm_1");
+    await resolver.resolve("ag_a", "rm_2");
+    expect(fetchGlobal).toHaveBeenCalledTimes(1);
+    expect(fetchEffective).toHaveBeenCalledTimes(2);
+
+    resolver.invalidate("ag_a", "rm_1");
+    await resolver.resolve("ag_a", null); // still cached
+    await resolver.resolve("ag_a", "rm_2"); // still cached
+    await resolver.resolve("ag_a", "rm_1"); // refetched
+    expect(fetchGlobal).toHaveBeenCalledTimes(1);
+    expect(fetchEffective).toHaveBeenCalledTimes(3);
+  });
+
+  it("put() installs a policy without going through fetch", async () => {
+    const fetchGlobal = vi.fn(async () => undefined);
+    const resolver = new PolicyResolver({ fetchGlobal });
+    resolver.put("ag_a", null, { mode: "muted", keywords: [] });
+    const p = await resolver.resolve("ag_a", null);
+    expect(p.mode).toBe("muted");
+    expect(fetchGlobal).not.toHaveBeenCalled();
+  });
+
+  it("forces DM rooms (rm_dm_*) to mode=always even if cached muted", async () => {
+    const resolver = new PolicyResolver({ fetchGlobal: async () => undefined });
+    resolver.put("ag_a", "rm_dm_xyz", { mode: "muted", keywords: [] });
+    const p = await resolver.resolve("ag_a", "rm_dm_xyz");
+    expect(p.mode).toBe("always");
+  });
+
+  it("falls back to defaults when fetch throws", async () => {
+    const resolver = new PolicyResolver({
+      fetchGlobal: async () => {
+        throw new Error("boom");
+      },
+    });
+    const p = await resolver.resolve("ag_a", null);
+    expect(p.mode).toBe("always");
+  });
+
+  it("falls back to the cached global when resolving a room with no override", async () => {
+    // Regression: prior to the room→global fallback, group messages
+    // collapsed to mode=always whenever the daemon had no fetchEffective
+    // wired (the default state), silently breaking global mention_only/muted.
+    const resolver = new PolicyResolver({ fetchGlobal: async () => undefined });
+    resolver.put("ag_a", null, { mode: "mention_only", keywords: [] });
+    const p = await resolver.resolve("ag_a", "rm_1");
+    expect(p.mode).toBe("mention_only");
+  });
+
+  it("per-room override wins over the cached global", async () => {
+    const resolver = new PolicyResolver({ fetchGlobal: async () => undefined });
+    resolver.put("ag_a", null, { mode: "always", keywords: [] });
+    resolver.put("ag_a", "rm_1", { mode: "muted", keywords: [] });
+    const p = await resolver.resolve("ag_a", "rm_1");
+    expect(p.mode).toBe("muted");
+    // Other rooms still inherit the global.
+    expect((await resolver.resolve("ag_a", "rm_2")).mode).toBe("always");
+  });
+
+  it("invalidate(agent, room) drops the override and falls back to the cached global", async () => {
+    const resolver = new PolicyResolver({ fetchGlobal: async () => undefined });
+    resolver.put("ag_a", null, { mode: "mention_only", keywords: [] });
+    resolver.put("ag_a", "rm_1", { mode: "muted", keywords: [] });
+    expect((await resolver.resolve("ag_a", "rm_1")).mode).toBe("muted");
+    resolver.invalidate("ag_a", "rm_1");
+    expect((await resolver.resolve("ag_a", "rm_1")).mode).toBe("mention_only");
+  });
+
+  it("global update via put propagates to inheriting rooms without invalidation", async () => {
+    const resolver = new PolicyResolver({ fetchGlobal: async () => undefined });
+    resolver.put("ag_a", null, { mode: "always", keywords: [] });
+    expect((await resolver.resolve("ag_a", "rm_1")).mode).toBe("always");
+    // Hub fires policy_updated with new global policy → daemon does put().
+    resolver.put("ag_a", null, { mode: "muted", keywords: [] });
+    expect((await resolver.resolve("ag_a", "rm_1")).mode).toBe("muted");
+  });
+
+  it("expires cached entries after ttlMs", async () => {
+    const fetchGlobal = vi.fn(async () => ({ mode: "muted", keywords: [] }) as AttentionPolicy);
+    const resolver = new PolicyResolver({ fetchGlobal, ttlMs: 1 });
+    await resolver.resolve("ag_a", null);
+    await new Promise((r) => setTimeout(r, 5));
+    await resolver.resolve("ag_a", null);
+    expect(fetchGlobal).toHaveBeenCalledTimes(2);
+  });
+});