@botcord/daemon 0.2.5 → 0.2.8

package/src/doctor.ts

@@ -31,9 +31,34 @@ export interface DoctorHttpResult {
   error?: string;
 }
 
+/** One endpoint probe entry, mirrored from `RuntimeEndpointProbe`. */
+export interface DoctorRuntimeEndpoint {
+  name: string;
+  url: string;
+  reachable: boolean;
+  version?: string;
+  error?: string;
+  agents?: Array<{
+    id: string;
+    name?: string;
+    workspace?: string;
+    model?: { name?: string; provider?: string };
+  }>;
+  /**
+   * Optional warning surfaced by the doctor: e.g. botcord plugin loaded on
+   * the gateway (would form a daemon → openclaw → botcord → Hub loop).
+   */
+  warnings?: string[];
+}
+
+/** Augmented runtime entry that may carry endpoint probe results. */
+export interface DoctorRuntimeEntry extends RuntimeProbeEntry {
+  endpoints?: DoctorRuntimeEndpoint[];
+}
+
 /** Input for the rendered doctor output. */
 export interface DoctorInput {
-  runtimes: RuntimeProbeEntry[];
+  runtimes: DoctorRuntimeEntry[];
   channels: ChannelProbeResult[];
 }
 
@@ -226,10 +251,32 @@ export function renderDoctor(input: DoctorInput): string {
   lines.push(
     `${pad("RUNTIME", widths.runtime)}  ${pad("NAME", widths.name)}  ${pad("STATUS", widths.status)}  ${pad("VERSION", widths.version)}  PATH`,
   );
-  for (const r of rows) {
+  for (let i = 0; i < rows.length; i += 1) {
+    const r = rows[i];
+    const e = input.runtimes[i];
     lines.push(
       `${pad(r.runtime, widths.runtime)}  ${pad(r.name, widths.name)}  ${pad(r.status, widths.status)}  ${pad(r.version, widths.version)}  ${r.path}`,
     );
+    if (e.endpoints && e.endpoints.length > 0) {
+      for (const ep of e.endpoints) {
+        const mark = ep.reachable ? "✓" : "✗";
+        const detail = ep.reachable
+          ? ep.version ?? "ok"
+          : ep.error ?? "unreachable";
+        lines.push(`    gateway ${pad(`"${ep.name}"`, 16)} ${pad(ep.url, 40)} ${mark} ${detail}`);
+        if (ep.agents && ep.agents.length > 0) {
+          // RFC §3.8.4: list by `id` (stable key); show display name when distinct.
+          lines.push(
+            `      agents (id): ${ep.agents
+              .map((a) => (a.name && a.name !== a.id ? `${a.id} (${a.name})` : a.id))
+              .join(", ")}`,
+          );
+        }
+        if (ep.warnings) {
+          for (const w of ep.warnings) lines.push(`      WARN: ${w}`);
+        }
+      }
+    }
   }
   const available = input.runtimes.filter((e) => e.result.available).length;
   lines.push(`\n${available}/${input.runtimes.length} runtimes available`);

package/src/gateway/__tests__/dispatcher.test.ts

@@ -1551,6 +1551,71 @@ describe("Dispatcher", () => {
     expect(composedItemCounts[1]).toBeLessThanOrEqual(8);
   });
 
+  it("attentionGate=false skips the runtime turn but still acks and runs onInbound (PR3)", async () => {
+    const runtime = new FakeRuntime();
+    const { store, dir } = await makeStore();
+    tempDirs.push(dir);
+    const channel = new FakeChannel();
+    const channels = new Map<string, ChannelAdapter>([[channel.id, channel]]);
+    const accept = vi.fn(async () => {});
+    const onInbound = vi.fn();
+    const attentionGate = vi.fn(async () => false);
+    const dispatcher = new Dispatcher({
+      config: baseConfig(),
+      channels,
+      runtime: () => runtime,
+      sessionStore: store,
+      log: silentLogger(),
+      onInbound,
+      attentionGate,
+    });
+    await dispatcher.handle(makeEnvelope({ id: "m_gated", text: "hello" }, { accept }));
+    expect(accept).toHaveBeenCalledTimes(1);
+    expect(onInbound).toHaveBeenCalledTimes(1);
+    expect(attentionGate).toHaveBeenCalledTimes(1);
+    expect(runtime.calls.length).toBe(0);
+    expect(channel.sends.length).toBe(0);
+  });
+
+  it("attentionGate=true wakes the runtime as usual (PR3)", async () => {
+    const runtime = new FakeRuntime({ reply: "ok", newSessionId: "sid-1" });
+    const { store, dir } = await makeStore();
+    tempDirs.push(dir);
+    const channel = new FakeChannel();
+    const channels = new Map<string, ChannelAdapter>([[channel.id, channel]]);
+    const dispatcher = new Dispatcher({
+      config: baseConfig(),
+      channels,
+      runtime: () => runtime,
+      sessionStore: store,
+      log: silentLogger(),
+      attentionGate: () => true,
+    });
+    await dispatcher.handle(makeEnvelope({ id: "m_wake" }));
+    expect(runtime.calls.length).toBe(1);
+    expect(channel.sends.length).toBe(1);
+  });
+
+  it("attentionGate throwing fails open and runs the turn (PR3)", async () => {
+    const runtime = new FakeRuntime({ reply: "ok", newSessionId: "sid-1" });
+    const { store, dir } = await makeStore();
+    tempDirs.push(dir);
+    const channel = new FakeChannel();
+    const channels = new Map<string, ChannelAdapter>([[channel.id, channel]]);
+    const dispatcher = new Dispatcher({
+      config: baseConfig(),
+      channels,
+      runtime: () => runtime,
+      sessionStore: store,
+      log: silentLogger(),
+      attentionGate: () => {
+        throw new Error("boom");
+      },
+    });
+    await dispatcher.handle(makeEnvelope({ id: "m_wake_throw" }));
+    expect(runtime.calls.length).toBe(1);
+  });
+
   it("owner-chat detection: dashboard_user_chat in non-rm_oc room still sends reply", async () => {
     const runtime = new FakeRuntime({ reply: "ok", newSessionId: "sid-1" });
     const { dispatcher, channel } = await scaffold({

package/src/gateway/__tests__/hermes-agent-adapter.test.ts

@@ -0,0 +1,302 @@
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import {
+  chmodSync,
+  existsSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { HermesAgentAdapter } from "../runtimes/hermes-agent.js";
+import { agentHermesWorkspaceDir } from "../../agent-workspace.js";
+
+// Spawn a tiny Node "ACP server" we control instead of the real hermes-acp.
+const tmpRoot = mkdtempSync(path.join(os.tmpdir(), "gateway-hermes-"));
+
+const originalHome = process.env.HOME;
+const agentHomeRoot = mkdtempSync(path.join(os.tmpdir(), "gateway-hermes-home-"));
+
+beforeAll(() => {
+  process.env.HOME = agentHomeRoot;
+});
+
+afterAll(() => {
+  if (originalHome === undefined) delete process.env.HOME;
+  else process.env.HOME = originalHome;
+  rmSync(tmpRoot, { recursive: true, force: true });
+  rmSync(agentHomeRoot, { recursive: true, force: true });
+});
+
+/**
+ * Mock ACP server. Reads newline-delimited JSON-RPC messages from stdin
+ * and replies on stdout. The script body controls the per-test scenario.
+ */
+function makeAcpServer(name: string, script: string): string {
+  const body = `
+const lines = [];
+let buf = "";
+process.stdin.setEncoding("utf8");
+function send(obj) { process.stdout.write(JSON.stringify(obj) + "\\n"); }
+function reply(req, result) { send({ jsonrpc: "2.0", id: req.id, result }); }
+function err(req, code, message) { send({ jsonrpc: "2.0", id: req.id, error: { code, message } }); }
+function notify(method, params) { send({ jsonrpc: "2.0", method, params }); }
+let nextReqId = 1000;
+const pending = new Map();
+function request(method, params) {
+  const id = nextReqId++;
+  return new Promise((resolve, reject) => {
+    pending.set(id, { resolve, reject });
+    send({ jsonrpc: "2.0", id, method, params });
+  });
+}
+async function handle(msg) {
+${script}
+}
+process.stdin.on("data", async (chunk) => {
+  buf += chunk;
+  let idx;
+  while ((idx = buf.indexOf("\\n")) !== -1) {
+    const line = buf.slice(0, idx).trim();
+    buf = buf.slice(idx + 1);
+    if (!line) continue;
+    let msg;
+    try { msg = JSON.parse(line); } catch { continue; }
+    // Server received a response to a request it sent
+    if (typeof msg.id === "number" && (msg.result !== undefined || msg.error !== undefined) && pending.has(msg.id)) {
+      const p = pending.get(msg.id);
+      pending.delete(msg.id);
+      if (msg.error) p.reject(msg.error); else p.resolve(msg.result);
+      continue;
+    }
+    try { await handle(msg); } catch (e) { process.stderr.write("mock error: " + e + "\\n"); }
+  }
+});
+process.stdin.on("end", () => process.exit(0));
+`;
+  const p = path.join(tmpRoot, name);
+  writeFileSync(p, `#!/usr/bin/env node\n${body}\n`, { mode: 0o755 });
+  chmodSync(p, 0o755);
+  return p;
+}
+
+interface RunOpts {
+  sessionId?: string | null;
+  trustLevel?: "owner" | "trusted" | "public";
+  systemContext?: string;
+  accountId?: string;
+  onBlock?: (b: unknown) => void;
+}
+
+function runAdapter(script: string, opts: RunOpts = {}) {
+  const adapter = new HermesAgentAdapter({ binary: script });
+  const ctrl = new AbortController();
+  return adapter.run({
+    text: "hello",
+    sessionId: opts.sessionId ?? null,
+    accountId: opts.accountId ?? "ag_hermes_test",
+    cwd: tmpRoot,
+    signal: ctrl.signal,
+    trustLevel: opts.trustLevel ?? "owner",
+    systemContext: opts.systemContext,
+    onBlock: opts.onBlock as never,
+  });
+}
+
+describe("HermesAgentAdapter", () => {
+  it("happy path: initialize → session/new → session/prompt with streamed text", async () => {
+    const script = makeAcpServer(
+      "happy.js",
+      `
+        if (msg.method === "initialize") {
+          reply(msg, { protocolVersion: 1, agentInfo: { name: "mock", version: "0.0.1" }, agentCapabilities: {} });
+        } else if (msg.method === "session/new") {
+          reply(msg, { sessionId: "sess-001" });
+        } else if (msg.method === "session/prompt") {
+          notify("session/update", { sessionId: msg.params.sessionId, update: { sessionUpdate: "agent_message_chunk", content: { type: "text", text: "hi " } } });
+          notify("session/update", { sessionId: msg.params.sessionId, update: { sessionUpdate: "agent_message_chunk", content: { type: "text", text: "world" } } });
+          reply(msg, { stopReason: "end_turn" });
+          process.stdin.pause();
+          process.exit(0);
+        }
+      `,
+    );
+    const blocks: any[] = [];
+    const res = await runAdapter(script, { onBlock: (b) => blocks.push(b) });
+    expect(res.error).toBeUndefined();
+    expect(res.newSessionId).toBe("sess-001");
+    expect(res.text).toBe("hi world");
+    expect(blocks.map((b) => b.kind)).toContain("assistant_text");
+  });
+
+  it("session/load success → reuses incoming sessionId", async () => {
+    const script = makeAcpServer(
+      "load.js",
+      `
+        if (msg.method === "initialize") {
+          reply(msg, { protocolVersion: 1 });
+        } else if (msg.method === "session/load") {
+          // Hermes returns null/empty body without sessionId — adapter must
+          // reuse opts.sessionId.
+          reply(msg, {});
+        } else if (msg.method === "session/new") {
+          reply(msg, { sessionId: "should-not-be-used" });
+        } else if (msg.method === "session/prompt") {
+          notify("session/update", { sessionId: msg.params.sessionId, update: { sessionUpdate: "agent_message_chunk", content: { type: "text", text: "resumed" } } });
+          reply(msg, { stopReason: "end_turn" });
+          process.exit(0);
+        }
+      `,
+    );
+    const res = await runAdapter(script, { sessionId: "sess-existing" });
+    expect(res.newSessionId).toBe("sess-existing");
+    expect(res.text).toBe("resumed");
+  });
+
+  it("session/load failure → falls back to session/new", async () => {
+    const script = makeAcpServer(
+      "load-miss.js",
+      `
+        if (msg.method === "initialize") {
+          reply(msg, { protocolVersion: 1 });
+        } else if (msg.method === "session/load") {
+          err(msg, -32000, "not found");
+        } else if (msg.method === "session/new") {
+          reply(msg, { sessionId: "sess-fresh" });
+        } else if (msg.method === "session/prompt") {
+          reply(msg, { stopReason: "end_turn" });
+          process.exit(0);
+        }
+      `,
+    );
+    const res = await runAdapter(script, { sessionId: "sess-stale" });
+    expect(res.newSessionId).toBe("sess-fresh");
+    expect(res.error).toBeUndefined();
+  });
+
+  it("owner trust → request_permission selects an allow_* option", async () => {
+    const script = makeAcpServer(
+      "perm-allow.js",
+      `
+        if (msg.method === "initialize") {
+          reply(msg, { protocolVersion: 1 });
+        } else if (msg.method === "session/new") {
+          reply(msg, { sessionId: "sess-perm" });
+        } else if (msg.method === "session/prompt") {
+          const outcome = await request("session/request_permission", {
+            sessionId: msg.params.sessionId,
+            toolCall: { name: "shell", rawInput: { cmd: "ls" } },
+            options: [
+              { optionId: "allow", name: "Allow", kind: "allow_once" },
+              { optionId: "deny", name: "Deny", kind: "reject_once" }
+            ]
+          });
+          notify("session/update", { sessionId: msg.params.sessionId, update: { sessionUpdate: "agent_message_chunk", content: { type: "text", text: "outcome=" + JSON.stringify(outcome) } } });
+          reply(msg, { stopReason: "end_turn" });
+          process.exit(0);
+        }
+      `,
+    );
+    const res = await runAdapter(script, { trustLevel: "owner" });
+    expect(res.text).toContain('"outcome":"selected"');
+    expect(res.text).toContain('"optionId":"allow"');
+  });
+
+  it("public trust → request_permission cancels", async () => {
+    const script = makeAcpServer(
+      "perm-deny.js",
+      `
+        if (msg.method === "initialize") {
+          reply(msg, { protocolVersion: 1 });
+        } else if (msg.method === "session/new") {
+          reply(msg, { sessionId: "sess-perm" });
+        } else if (msg.method === "session/prompt") {
+          const outcome = await request("session/request_permission", {
+            sessionId: msg.params.sessionId,
+            options: [
+              { optionId: "allow", kind: "allow_once" },
+              { optionId: "deny", kind: "reject_once" }
+            ]
+          });
+          notify("session/update", { sessionId: msg.params.sessionId, update: { sessionUpdate: "agent_message_chunk", content: { type: "text", text: JSON.stringify(outcome) } } });
+          reply(msg, { stopReason: "end_turn" });
+          process.exit(0);
+        }
+      `,
+    );
+    const res = await runAdapter(script, { trustLevel: "public" });
+    expect(res.text).toContain('"outcome":"cancelled"');
+    expect(res.text).not.toContain("optionId");
+  });
+
+  it("writes systemContext to <hermes-workspace>/AGENTS.md before spawn", async () => {
+    const script = makeAcpServer(
+      "ctx.js",
+      `
+        if (msg.method === "initialize") { reply(msg, { protocolVersion: 1 }); }
+        else if (msg.method === "session/new") { reply(msg, { sessionId: "sess-ctx" }); }
+        else if (msg.method === "session/prompt") { reply(msg, { stopReason: "end_turn" }); process.exit(0); }
+      `,
+    );
+    await runAdapter(script, {
+      accountId: "ag_ctx_test",
+      systemContext: "MEMORY: remember X\nDIGEST: room Y",
+    });
+    const ws = agentHermesWorkspaceDir("ag_ctx_test");
+    const agentsMd = path.join(ws, "AGENTS.md");
+    expect(existsSync(agentsMd)).toBe(true);
+    const body = readFileSync(agentsMd, "utf8");
+    expect(body).toContain("MEMORY: remember X");
+    expect(body).toContain("DIGEST: room Y");
+  });
+
+  it("session/new uses hermes-workspace as cwd, not the route cwd", async () => {
+    const script = makeAcpServer(
+      "cwd-echo.js",
+      `
+        if (msg.method === "initialize") { reply(msg, { protocolVersion: 1 }); }
+        else if (msg.method === "session/new") {
+          reply(msg, { sessionId: "sess-cwd" });
+          // Echo back the cwd we received via a streamed update on prompt.
+          this.__cwd = msg.params && msg.params.cwd;
+        } else if (msg.method === "session/prompt") {
+          notify("session/update", { sessionId: msg.params.sessionId, update: { sessionUpdate: "agent_message_chunk", content: { type: "text", text: this.__cwd || "" } } });
+          reply(msg, { stopReason: "end_turn" });
+          process.exit(0);
+        }
+      `,
+    );
+    const res = await runAdapter(script, { accountId: "ag_cwd_test" });
+    expect(res.text).toBe(agentHermesWorkspaceDir("ag_cwd_test"));
+  });
+
+  it("returns early when signal is already aborted", async () => {
+    const script = makeAcpServer("noop.js", "");
+    const adapter = new HermesAgentAdapter({ binary: script });
+    const ctrl = new AbortController();
+    ctrl.abort();
+    const res = await adapter.run({
+      text: "x",
+      sessionId: null,
+      accountId: "ag_hermes_test",
+      cwd: tmpRoot,
+      signal: ctrl.signal,
+      trustLevel: "owner",
+    });
+    expect(res.text).toBe("");
+    expect(res.error).toMatch(/aborted before spawn/);
+  });
+
+  it("surfaces non-zero exit with stderr snippet", async () => {
+    const p = path.join(tmpRoot, "boom.js");
+    writeFileSync(
+      p,
+      `#!/usr/bin/env node\nprocess.stderr.write("hermes auth required\\n"); process.exit(2);\n`,
+      { mode: 0o755 },
+    );
+    chmodSync(p, 0o755);
+    const res = await runAdapter(p);
+    expect(res.error).toBeDefined();
+  });
+});