@botcord/daemon 0.1.1

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

@@ -0,0 +1,147 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+import {
+  agentHomeDir,
+  agentStateDir,
+  agentWorkspaceDir,
+  ensureAgentWorkspace,
+} from "../agent-workspace.js";
+
+let tmpHome = "";
+let prevHome: string | undefined;
+
+beforeEach(() => {
+  tmpHome = mkdtempSync(path.join(os.tmpdir(), "daemon-workspace-"));
+  prevHome = process.env.HOME;
+  process.env.HOME = tmpHome;
+});
+
+afterEach(() => {
+  if (prevHome === undefined) delete process.env.HOME;
+  else process.env.HOME = prevHome;
+  if (tmpHome) rmSync(tmpHome, { recursive: true, force: true });
+});
+
+describe("ensureAgentWorkspace", () => {
+  it("creates the full tree + seed files from a clean slate", () => {
+    ensureAgentWorkspace("ag_fresh", {
+      displayName: "Writer",
+      bio: "A careful assistant.",
+      runtime: "claude-code",
+      keyId: "k_abc",
+      savedAt: "2026-04-23T00:00:00Z",
+    });
+
+    const home = agentHomeDir("ag_fresh");
+    const workspace = agentWorkspaceDir("ag_fresh");
+    const state = agentStateDir("ag_fresh");
+
+    expect(home.startsWith(tmpHome)).toBe(true);
+    expect(existsSync(home)).toBe(true);
+    expect(statSync(home).isDirectory()).toBe(true);
+    expect(existsSync(workspace)).toBe(true);
+    expect(existsSync(state)).toBe(true);
+    expect(existsSync(path.join(workspace, "notes"))).toBe(true);
+
+    for (const name of ["AGENTS.md", "CLAUDE.md", "identity.md", "memory.md", "task.md"]) {
+      expect(existsSync(path.join(workspace, name))).toBe(true);
+    }
+
+    const agentsMd = readFileSync(path.join(workspace, "AGENTS.md"), "utf8");
+    const claudeMd = readFileSync(path.join(workspace, "CLAUDE.md"), "utf8");
+    expect(agentsMd).toBe(claudeMd);
+    expect(agentsMd).toContain("# Agent Workspace");
+
+    const identity = readFileSync(path.join(workspace, "identity.md"), "utf8");
+    expect(identity).toContain("ag_fresh");
+    expect(identity).toContain("Writer");
+    expect(identity).toContain("claude-code");
+    expect(identity).toContain("k_abc");
+    expect(identity).toContain("2026-04-23T00:00:00Z");
+    expect(identity).toContain("A careful assistant.");
+  });
+
+  it("places .gitkeep inside notes/", () => {
+    ensureAgentWorkspace("ag_notes", {});
+    expect(existsSync(path.join(agentWorkspaceDir("ag_notes"), "notes", ".gitkeep"))).toBe(true);
+  });
+
+  it("does not overwrite a user-modified memory.md on a second call", () => {
+    ensureAgentWorkspace("ag_keep", {});
+    const memoryPath = path.join(agentWorkspaceDir("ag_keep"), "memory.md");
+    writeFileSync(memoryPath, "my custom notes\n");
+
+    ensureAgentWorkspace("ag_keep", {});
+
+    expect(readFileSync(memoryPath, "utf8")).toBe("my custom notes\n");
+  });
+
+  it("identity.md renders the bio placeholder when bio is missing", () => {
+    ensureAgentWorkspace("ag_nobio", { displayName: "Nameless" });
+    const identity = readFileSync(path.join(agentWorkspaceDir("ag_nobio"), "identity.md"), "utf8");
+    expect(identity).toContain("_(none provided at provision time");
+    expect(identity).toContain("## Bio");
+  });
+
+  it("identity.md degrades gracefully when runtime/keyId/savedAt are absent", () => {
+    ensureAgentWorkspace("ag_sparse", {});
+    const identity = readFileSync(path.join(agentWorkspaceDir("ag_sparse"), "identity.md"), "utf8");
+    expect(identity).toContain("ag_sparse");
+    // Placeholder used for every missing scalar field.
+    expect(identity).toContain("_(not set)_");
+    expect(identity).toContain("_(none provided at provision time");
+  });
+
+  describe("agentId safety", () => {
+    // Defence-in-depth: if a malformed/hostile agentId reached these path
+    // builders, `revokeAgent(deleteWorkspace:true)`'s `rmSync(home, {recursive:true})`
+    // would happily wipe data outside ~/.botcord/agents/.
+    const hostile = [
+      "../escape",
+      "../../etc",
+      "foo/bar",
+      "..",
+      ".",
+      "",
+      "has spaces",
+      "a\0b",
+      "foo/../bar",
+    ];
+    for (const id of hostile) {
+      it(`rejects unsafe agentId ${JSON.stringify(id)}`, () => {
+        expect(() => agentHomeDir(id)).toThrow();
+        expect(() => agentWorkspaceDir(id)).toThrow();
+        expect(() => agentStateDir(id)).toThrow();
+        expect(() => ensureAgentWorkspace(id, {})).toThrow();
+      });
+    }
+
+    it("accepts realistic agent ids", () => {
+      for (const ok of ["ag_abc123", "ag_XYZ_9", "ag-dash-ok", "A1", "ag_0"]) {
+        expect(() => agentHomeDir(ok)).not.toThrow();
+      }
+    });
+  });
+
+  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");
+    // Creation goes via ensureAgentWorkspace's recursive mkdir, which wouldn't
+    // override an existing mode — that's precisely the bug we fix.
+    mkdirSync(home, { recursive: true, mode: 0o755 });
+    ensureAgentWorkspace("ag_upgrade", {});
+    const mode = statSync(home).mode & 0o777;
+    expect(mode).toBe(0o700);
+  });
+});

