@botcord/daemon 0.2.5 → 0.2.8

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

@@ -0,0 +1,150 @@
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import {
+  discoverLocalOpenclawGateways,
+  mergeOpenclawGateways,
+} from "../openclaw-discovery.js";
+import type { DaemonConfig } from "../config.js";
+import type { WsEndpointProbeFn } from "../provision.js";
+
+let tmp: string | null = null;
+
+afterEach(() => {
+  if (tmp) rmSync(tmp, { recursive: true, force: true });
+  tmp = null;
+});
+
+function tempDir(): string {
+  tmp = mkdtempSync(path.join(tmpdir(), "openclaw-discovery-"));
+  return tmp;
+}
+
+function baseConfig(): DaemonConfig {
+  return {
+    defaultRoute: { adapter: "claude-code", cwd: "/tmp" },
+    routes: [],
+    streamBlocks: true,
+  };
+}
+
+describe("discoverLocalOpenclawGateways", () => {
+  it("discovers JSON and TOML acp config files", async () => {
+    const dir = tempDir();
+    writeFileSync(
+      path.join(dir, "one.json"),
+      JSON.stringify({ acp: { url: "ws://127.0.0.1:18789/acp", tokenFile: "/tmp/token" } }),
+    );
+    writeFileSync(
+      path.join(dir, "two.toml"),
+      ['[acp]', 'url = "ws://127.0.0.1:18790/acp"', 'token = "secret"'].join("\n"),
+    );
+
+    const found = await discoverLocalOpenclawGateways({
+      searchPaths: [dir],
+      defaultPorts: [],
+    });
+
+    expect(found).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          url: "ws://127.0.0.1:18789/acp",
+          tokenFile: "/tmp/token",
+          source: "config-file",
+        }),
+        expect.objectContaining({
+          url: "ws://127.0.0.1:18790/acp",
+          token: "secret",
+          source: "config-file",
+        }),
+      ]),
+    );
+  });
+
+  it("uses OPENCLAW_ACP_URL and token env vars", async () => {
+    const found = await discoverLocalOpenclawGateways({
+      searchPaths: [],
+      defaultPorts: [],
+      env: {
+        OPENCLAW_ACP_URL: "ws://127.0.0.1:18888/acp",
+        OPENCLAW_ACP_TOKEN: "env-token",
+      },
+    });
+
+    expect(found).toEqual([
+      expect.objectContaining({
+        url: "ws://127.0.0.1:18888/acp",
+        token: "env-token",
+        source: "env",
+      }),
+    ]);
+  });
+
+  it("adds default-port candidates only when the probe succeeds", async () => {
+    const probe = vi.fn<WsEndpointProbeFn>(async ({ url }) => ({
+      ok: url.includes("18789"),
+      agents: [],
+    }));
+
+    const found = await discoverLocalOpenclawGateways({
+      searchPaths: [],
+      defaultPorts: [18789, 18790],
+      probe,
+      timeoutMs: 10,
+    });
+
+    expect(probe).toHaveBeenCalledTimes(2);
+    expect(found.map((g) => g.url)).toEqual(["ws://127.0.0.1:18789"]);
+  });
+
+  it("prefers config-file auth details over lower-priority duplicate sources", async () => {
+    const dir = tempDir();
+    writeFileSync(
+      path.join(dir, "one.json"),
+      JSON.stringify({ acp: { url: "ws://127.0.0.1:18789", token: "file-token" } }),
+    );
+    const probe = vi.fn<WsEndpointProbeFn>(async () => ({ ok: true }));
+
+    const found = await discoverLocalOpenclawGateways({
+      searchPaths: [dir],
+      defaultPorts: [18789],
+      probe,
+      env: {
+        OPENCLAW_ACP_URL: "ws://127.0.0.1:18789",
+        OPENCLAW_ACP_TOKEN: "env-token",
+      },
+    });
+
+    expect(found).toHaveLength(1);
+    expect(found[0]).toEqual(
+      expect.objectContaining({ source: "config-file", token: "file-token" }),
+    );
+  });
+});
+
+describe("mergeOpenclawGateways", () => {
+  it("appends new URLs and keeps existing profiles untouched", () => {
+    const cfg = baseConfig();
+    cfg.openclawGateways = [{ name: "local", url: "ws://127.0.0.1:18789/acp", token: "user-token" }];
+    const merged = mergeOpenclawGateways(cfg, [
+      {
+        name: "openclaw-127-0-0-1-18789",
+        url: "ws://127.0.0.1:18789/acp",
+        token: "discovered-token",
+        source: "env",
+      },
+      {
+        name: "openclaw-127-0-0-1-18790",
+        url: "ws://127.0.0.1:18790/acp",
+        source: "default-port",
+      },
+    ]);
+
+    expect(merged.changed).toBe(true);
+    expect(merged.cfg.openclawGateways).toEqual([
+      { name: "local", url: "ws://127.0.0.1:18789/acp", token: "user-token" },
+      { name: "openclaw-127-0-0-1-18790", url: "ws://127.0.0.1:18790/acp" },
+    ]);
+  });
+});

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);
+  });
+});

package/src/__tests__/policy-updated-handler.test.ts

