@botcord/daemon 0.2.74 → 0.2.76

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

@@ -188,6 +188,23 @@ function makeEnvelope(
   return { message: makeMessage(partial), ack };
 }
 
+function cloudRunRaw(
+  budget: { max_wall_time_seconds?: number; max_tool_calls?: number },
+): Record<string, unknown> {
+  return {
+    envelope: {
+      type: "cloud_run",
+      payload: {
+        text: "run this",
+        cloud_run: {
+          run_id: "crun_test",
+          budget,
+        },
+      },
+    },
+  };
+}
+
 function baseConfig(overrides: Partial<GatewayConfig> = {}): GatewayConfig {
   return {
     channels: [{ id: "botcord", type: "botcord", accountId: "ag_me" }],
@@ -225,6 +242,8 @@ describe("Dispatcher", () => {
     channel?: FakeChannel;
     runtimeFactory?: RuntimeFactory;
     turnTimeoutMs?: number;
+    runtimeAuthFailureThreshold?: number;
+    runtimeAuthFailureCooldownMs?: number;
   }) {
     const { store, dir } = await makeStore();
     tempDirs.push(dir);
@@ -237,6 +256,8 @@ describe("Dispatcher", () => {
       sessionStore: store,
       log: silentLogger(),
       turnTimeoutMs: args.turnTimeoutMs,
+      runtimeAuthFailureThreshold: args.runtimeAuthFailureThreshold,
+      runtimeAuthFailureCooldownMs: args.runtimeAuthFailureCooldownMs,
     });
     return { dispatcher, channel, store };
   }
@@ -293,6 +314,51 @@ describe("Dispatcher", () => {
     expect(store.all()[0].threadId).toBe("t_1");
   });
 
+  it("cloud_run: forwards budget caps to the runtime", async () => {
+    const runtime = new FakeRuntime({ reply: "ok", newSessionId: "sid-cloud" });
+    const { dispatcher } = await scaffold({
+      runtimeFactory: () => runtime,
+    });
+
+    await dispatcher.handle(
+      makeEnvelope({
+        id: "msg_cloud_budget",
+        raw: cloudRunRaw({ max_wall_time_seconds: 12, max_tool_calls: 7 }),
+      }),
+    );
+
+    expect(runtime.calls.length).toBe(1);
+    expect(runtime.calls[0].budget).toEqual({
+      maxWallTimeMs: 12000,
+      maxToolCalls: 7,
+    });
+  });
+
+  it("cloud_run: aborts the turn when tool-call budget is exceeded", async () => {
+    const runtime = new FakeRuntime({
+      reply: "should not deliver",
+      newSessionId: "sid-budget",
+      blocks: [
+        { raw: { type: "tool", name: "one" }, kind: "tool_use", seq: 1 },
+        { raw: { type: "tool", name: "two" }, kind: "tool_use", seq: 2 },
+      ],
+    });
+    const { dispatcher, channel, store } = await scaffold({
+      runtimeFactory: () => runtime,
+    });
+
+    await dispatcher.handle(
+      makeEnvelope({
+        id: "msg_cloud_tool_budget",
+        raw: cloudRunRaw({ max_tool_calls: 1 }),
+      }),
+    );
+
+    expect(channel.sends.length).toBe(1);
+    expect(channel.sends[0].message.text).toContain("Cloud run budget exceeded");
+    expect(store.all().length).toBe(0);
+  });
+
   it("sends replies to the provider reply id when it differs from the internal message id", async () => {
     const runtime = new FakeRuntime({ reply: "ok" });
     const feishuChannel = new FakeChannel({ id: "gw_feishu_1", type: "feishu" });
@@ -394,6 +460,60 @@ describe("Dispatcher", () => {
     expect(channel.sends[0].message.type).toBe("error");
   });
 
+  it("treats auth failure text as an error and does not persist the failed session", async () => {
+    let callNo = 0;
+    const runtimeFactory: RuntimeFactory = () => {
+      callNo += 1;
+      if (callNo === 1) return new FakeRuntime({ reply: "ok", newSessionId: "sid-1" });
+      return new FakeRuntime({
+        reply: "Failed to authenticate. API Error: 403 Request not allowed",
+        newSessionId: "sid-bad",
+      });
+    };
+    const { dispatcher, store, channel } = await scaffold({ runtimeFactory });
+
+    await dispatcher.handle(
+      makeEnvelope({ id: "msg_1", conversation: { id: "rm_oc_auth", kind: "direct" } }),
+    );
+    expect(store.all()[0].runtimeSessionId).toBe("sid-1");
+
+    await dispatcher.handle(
+      makeEnvelope({ id: "msg_2", conversation: { id: "rm_oc_auth", kind: "direct" } }),
+    );
+
+    expect(store.all().length).toBe(0);
+    expect(channel.sends).toHaveLength(2);
+    expect(channel.sends[1].message.type).toBe("error");
+    expect(channel.sends[1].message.text).toContain("Runtime error");
+    expect(channel.sends[1].message.text).toContain("Failed to authenticate");
+  });
+
+  it("opens an auth circuit breaker after repeated failures and skips runtime spawn", async () => {
+    const runtime = new FakeRuntime({
+      reply: "Failed to authenticate. API Error: 403 Request not allowed",
+      newSessionId: "sid-bad",
+    });
+    const { dispatcher, channel, store } = await scaffold({
+      runtimeFactory: () => runtime,
+      runtimeAuthFailureThreshold: 2,
+      runtimeAuthFailureCooldownMs: 60_000,
+    });
+    const conversation = { id: "rm_oc_auth_breaker", kind: "direct" as const };
+
+    await dispatcher.handle(makeEnvelope({ id: "msg_1", conversation }));
+    await dispatcher.handle(makeEnvelope({ id: "msg_2", conversation }));
+    expect(runtime.calls).toHaveLength(2);
+    expect(Object.values(dispatcher.runtimeCircuitBreakers())).toHaveLength(1);
+
+    await dispatcher.handle(makeEnvelope({ id: "msg_3", conversation }));
+
+    expect(runtime.calls).toHaveLength(2);
+    expect(store.all()).toHaveLength(0);
+    expect(channel.sends).toHaveLength(3);
+    expect(channel.sends[2].message.type).toBe("error");
+    expect(channel.sends[2].message.text).toContain("dispatch paused");
+  });
+
   it("applies composeUserTurn before handing text to the runtime", async () => {
     const runtime = new FakeRuntime({ reply: "ok", newSessionId: "sid-1" });
     const { store, dir } = await makeStore();

package/src/gateway/channels/botcord.ts

@@ -43,7 +43,8 @@ type InboxDrainTrigger =
   | "ws_auth_ok"
   | "ws_inbox_update"
   | "coalesced_inbox_update"
-  | "has_more_continue";
+  | "has_more_continue"
+  | "poll_interval";
 
 /** Minimal surface the adapter needs from `BotCordClient`. Matches the subset used at runtime. */
 export interface BotCordChannelClient {
@@ -90,7 +91,7 @@ export interface BotCordChannelOptions {
   credentialsPath?: string;
   /** Override the Hub base URL. Defaults to the `hubUrl` stored in credentials. */
   hubBaseUrl?: string;
-  /** Not used by the WS-only loop today; kept for future polling fallback. */
+  /** Periodic inbox polling fallback. Set to 0 to disable. Defaults to 30s. */
   pollIntervalMs?: number;
   /** Test hook: supply a pre-built client instead of loading credentials from disk. */
   client?: BotCordChannelClient;
@@ -153,6 +154,9 @@ function defaultClientFactory(input: {
 function isOwnerTrust(msg: InboxMessage): boolean {
   if (msg.room_id?.startsWith(OWNER_CHAT_PREFIX)) return true;
   if (msg.source_type === "dashboard_user_chat") return true;
+  // Cloud Agent run tasks are Hub-issued on the user's behalf, same
+  // trust posture as owner chat.
+  if (msg.source_type === "cloud_agent_run") return true;
   return false;
 }
 
@@ -186,11 +190,19 @@ function normalizeInbox(
   if (!env) return null;
   // `message` is the normal conversational envelope; `contact_request` is
   // a lightweight inbound asking the agent to notify its owner (the
-  // composer appends the notify-owner hint). All other envelope types
-  // (notification, system, contact_added/removed, …) are still filtered
-  // out here — they belong in a separate push-notification path that
-  // daemon does not yet implement.
-  if (env.type !== "message" && env.type !== "contact_request") return null;
+  // composer appends the notify-owner hint); `cloud_run` carries a
+  // Cloud Agent run task with embedded run_id + budget (the cloud
+  // daemon's runtime adapter reads them from `raw.envelope.payload.cloud_run`
+  // and reports usage back via /internal/cloud-agents/.../settle when the
+  // run completes). All other envelope types (notification, system,
+  // contact_added/removed, …) are still filtered out — they belong in
+  // a separate push-notification path that daemon does not yet implement.
+  if (
+    env.type !== "message" &&
+    env.type !== "contact_request" &&
+    env.type !== "cloud_run"
+  )
+    return null;
   if (!msg.room_id) return null;
 
   const rawText =
@@ -482,6 +494,7 @@ export function createBotCordChannel(options: BotCordChannelOptions): ChannelAda
     let ws: WebSocket | null = null;
     let reconnectTimer: NodeJS.Timeout | null = null;
     let keepaliveTimer: NodeJS.Timeout | null = null;
+    let pollTimer: NodeJS.Timeout | null = null;
     let reconnectAttempt = 0;
     let connectionSeq = 0;
     let consecutiveAuthFailures = 0;
@@ -507,6 +520,10 @@ export function createBotCordChannel(options: BotCordChannelOptions): ChannelAda
         clearInterval(keepaliveTimer);
         keepaliveTimer = null;
       }
+      if (pollTimer) {
+        clearInterval(pollTimer);
+        pollTimer = null;
+      }
     }
 
     function markStatus(patch: Partial<ChannelStatusSnapshot>) {
@@ -709,6 +726,16 @@ export function createBotCordChannel(options: BotCordChannelOptions): ChannelAda
           });
           log.info("botcord ws authenticated", { agentId: msg.agent_id });
           void fireInbox("ws_auth_ok");
+          const pollIntervalMs = options.pollIntervalMs ?? 30_000;
+          if (pollTimer) clearInterval(pollTimer);
+          if (pollIntervalMs > 0) {
+            pollTimer = setInterval(() => {
+              if (ws === socket && socket.readyState === WebSocket.OPEN) {
+                void fireInbox("poll_interval");
+              }
+            }, pollIntervalMs);
+            pollTimer.unref?.();
+          }
           if (keepaliveTimer) clearInterval(keepaliveTimer);
           keepaliveTimer = setInterval(() => {
             if (ws === socket && socket.readyState === WebSocket.OPEN) {
@@ -1042,6 +1069,14 @@ function normalizeBlockForHub(
   }
 
   // "other" — e.g. Claude Code `type:"result"` end-of-turn summary.
+  if (isTerminalRuntimeBlock(raw)) {
+    payload.terminal = true;
+    payload.details = formatBlockDetails(raw);
+    const event = typeof raw?.event === "string" ? raw.event : undefined;
+    const embedded = typeof raw?.payload?.event === "string" ? raw.payload.event : undefined;
+    if (event || embedded) payload.event = event ?? embedded;
+    return { kind: "other", seq, payload };
+  }
   if (raw?.type === "result") {
     if (typeof raw.result === "string") payload.text = raw.result;
     if (typeof raw.subtype === "string") payload.subtype = raw.subtype;
@@ -1050,6 +1085,18 @@ function normalizeBlockForHub(
   return { kind: "other", seq, payload };
 }
 
+function isTerminalRuntimeBlock(raw: any): boolean {
+  const event = typeof raw?.event === "string" ? raw.event : undefined;
+  const embedded = typeof raw?.payload?.event === "string" ? raw.payload.event : undefined;
+  const terminal = event ?? embedded;
+  return (
+    terminal === "turn.completed" ||
+    terminal === "turn.finished" ||
+    terminal === "turn.done" ||
+    terminal === "done"
+  );
+}
+
 function formatBlockDetails(raw: unknown): string {
   if (!raw || typeof raw !== "object") return "";
   const r = raw as any;