package/src/__tests__/control-channel.test.ts

@@ -0,0 +1,327 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { EventEmitter } from "node:events";
+import {
+  buildDaemonWebSocketUrl,
+  CONTROL_FRAME_TYPES,
+  generateKeypair,
+  type ControlFrame,
+} from "@botcord/protocol-core";
+import { sign as nodeSign } from "node:crypto";
+import { ControlChannel, controlSigningInput } from "../control-channel.js";
+import { UserAuthManager, type UserAuthRecord } from "../user-auth.js";
+import * as userAuthModule from "../user-auth.js";
+
+function makeAuthRecord(overrides: Partial<UserAuthRecord> = {}): UserAuthRecord {
+  return {
+    version: 1,
+    userId: "usr_1",
+    daemonInstanceId: "dm_1",
+    hubUrl: "http://localhost:9000",
+    accessToken: "at_1",
+    refreshToken: "rt_1",
+    expiresAt: Date.now() + 60 * 60_000,
+    loggedInAt: new Date().toISOString(),
+    ...overrides,
+  };
+}
+
+/**
+ * Minimal in-memory fake of `ws` that mimics what ControlChannel uses:
+ * `open` event after construction, `message`/`close`/`error` listeners,
+ * `ping()`, `send()`, `close()`, and `readyState`. Each instance records
+ * the URL + headers it was constructed with.
+ */
+class FakeWebSocket extends EventEmitter {
+  public readyState = 0;
+  public sent: string[] = [];
+  public closed = false;
+  static OPEN = 1;
+  constructor(public url: string, public opts: { headers?: Record<string, string> } = {}) {
+    super();
+    setImmediate(() => {
+      this.readyState = FakeWebSocket.OPEN;
+      this.emit("open");
+    });
+  }
+  send(data: string): void {
+    this.sent.push(data);
+  }
+  ping(): void {
+    /* noop for tests */
+  }
+  close(): void {
+    this.closed = true;
+    this.emit("close", 1000, Buffer.from("test"));
+  }
+  static readonly instances: FakeWebSocket[] = [];
+}
+
+function makeFakeCtor(): typeof FakeWebSocket & ((url: string, opts?: unknown) => FakeWebSocket) {
+  // The ControlChannel uses `new this.webSocketCtor(url, { headers })`.
+  // We capture each instance for assertions.
+  function Ctor(url: string, opts: { headers?: Record<string, string> } = {}) {
+    const ws = new FakeWebSocket(url, opts);
+    FakeWebSocket.instances.push(ws);
+    return ws;
+  }
+  // Inherit static OPEN + readonly enum used by ControlChannel.
+  (Ctor as unknown as { OPEN: number }).OPEN = FakeWebSocket.OPEN;
+  return Ctor as unknown as typeof FakeWebSocket & ((url: string, opts?: unknown) => FakeWebSocket);
+}
+
+describe("buildDaemonWebSocketUrl", () => {
+  it("appends a label query string when provided", () => {
+    const url = buildDaemonWebSocketUrl("http://localhost:9000", "/daemon/ws", {
+      label: "MacBook Pro",
+    });
+    expect(url).toContain("ws://localhost:9000/daemon/ws?");
+    expect(url).toContain("label=MacBook+Pro");
+  });
+
+  it("omits the query string when no label", () => {
+    expect(buildDaemonWebSocketUrl("http://localhost:9000", "/daemon/ws")).toBe(
+      "ws://localhost:9000/daemon/ws",
+    );
+  });
+});
+
+describe("ControlChannel — label propagation", () => {
+  beforeEach(() => {
+    FakeWebSocket.instances.length = 0;
+  });
+
+  it("sends the label from auth.current.label as ?label= on connect", async () => {
+    const auth = new UserAuthManager({
+      record: makeAuthRecord({ label: "MacBook Pro" }),
+      file: "/tmp/never-written-user-auth.json",
+    });
+    const ctor = makeFakeCtor();
+    const ch = new ControlChannel({
+      auth,
+      handle: () => ({ ok: true }),
+      webSocketCtor: ctor as unknown as typeof import("ws").default,
+      hubPublicKey: null,
+    });
+    await ch.start();
+    expect(FakeWebSocket.instances).toHaveLength(1);
+    expect(FakeWebSocket.instances[0].url).toContain("label=MacBook+Pro");
+    await ch.stop();
+  });
+
+  it("explicit opts.label overrides the persisted label", async () => {
+    const auth = new UserAuthManager({
+      record: makeAuthRecord({ label: "Old" }),
+      file: "/tmp/never-written-user-auth.json",
+    });
+    const ctor = makeFakeCtor();
+    const ch = new ControlChannel({
+      auth,
+      handle: () => ({ ok: true }),
+      label: "New",
+      webSocketCtor: ctor as unknown as typeof import("ws").default,
+      hubPublicKey: null,
+    });
+    await ch.start();
+    expect(FakeWebSocket.instances[0].url).toContain("label=New");
+    await ch.stop();
+  });
+
+  it("omits the query string when there is no label anywhere", async () => {
+    const auth = new UserAuthManager({
+      record: makeAuthRecord(),
+      file: "/tmp/never-written-user-auth.json",
+    });
+    const ctor = makeFakeCtor();
+    const ch = new ControlChannel({
+      auth,
+      handle: () => ({ ok: true }),
+      webSocketCtor: ctor as unknown as typeof import("ws").default,
+      hubPublicKey: null,
+    });
+    await ch.start();
+    expect(FakeWebSocket.instances[0].url).not.toContain("?");
+    await ch.stop();
+  });
+});
+
+describe("ControlChannel — Hub signature verification", () => {
+  beforeEach(() => {
+    FakeWebSocket.instances.length = 0;
+  });
+
+  function ed25519PrivateKeyForSigning(seedB64: string) {
+    // Mirror protocol-core/crypto.ts privateKeyFromSeed.
+    const prefix = Buffer.from("302e020100300506032b657004220420", "hex");
+    const seed = Buffer.from(seedB64, "base64");
+    return require("node:crypto").createPrivateKey({
+      key: Buffer.concat([prefix, seed]),
+      format: "der",
+      type: "pkcs8",
+    });
+  }
+
+  function signFrame(frame: Omit<ControlFrame, "sig">, privateKeyB64: string): ControlFrame {
+    const input = controlSigningInput(frame);
+    const pk = ed25519PrivateKeyForSigning(privateKeyB64);
+    const sig = nodeSign(null, Buffer.from(input, "utf8"), pk).toString("base64");
+    return { ...frame, sig };
+  }
+
+  it("accepts and dispatches a properly-signed frame", async () => {
+    const { privateKey, publicKey } = generateKeypair();
+    const handler = vi.fn(async () => ({ ok: true, result: { handled: true } }));
+    const auth = new UserAuthManager({
+      record: makeAuthRecord(),
+      file: "/tmp/never-written-user-auth.json",
+    });
+    const ctor = makeFakeCtor();
+    const ch = new ControlChannel({
+      auth,
+      handle: handler,
+      hubPublicKey: publicKey,
+      webSocketCtor: ctor as unknown as typeof import("ws").default,
+    });
+    await ch.start();
+    const frame = signFrame(
+      { id: "f1", type: CONTROL_FRAME_TYPES.PING, ts: Date.now() },
+      privateKey,
+    );
+    FakeWebSocket.instances[0].emit("message", Buffer.from(JSON.stringify(frame)));
+    // Allow the async handler microtask to flush.
+    await new Promise((r) => setImmediate(r));
+    expect(handler).toHaveBeenCalledOnce();
+    await ch.stop();
+  });
+
+  it("rejects frames with no signature when a Hub key is configured", async () => {
+    const { publicKey } = generateKeypair();
+    const handler = vi.fn(async () => ({ ok: true }));
+    const auth = new UserAuthManager({
+      record: makeAuthRecord(),
+      file: "/tmp/never-written-user-auth.json",
+    });
+    const ctor = makeFakeCtor();
+    const ch = new ControlChannel({
+      auth,
+      handle: handler,
+      hubPublicKey: publicKey,
+      webSocketCtor: ctor as unknown as typeof import("ws").default,
+    });
+    await ch.start();
+    const ws = FakeWebSocket.instances[0];
+    ws.emit(
+      "message",
+      Buffer.from(JSON.stringify({ id: "f1", type: "ping", ts: Date.now() })),
+    );
+    await new Promise((r) => setImmediate(r));
+    expect(handler).not.toHaveBeenCalled();
+    const acks = ws.sent.map((s) => JSON.parse(s));
+    expect(acks[0].ok).toBe(false);
+    expect(acks[0].error.code).toBe("unsigned");
+    await ch.stop();
+  });
+
+  it("rejects frames whose signature does not verify", async () => {
+    const wrongKey = generateKeypair();
+    const otherKey = generateKeypair();
+    const handler = vi.fn(async () => ({ ok: true }));
+    const auth = new UserAuthManager({
+      record: makeAuthRecord(),
+      file: "/tmp/never-written-user-auth.json",
+    });
+    const ctor = makeFakeCtor();
+    const ch = new ControlChannel({
+      auth,
+      handle: handler,
+      // Daemon trusts otherKey.publicKey; Hub signs with wrongKey.privateKey.
+      hubPublicKey: otherKey.publicKey,
+      webSocketCtor: ctor as unknown as typeof import("ws").default,
+    });
+    await ch.start();
+    const frame = signFrame(
+      { id: "f2", type: CONTROL_FRAME_TYPES.PING, ts: Date.now() },
+      wrongKey.privateKey,
+    );
+    const ws = FakeWebSocket.instances[0];
+    ws.emit("message", Buffer.from(JSON.stringify(frame)));
+    await new Promise((r) => setImmediate(r));
+    expect(handler).not.toHaveBeenCalled();
+    const acks = ws.sent.map((s) => JSON.parse(s));
+    expect(acks[0].ok).toBe(false);
+    expect(acks[0].error.code).toBe("bad_signature");
+    await ch.stop();
+  });
+
+  it("dispatches unsigned frames when no Hub key is configured (P1 dev mode)", async () => {
+    const handler = vi.fn(async () => ({ ok: true }));
+    const auth = new UserAuthManager({
+      record: makeAuthRecord(),
+      file: "/tmp/never-written-user-auth.json",
+    });
+    const ctor = makeFakeCtor();
+    const ch = new ControlChannel({
+      auth,
+      handle: handler,
+      hubPublicKey: null,
+      webSocketCtor: ctor as unknown as typeof import("ws").default,
+    });
+    await ch.start();
+    FakeWebSocket.instances[0].emit(
+      "message",
+      Buffer.from(JSON.stringify({ id: "f1", type: "ping", ts: Date.now() })),
+    );
+    await new Promise((r) => setImmediate(r));
+    expect(handler).toHaveBeenCalledOnce();
+    await ch.stop();
+  });
+});
+
+describe("ControlChannel — REVOKE frame (plan §6.3)", () => {
+  beforeEach(() => {
+    FakeWebSocket.instances.length = 0;
+  });
+
+  it("acks revoke, writes auth-expired flag, and stops reconnecting without invoking the user handler", async () => {
+    const writeSpy = vi.spyOn(userAuthModule, "writeAuthExpiredFlag").mockImplementation(() => {});
+
+    const handler = vi.fn(async () => ({ ok: true }));
+    const auth = new UserAuthManager({
+      record: makeAuthRecord(),
+      file: "/tmp/never-written-user-auth.json",
+    });
+    const ctor = makeFakeCtor();
+    const ch = new ControlChannel({
+      auth,
+      handle: handler,
+      hubPublicKey: null,
+      webSocketCtor: ctor as unknown as typeof import("ws").default,
+    });
+    await ch.start();
+    const ws = FakeWebSocket.instances[0];
+    ws.emit(
+      "message",
+      Buffer.from(
+        JSON.stringify({
+          id: "rv1",
+          type: "revoke",
+          ts: Date.now(),
+          params: { reason: "test" },
+        }),
+      ),
+    );
+    await new Promise((r) => setImmediate(r));
+
+    expect(writeSpy).toHaveBeenCalledOnce();
+    expect(handler).not.toHaveBeenCalled();
+    const acks = ws.sent.map((s) => JSON.parse(s));
+    expect(acks[0]).toEqual({ id: "rv1", ok: true, result: { acknowledged: true } });
+    // Channel should self-stop and refuse further connects.
+    expect(ch.isConnected).toBe(false);
+
+    writeSpy.mockRestore();
+  });
+});
+
+afterEach(() => {
+  FakeWebSocket.instances.length = 0;
+});