@@ -0,0 +1,144 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const mockState = {
+  cfg: {
+    defaultRoute: { adapter: "claude-code", cwd: "/tmp" },
+    routes: [],
+    streamBlocks: true,
+  } as Record<string, unknown>,
+  saved: [] as Array<Record<string, unknown>>,
+};
+
+vi.mock("../config.js", async () => {
+  const actual = await vi.importActual<typeof import("../config.js")>("../config.js");
+  return {
+    ...actual,
+    loadConfig: () => JSON.parse(JSON.stringify(mockState.cfg)) as Record<string, unknown>,
+    saveConfig: (next: Record<string, unknown>) => {
+      mockState.cfg = JSON.parse(JSON.stringify(next)) as Record<string, unknown>;
+      mockState.saved.push(JSON.parse(JSON.stringify(next)) as Record<string, unknown>);
+    },
+  };
+});
+
+const { createProvisioner } = await import("../provision.js");
+const { CONTROL_FRAME_TYPES } = await import("@botcord/protocol-core");
+import type { GatewayRoute, GatewayRuntimeSnapshot } from "../gateway/index.js";
+import type { PolicyResolverLike } from "../gateway/policy-resolver.js";
+
+beforeEach(() => {
+  mockState.cfg = {
+    defaultRoute: { adapter: "claude-code", cwd: "/tmp" },
+    routes: [],
+    streamBlocks: true,
+  };
+  mockState.saved = [];
+});
+
+function makeFakeGateway(): unknown {
+  const snap: GatewayRuntimeSnapshot = { channels: {}, turns: {} };
+  return {
+    addChannel: vi.fn(async () => {}),
+    removeChannel: vi.fn(async () => {}),
+    upsertManagedRoute: vi.fn(),
+    removeManagedRoute: vi.fn(),
+    replaceManagedRoutes: vi.fn(),
+    listManagedRoutes: () => [] as GatewayRoute[],
+    snapshot: () => snap,
+  };
+}
+
+function makeFakeResolver(): PolicyResolverLike & {
+  invalidate: ReturnType<typeof vi.fn>;
+  put: ReturnType<typeof vi.fn>;
+  resolve: ReturnType<typeof vi.fn>;
+} {
+  return {
+    resolve: vi.fn(async () => ({ mode: "always", keywords: [] })),
+    invalidate: vi.fn(),
+    put: vi.fn(),
+  };
+}
+
+describe("policy_updated control-frame handler", () => {
+  it("invalidates the resolver cache for the agent when payload has no policy", async () => {
+    const gw = makeFakeGateway();
+    const resolver = makeFakeResolver();
+    const provisioner = createProvisioner({
+      gateway: gw as Parameters<typeof createProvisioner>[0]["gateway"],
+      policyResolver: resolver,
+    });
+    const ack = await provisioner({
+      id: "f1",
+      type: CONTROL_FRAME_TYPES.POLICY_UPDATED,
+      params: { agent_id: "ag_a" },
+    });
+    expect(ack.ok).toBe(true);
+    expect(resolver.invalidate).toHaveBeenCalledWith("ag_a", undefined);
+    expect(resolver.put).not.toHaveBeenCalled();
+  });
+
+  it("invalidates only the per-room slot when room_id is present", async () => {
+    const resolver = makeFakeResolver();
+    const provisioner = createProvisioner({
+      gateway: makeFakeGateway() as Parameters<typeof createProvisioner>[0]["gateway"],
+      policyResolver: resolver,
+    });
+    await provisioner({
+      id: "f2",
+      type: CONTROL_FRAME_TYPES.POLICY_UPDATED,
+      params: { agent_id: "ag_a", room_id: "rm_1" },
+    });
+    expect(resolver.invalidate).toHaveBeenCalledWith("ag_a", "rm_1");
+  });
+
+  it("calls put() with the embedded policy when payload carries one", async () => {
+    const resolver = makeFakeResolver();
+    const provisioner = createProvisioner({
+      gateway: makeFakeGateway() as Parameters<typeof createProvisioner>[0]["gateway"],
+      policyResolver: resolver,
+    });
+    const ack = await provisioner({
+      id: "f3",
+      type: CONTROL_FRAME_TYPES.POLICY_UPDATED,
+      params: {
+        agent_id: "ag_a",
+        policy: { mode: "keyword", keywords: ["foo", "bar"], muted_until: 123 },
+      },
+    });
+    expect(ack.ok).toBe(true);
+    expect(resolver.put).toHaveBeenCalledWith("ag_a", null, {
+      mode: "keyword",
+      keywords: ["foo", "bar"],
+      muted_until: 123,
+    });
+    expect(resolver.invalidate).not.toHaveBeenCalled();
+  });
+
+  it("rejects payloads missing agent_id with bad_params", async () => {
+    const resolver = makeFakeResolver();
+    const provisioner = createProvisioner({
+      gateway: makeFakeGateway() as Parameters<typeof createProvisioner>[0]["gateway"],
+      policyResolver: resolver,
+    });
+    const ack = await provisioner({
+      id: "f4",
+      type: CONTROL_FRAME_TYPES.POLICY_UPDATED,
+      params: {},
+    });
+    expect(ack.ok).toBe(false);
+    expect(ack.error?.code).toBe("bad_params");
+  });
+
+  it("succeeds quietly when no resolver is wired", async () => {
+    const provisioner = createProvisioner({
+      gateway: makeFakeGateway() as Parameters<typeof createProvisioner>[0]["gateway"],
+    });
+    const ack = await provisioner({
+      id: "f5",
+      type: CONTROL_FRAME_TYPES.POLICY_UPDATED,
+      params: { agent_id: "ag_a" },
+    });
+    expect(ack.ok).toBe(true);
+  });
+});