@botcord/daemon 0.2.78 → 0.2.80

package/src/cloud-gateway-runtime.ts

@@ -0,0 +1,171 @@
+import {
+  RUNTIME_FRAME_TYPES,
+  type GatewayInboundFrame,
+} from "@botcord/protocol-core";
+
+import type {
+  ChannelAdapter,
+  ChannelSendContext,
+  ChannelSendResult,
+  ChannelStatusSnapshot,
+  Gateway,
+  GatewayInboundMessage,
+  GatewayLogger,
+} from "./gateway/index.js";
+
+export interface CloudGatewayRuntimeResult {
+  accepted: boolean;
+  eventId: string;
+  gatewayId: string;
+  agentId: string;
+  conversationId: string;
+  turnId: string;
+  outbound?: {
+    finalText: string;
+    providerMessageId?: string | null;
+  };
+  error?: {
+    code: string;
+    message: string;
+  };
+}
+
+/**
+ * Execute one ingress-originated runtime frame through the normal Gateway
+ * dispatcher while keeping provider I/O outside the cloud sandbox.
+ *
+ * The temporary channel is scoped to this call and implements only the
+ * dispatcher-facing send/status surface. Its send() method captures the
+ * final runtime reply; the Hub relay converts that into
+ * gateway_outbound_complete for gateway-ingress, which then calls the real
+ * provider API.
+ */
+export async function handleCloudGatewayRuntimeInbound(
+  gateway: Gateway,
+  frame: GatewayInboundFrame,
+  log?: GatewayLogger,
+): Promise<CloudGatewayRuntimeResult> {
+  if (frame.type !== RUNTIME_FRAME_TYPES.GATEWAY_INBOUND) {
+    return rejected(frame, "bad_frame_type", `unsupported frame type "${frame.type}"`);
+  }
+  if (!frame.gateway_id || !frame.agent_id || !frame.event_id) {
+    return rejected(frame, "bad_frame", "gateway_id, agent_id and event_id are required");
+  }
+  if (frame.message.accountId !== frame.agent_id) {
+    return rejected(frame, "account_mismatch", "message.accountId does not match frame.agent_id");
+  }
+  if (frame.message.channel !== frame.gateway_id) {
+    return rejected(frame, "channel_mismatch", "message.channel does not match frame.gateway_id");
+  }
+
+  let accepted = false;
+  let outboundText: string | null = null;
+  let providerMessageId: string | null | undefined;
+  const channel = createRuntimeRelayChannel({
+    id: frame.gateway_id,
+    provider: frame.provider,
+    accountId: frame.agent_id,
+    onSend: async (ctx) => {
+      outboundText = ctx.message.text ?? "";
+      providerMessageId = ctx.message.traceId ?? null;
+      return { providerMessageId };
+    },
+  });
+
+  const message: GatewayInboundMessage = {
+    ...frame.message,
+    raw: {
+      source_type: "cloud_gateway_ingress",
+      provider: frame.provider,
+      event_id: frame.event_id,
+      gateway_id: frame.gateway_id,
+    },
+  };
+
+  try {
+    await gateway.injectInboundThrough(message, channel, {
+      accept: async () => {
+        accepted = true;
+      },
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    log?.warn("cloud gateway runtime dispatch failed", {
+      eventId: frame.event_id,
+      gatewayId: frame.gateway_id,
+      agentId: frame.agent_id,
+      error: message,
+    });
+    return rejected(frame, "dispatch_failed", message);
+  }
+
+  return {
+    accepted,
+    eventId: frame.event_id,
+    gatewayId: frame.gateway_id,
+    agentId: frame.agent_id,
+    conversationId: frame.message.conversation.id,
+    turnId: `turn_${frame.event_id}`,
+    ...(outboundText !== null
+      ? {
+          outbound: {
+            finalText: outboundText,
+            providerMessageId: providerMessageId ?? null,
+          },
+        }
+      : {}),
+    ...(!accepted
+      ? { error: { code: "not_accepted", message: "dispatcher did not accept inbound" } }
+      : {}),
+  };
+}
+
+function createRuntimeRelayChannel(opts: {
+  id: string;
+  provider: string;
+  accountId: string;
+  onSend: (ctx: ChannelSendContext) => Promise<ChannelSendResult>;
+}): ChannelAdapter {
+  let lastSendAt: number | undefined;
+  return {
+    id: opts.id,
+    type: opts.provider,
+    async start() {
+      return undefined;
+    },
+    async stop() {
+      return undefined;
+    },
+    async send(ctx) {
+      lastSendAt = Date.now();
+      return opts.onSend(ctx);
+    },
+    status(): ChannelStatusSnapshot {
+      return {
+        channel: opts.id,
+        accountId: opts.accountId,
+        running: true,
+        connected: true,
+        authorized: true,
+        provider: opts.provider as ChannelStatusSnapshot["provider"],
+        ...(lastSendAt ? { lastSendAt } : {}),
+      };
+    },
+  };
+}
+
+function rejected(
+  frame: Partial<GatewayInboundFrame>,
+  code: string,
+  message: string,
+): CloudGatewayRuntimeResult {
+  return {
+    accepted: false,
+    eventId: frame.event_id ?? "",
+    gatewayId: frame.gateway_id ?? "",
+    agentId: frame.agent_id ?? "",
+    conversationId: frame.message?.conversation.id ?? "",
+    turnId: frame.event_id ? `turn_${frame.event_id}` : "turn_unknown",
+    error: { code, message },
+  };
+}

package/src/daemon-singleton.ts

@@ -1,3 +1,4 @@
+import { execFileSync } from "node:child_process";
 import { existsSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
 import { PID_PATH } from "./config.js";
 
@@ -31,6 +32,46 @@ export function pidAlive(pid: number): boolean {
   }
 }
 
+export interface DaemonProcessInfo {
+  pid: number;
+  command: string;
+}
+
+export function parseDaemonProcesses(
+  psOutput: string,
+  currentPid: number = process.pid,
+): DaemonProcessInfo[] {
+  const out: DaemonProcessInfo[] = [];
+  for (const line of psOutput.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    const match = /^(\d+)\s+(.+)$/.exec(trimmed);
+    if (!match) continue;
+    const pid = Number(match[1]);
+    if (!Number.isFinite(pid) || pid <= 0 || pid === currentPid) continue;
+    const command = match[2] ?? "";
+    if (!isBotCordDaemonStartCommand(command)) continue;
+    out.push({ pid, command });
+  }
+  return out;
+}
+
+export function findOtherDaemonProcesses(
+  opts: {
+    currentPid?: number;
+  } = {},
+): DaemonProcessInfo[] {
+  const currentPid = opts.currentPid ?? process.pid;
+  try {
+    const output = execFileSync("ps", ["-axo", "pid=,command="], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+    });
+    return parseDaemonProcesses(output, currentPid).filter((p) => pidAlive(p.pid));
+  } catch {
+    return [];
+  }
+}
+
 export async function waitForPidExit(pid: number, timeoutMs: number): Promise<boolean> {
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
@@ -85,6 +126,41 @@ export async function stopDaemonFromPidFileForRestart(
   }
 }
 
+export async function stopOtherDaemonProcessesForRestart(
+  opts: {
+    currentPid?: number;
+    logger?: SingletonLogger;
+    processes?: DaemonProcessInfo[];
+  } = {},
+): Promise<DaemonProcessInfo[]> {
+  const currentPid = opts.currentPid ?? process.pid;
+  const logger = opts.logger ?? noopLogger;
+  const processes = opts.processes ?? findOtherDaemonProcesses({ currentPid });
+  for (const proc of processes) {
+    logger.info("additional daemon process found; restarting", {
+      pid: proc.pid,
+      command: proc.command,
+    });
+    try {
+      process.kill(proc.pid, "SIGTERM");
+    } catch {
+      continue;
+    }
+    if (!(await waitForPidExit(proc.pid, 5_000))) {
+      logger.warn("additional daemon did not stop after SIGTERM; sending SIGKILL", {
+        pid: proc.pid,
+      });
+      try {
+        process.kill(proc.pid, "SIGKILL");
+      } catch {
+        // ignore
+      }
+      await waitForPidExit(proc.pid, 2_000);
+    }
+  }
+  return processes;
+}
+
 export function ensureNoOtherDaemonFromPidFile(
   opts: {
     pidPath?: string;
@@ -117,6 +193,15 @@ export function removePidFile(pidPath = PID_PATH): void {
   }
 }
 
+function isBotCordDaemonStartCommand(command: string): boolean {
+  if (!/\bstart\b/.test(command)) return false;
+  return (
+    command.includes("botcord-daemon") ||
+    /(?:^|\s)\S*botcord\S*\/daemon\/dist\/index\.js(?:\s|$)/.test(command) ||
+    /(?:^|\s)\S*packages\/daemon\/dist\/index\.js(?:\s|$)/.test(command)
+  );
+}
+
 function delay(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }

package/src/daemon.ts

@@ -39,6 +39,7 @@ import { createDaemonSystemContextBuilder } from "./system-context.js";
 import { readWorkingMemorySnapshot } from "./working-memory.js";
 import { createRoomStaticContextBuilder } from "./room-context.js";
 import { createRoomContextFetcher } from "./room-context-fetcher.js";
+import { createRecentRoomMessagesRecoveryBuilder } from "./room-recovery-context.js";
 import {
   buildLoopRiskPrompt,
   loopRiskSessionKey,
@@ -50,6 +51,7 @@ import { UserAuthManager } from "./user-auth.js";
 import { PolicyResolver, type DaemonAttentionPolicy } from "./gateway/policy-resolver.js";
 import { scanMention } from "./mention-scan.js";
 import { createDiagnosticBundle, uploadDiagnosticBundle } from "./diagnostics.js";
+import { createAttentionPolicyFetcher } from "./attention-policy-fetcher.js";
 
 /**
  * Default hard cap for a single runtime turn. Long-running coding/research
@@ -364,6 +366,13 @@ export async function startDaemon(opts: DaemonRuntimeOptions): Promise<DaemonHan
     fetchRoomInfo: roomContextFetcher,
     log: logger,
   });
+  const buildRuntimeRecoveryContext = createRecentRoomMessagesRecoveryBuilder({
+    credentialPathByAgentId,
+    ...(opts.credentialsPath ? { defaultCredentialsPath: opts.credentialsPath } : {}),
+    ...(opts.hubBaseUrl ? { hubBaseUrl: opts.hubBaseUrl } : {}),
+    limit: 20,
+    log: logger,
+  });
 
   // Cache one system-context builder per configured agentId. The gateway
   // calls this with each inbound message and we pick the right builder by
@@ -442,13 +451,20 @@ export async function startDaemon(opts: DaemonRuntimeOptions): Promise<DaemonHan
     });
   };
 
-  // Per-agent attention policy cache (PR3, design §4.2 / §5). Seeded from
-  // the optional `defaultAttention` / `attentionKeywords` carried by
-  // `provision_agent`, refreshed in-place by the `policy_updated` control
-  // frame. PR2 will plug per-room overrides into `fetchEffective`; PR3
-  // leaves it absent so the resolver collapses to per-agent state.
+  // Per-agent attention policy cache (design §4.2 / §5). It is seeded from
+  // `provision_agent` / `policy_updated` frames when available and falls back
+  // to Hub on cold misses, so daemon restarts preserve dashboard policy.
+  const fetchAttentionPolicy = createAttentionPolicyFetcher({
+    credentialPathByAgentId,
+    defaultCredentialsPath: opts.credentialsPath,
+    hubBaseUrl: opts.hubBaseUrl,
+    log: logger,
+  });
   const policyResolver = new PolicyResolver({
-    fetchGlobal: async (_agentId: string) => undefined,
+    fetchGlobal: async (agentId: string) =>
+      fetchAttentionPolicy({ agentId, roomId: null }),
+    fetchEffective: async (agentId: string, roomId: string) =>
+      fetchAttentionPolicy({ agentId, roomId }),
   });
 
   // Display-name lookup for the mention text-fallback. Populated from boot
@@ -528,6 +544,7 @@ export async function startDaemon(opts: DaemonRuntimeOptions): Promise<DaemonHan
     turnTimeoutMs: DEFAULT_TURN_TIMEOUT_MS,
     buildSystemContext,
     buildMemoryContext,
+    buildRuntimeRecoveryContext,
     onInbound,
     onOutbound,
     onRuntimeCircuitBreakerChange: pushLiveRuntimeSnapshot,

package/src/gateway/__tests__/botcord-channel.test.ts

@@ -699,7 +699,7 @@ describe("createBotCordChannel — streamBlock()", () => {
         },
         1,
       ),
-    ).toEqual({
+    ).toMatchObject({
       kind: "tool_call",
       seq: 1,
       payload: {
@@ -725,7 +725,7 @@ describe("createBotCordChannel — streamBlock()", () => {
         },
         2,
       ),
-    ).toEqual({
+    ).toMatchObject({
       kind: "tool_call",
       seq: 2,
       payload: {
@@ -758,7 +758,7 @@ describe("createBotCordChannel — streamBlock()", () => {
         },
         3,
       ),
-    ).toEqual({
+    ).toMatchObject({
       kind: "tool_result",
       seq: 3,
       payload: {
@@ -782,7 +782,7 @@ describe("createBotCordChannel — streamBlock()", () => {
         },
         4,
       ),
-    ).toEqual({
+    ).toMatchObject({
       kind: "tool_call",
       seq: 4,
       payload: {
@@ -925,6 +925,211 @@ describe("createBotCordChannel — streamBlock()", () => {
     }
   });
 
+  it("normalizes current DeepSeek item.delta assistant text", async () => {
+    const fetchSpy = vi.fn().mockResolvedValue(new Response(null, { status: 204 }));
+    const realFetch = globalThis.fetch;
+    globalThis.fetch = fetchSpy as unknown as typeof fetch;
+    try {
+      const client = makeClient({
+        getHubUrl: vi.fn().mockReturnValue("https://hub.example.com"),
+      });
+      const channel = createBotCordChannel({
+        id: "botcord-main",
+        accountId: "ag_self",
+        agentId: "ag_self",
+        client,
+        hubBaseUrl: "https://hub.example.com",
+      });
+      await channel.streamBlock!({
+        traceId: "m_trace",
+        accountId: "ag_self",
+        conversationId: "rm_oc_1",
+        block: {
+          kind: "assistant_text",
+          seq: 6,
+          raw: {
+            event: "item.delta",
+            payload: { thread_id: "thr_1", turn_id: "turn_1", kind: "agent_message", delta: "hello" },
+          },
+        },
+        log: silentLog,
+      });
+      const [, init] = fetchSpy.mock.calls[0];
+      const body = JSON.parse(init.body as string);
+      expect(body.block).toEqual({
+        kind: "assistant",
+        seq: 6,
+        payload: { text: "hello" },
+      });
+    } finally {
+      globalThis.fetch = realFetch;
+    }
+  });
+
+  it("normalizes current DeepSeek item.started tool input", () => {
+    expect(
+      __normalizeBlockForHubForTests(
+        {
+          kind: "tool_use",
+          seq: 7,
+          raw: {
+            event: "item.started",
+            payload: {
+              item: { id: "item_tool", kind: "tool_call", status: "in_progress" },
+              tool: { id: "call_1", name: "web_search", input: { query: "上海天气" } },
+            },
+          },
+        },
+        7,
+      ),
+    ).toMatchObject({
+      kind: "tool_call",
+      seq: 7,
+      payload: {
+        id: "call_1",
+        name: "web_search",
+        params: { query: "上海天气" },
+        status: "in_progress",
+      },
+      raw: {
+        event: "item.started",
+        payload: {
+          item: { id: "item_tool", kind: "tool_call", status: "in_progress" },
+          tool: { id: "call_1", name: "web_search", input: { query: "上海天气" } },
+        },
+      },
+    });
+  });
+
+  it("infers current DeepSeek tool input from item summary and detail", () => {
+    expect(
+      __normalizeBlockForHubForTests(
+        {
+          kind: "tool_use",
+          seq: 8,
+          raw: {
+            event: "item.started",
+            payload: {
+              item: {
+                id: "item_exec",
+                kind: "tool_call",
+                status: "in_progress",
+                summary: "exec_shell started",
+                detail: "{\"cmd\":\"botcord-daemon --version\"}",
+              },
+            },
+          },
+        },
+        8,
+      ),
+    ).toMatchObject({
+      kind: "tool_call",
+      seq: 8,
+      payload: {
+        id: "item_exec",
+        name: "exec_shell",
+        params: { cmd: "botcord-daemon --version" },
+        status: "in_progress",
+      },
+      raw: {
+        event: "item.started",
+        payload: {
+          item: {
+            id: "item_exec",
+            kind: "tool_call",
+            status: "in_progress",
+            summary: "exec_shell started",
+            detail: "{\"cmd\":\"botcord-daemon --version\"}",
+          },
+        },
+      },
+    });
+  });
+
+  it("infers current DeepSeek tool result name from item summary", () => {
+    expect(
+      __normalizeBlockForHubForTests(
+        {
+          kind: "tool_result",
+          seq: 9,
+          raw: {
+            event: "item.completed",
+            payload: {
+              item: {
+                id: "item_exec",
+                kind: "tool_call",
+                status: "completed",
+                summary: "exec_shell: botcord-daemon 0.2.78",
+                detail: "botcord-daemon 0.2.78",
+              },
+            },
+          },
+        },
+        9,
+      ),
+    ).toMatchObject({
+      kind: "tool_result",
+      seq: 9,
+      payload: {
+        name: "exec_shell",
+        result: "botcord-daemon 0.2.78",
+        tool_use_id: "item_exec",
+      },
+      raw: {
+        event: "item.completed",
+        payload: {
+          item: {
+            id: "item_exec",
+            kind: "tool_call",
+            status: "completed",
+            summary: "exec_shell: botcord-daemon 0.2.78",
+            detail: "botcord-daemon 0.2.78",
+          },
+        },
+      },
+    });
+  });
+
+  it("normalizes current DeepSeek agent_reasoning details", () => {
+    expect(
+      __normalizeBlockForHubForTests(
+        {
+          kind: "thinking",
+          seq: 8,
+          raw: {
+            event: "item.completed",
+            payload: {
+              item: {
+                id: "item_reasoning",
+                kind: "agent_reasoning",
+                status: "completed",
+                summary: "I should answer briefly.",
+                detail: "I should answer briefly.",
+              },
+            },
+          },
+        },
+        8,
+      ),
+    ).toMatchObject({
+      kind: "thinking",
+      seq: 8,
+      payload: { details: "I should answer briefly." },
+      raw: {
+        event: "item.completed",
+        payload: {
+          item: {
+            id: "item_reasoning",
+            kind: "agent_reasoning",
+            status: "completed",
+            summary: "I should answer briefly.",
+            detail: "I should answer briefly.",
+          },
+        },
+      },
+    });
+  });
+
   it("marks DeepSeek terminal events for owner-chat stream cleanup", async () => {
     const fetchSpy = vi.fn().mockResolvedValue(new Response(null, { status: 204 }));
     const realFetch = globalThis.fetch;
@@ -993,10 +1198,11 @@ describe("createBotCordChannel — streamBlock()", () => {
         log: silentLog,
       });
       const body = JSON.parse(fetchSpy.mock.calls[0][1].body as string);
-      expect(body.block).toEqual({
+      expect(body.block).toMatchObject({
         kind: "thinking",
         seq: 7,
         payload: { phase: "updated", label: "Searching web", source: "runtime", details: "Searching web" },
+        raw: { phase: "updated", label: "Searching web", source: "runtime" },
       });
     } finally {
       globalThis.fetch = realFetch;