package/src/__tests__/cross-room.test.ts

@@ -0,0 +1,116 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { mkdtempSync, rmSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { ActivityTracker } from "../activity-tracker.js";
+import { buildCrossRoomDigest } from "../cross-room.js";
+
+let tmpDir = "";
+let tracker: ActivityTracker;
+
+beforeEach(() => {
+  tmpDir = mkdtempSync(path.join(os.tmpdir(), "daemon-xr-"));
+  tracker = new ActivityTracker({ filePath: path.join(tmpDir, "activity.json") });
+});
+afterEach(() => {
+  if (tmpDir) rmSync(tmpDir, { recursive: true, force: true });
+});
+
+describe("buildCrossRoomDigest", () => {
+  it("returns null when there are no other rooms", () => {
+    tracker.record({
+      agentId: "ag_me",
+      roomId: "rm_only",
+      topic: null,
+      lastInboundPreview: "hi",
+      lastSenderKind: "agent",
+      lastSender: "ag_peer",
+    });
+    const digest = buildCrossRoomDigest({
+      tracker,
+      agentId: "ag_me",
+      currentRoomId: "rm_only",
+    });
+    expect(digest).toBeNull();
+  });
+
+  it("renders up to maxEntries active rooms, newest first, with sender + preview", () => {
+    const base = Date.now();
+    for (let i = 0; i < 7; i++) {
+      tracker.record({
+        agentId: "ag_me",
+        roomId: `rm_${i}`,
+        roomName: `Room${i}`,
+        topic: null,
+        lastInboundPreview: `msg ${i}`,
+        lastSenderKind: "agent",
+        lastSender: `ag_p${i}`,
+        lastActivityAt: base - i * 60 * 1000,
+      });
+    }
+    const digest = buildCrossRoomDigest({
+      tracker,
+      agentId: "ag_me",
+      currentRoomId: "rm_0",
+      maxEntries: 3,
+    });
+    expect(digest).not.toBeNull();
+    expect(digest).toContain("[BotCord Cross-Room Awareness]");
+    // 7 rooms recorded (rm_0..rm_6), current is rm_0 → 6 others + 1 current = 7 total.
+    expect(digest).toContain("You are currently active in 7 BotCord sessions");
+    expect(digest).toContain("Room1 (rm_1)");
+    expect(digest).toContain("Room2 (rm_2)");
+    expect(digest).toContain("Room3 (rm_3)");
+    // maxEntries=3 so Room4+ shouldn't appear
+    expect(digest).not.toContain("Room4 (rm_4)");
+    expect(digest).toContain("agent ag_p1: msg 1");
+  });
+
+  it("skips entries outside windowMs", () => {
+    const base = Date.now();
+    tracker.record({
+      agentId: "ag_me",
+      roomId: "rm_recent",
+      topic: null,
+      lastInboundPreview: "fresh",
+      lastSenderKind: "agent",
+      lastSender: "ag_p",
+      lastActivityAt: base - 5 * 60 * 1000,
+    });
+    tracker.record({
+      agentId: "ag_me",
+      roomId: "rm_stale",
+      topic: null,
+      lastInboundPreview: "stale",
+      lastSenderKind: "agent",
+      lastSender: "ag_p",
+      lastActivityAt: base - 3 * 60 * 60 * 1000,
+    });
+    const digest = buildCrossRoomDigest({
+      tracker,
+      agentId: "ag_me",
+      currentRoomId: "rm_somewhere",
+      windowMs: 2 * 60 * 60 * 1000,
+    });
+    expect(digest).toContain("rm_recent");
+    expect(digest).not.toContain("rm_stale");
+  });
+
+  it("labels human sender differently from agent", () => {
+    tracker.record({
+      agentId: "ag_me",
+      roomId: "rm_humans",
+      topic: null,
+      lastInboundPreview: "hi",
+      lastSenderKind: "human",
+      lastSender: "Alice",
+    });
+    const digest = buildCrossRoomDigest({
+      tracker,
+      agentId: "ag_me",
+      currentRoomId: "rm_somewhere",
+    });
+    expect(digest).toContain("human Alice:");
+    expect(digest).not.toContain("agent Alice:");
+  });
+});