@botcord/daemon 0.2.78 → 0.2.80

package/src/gateway-control.ts

@@ -313,13 +313,17 @@ export function createGatewayControl(ctx: GatewayControlContext) {
       if (!loginId) {
         return badParams("upsert_gateway: wechat requires loginId");
       }
-      const session = sessions.get(loginId);
-      if (!session) {
+      const resolved = sessions.resolve(loginId);
+      if (resolved.state !== "live") {
         return {
           ok: false,
-          error: { code: "login_expired", message: `wechat login session "${loginId}" not found or expired` },
+          error:
+            resolved.state === "missing"
+              ? { code: "login_missing", message: `wechat login session "${loginId}" not found` }
+              : { code: "login_expired", message: `wechat login session "${loginId}" expired` },
         };
       }
+      const session = resolved.session!;
       if (session.provider !== "wechat") {
         return badParams(`upsert_gateway: login session provider "${session.provider}" != "wechat"`);
       }
@@ -347,13 +351,17 @@ export function createGatewayControl(ctx: GatewayControlContext) {
       if (!loginId) {
         return badParams("upsert_gateway: feishu requires loginId");
       }
-      const session = sessions.get(loginId);
-      if (!session) {
+      const resolved = sessions.resolve(loginId);
+      if (resolved.state !== "live") {
         return {
           ok: false,
-          error: { code: "login_expired", message: `feishu login session "${loginId}" not found or expired` },
+          error:
+            resolved.state === "missing"
+              ? { code: "login_missing", message: `feishu login session "${loginId}" not found` }
+              : { code: "login_expired", message: `feishu login session "${loginId}" expired` },
         };
       }
+      const session = resolved.session!;
       if (session.provider !== "feishu") {
         return badParams(`upsert_gateway: login session provider "${session.provider}" != "feishu"`);
       }
@@ -869,13 +877,17 @@ export function createGatewayControl(ctx: GatewayControlContext) {
     if (!params.accountId || typeof params.accountId !== "string") {
       return badParams("gateway_recent_senders: accountId is required");
     }
-    const session = sessions.get(params.loginId);
-    if (!session) {
+    const resolved = sessions.resolve(params.loginId);
+    if (resolved.state !== "live") {
       return {
         ok: false,
-        error: { code: "login_expired", message: `wechat login session "${params.loginId}" not found or expired` },
+        error:
+          resolved.state === "missing"
+            ? { code: "login_missing", message: `wechat login session "${params.loginId}" not found` }
+            : { code: "login_expired", message: `wechat login session "${params.loginId}" expired` },
       };
     }
+    const session = resolved.session!;
     if (session.provider !== "wechat") {
       return badParams("gateway_recent_senders: provider does not match login session");
     }

package/src/index.ts

@@ -18,10 +18,12 @@ import {
 } from "./config.js";
 import {
   ensureNoOtherDaemonFromPidFile,
+  findOtherDaemonProcesses,
   pidAlive,
   readPid,
   removePidFile,
   stopDaemonFromPidFileForRestart,
+  stopOtherDaemonProcessesForRestart,
   writeCurrentPid,
 } from "./daemon-singleton.js";
 import { resolveBootAgents } from "./agent-discovery.js";
@@ -585,6 +587,7 @@ async function cmdStart(args: ParsedArgs): Promise<void> {
   if (process.env.BOTCORD_DAEMON_CHILD !== "1") {
     await ensureUserAuthForStart(args);
     await stopDaemonFromPidFileForRestart({ logger: log });
+    await stopOtherDaemonProcessesForRestart({ logger: log });
   } else {
     const existing = ensureNoOtherDaemonFromPidFile();
     if (existing) {
@@ -603,7 +606,7 @@ async function cmdStart(args: ParsedArgs): Promise<void> {
       env: { ...process.env, BOTCORD_DAEMON_CHILD: "1" },
     });
     child.unref();
-    const deadline = Date.now() + 500;
+    const deadline = Date.now() + 5_000;
     let observed: number | null = null;
     while (Date.now() < deadline) {
       const p = readPid();
@@ -614,7 +617,7 @@ async function cmdStart(args: ParsedArgs): Promise<void> {
       await new Promise((r) => setTimeout(r, 50));
     }
     if (!observed) {
-      console.error(`daemon did not record pid within 500ms (expected child pid ${child.pid})`);
+      console.error(`daemon did not record pid within 5000ms (expected child pid ${child.pid})`);
       process.exit(1);
     }
     console.log(`daemon started (pid ${observed})`);
@@ -659,6 +662,7 @@ async function cmdStartCloud(_args: ParsedArgs): Promise<void> {
     hubUrl: cloudConfig.hubUrl,
   });
   await stopDaemonFromPidFileForRestart({ logger: log });
+  await stopOtherDaemonProcessesForRestart({ logger: log });
   writeCurrentPid();
 
   // Cloud daemons always start with an empty in-memory config — every
@@ -755,6 +759,7 @@ async function cmdStatus(args: ParsedArgs): Promise<void> {
   const file = readSnapshotFile();
   const now = Date.now();
   const snapshotAgeMs = file ? now - file.writtenAt : null;
+  const daemonProcesses = findOtherDaemonProcesses().filter((p) => p.pid !== pid);
 
   if (args.flags.json === true) {
     const payload = {
@@ -780,6 +785,7 @@ async function cmdStatus(args: ParsedArgs): Promise<void> {
       snapshotWrittenAt: file?.writtenAt ?? null,
       snapshotAgeMs,
       snapshotPath: SNAPSHOT_PATH,
+      daemonProcesses,
     };
     console.log(JSON.stringify(payload, null, 2));
     return;
@@ -793,6 +799,7 @@ async function cmdStatus(args: ParsedArgs): Promise<void> {
     configPath,
     snapshot: file?.snapshot ?? null,
     snapshotAgeMs,
+    daemonProcesses,
   };
   console.log(renderStatus(input, now));
   if (userAuth) {

package/src/provision.ts

@@ -26,6 +26,7 @@ import {
   type RuntimeProbeResult,
   type StoredBotCordCredentials,
   type UpdateAgentParams,
+  type GatewayInboundFrame,
 } from "@botcord/protocol-core";
 import type { Gateway } from "./gateway/index.js";
 import type { GatewayInboundMessage } from "./gateway/index.js";
@@ -77,6 +78,7 @@ import {
   buildRuntimeSelectionExtraArgs,
   mergeRuntimeExtraArgs,
 } from "./runtime-route-options.js";
+import { handleCloudGatewayRuntimeInbound } from "./cloud-gateway-runtime.js";
 
 /**
  * Information passed to {@link OnAgentInstalledHook} after a successful
@@ -164,7 +166,7 @@ export function createProvisioner(opts: ProvisionerOptions): (
 
       case CONTROL_FRAME_TYPES.HELLO: {
         const params = (frame.params ?? {}) as unknown as HelloParams;
-        const result = applyHelloIdentitySnapshot(params.agents);
+        const result = applyHelloIdentitySnapshot(params.agents, { gateway });
         daemonLog.debug("hello: identity snapshot applied", {
           frameId: frame.id,
           received: params.agents?.length ?? 0,
@@ -186,12 +188,19 @@ export function createProvisioner(opts: ProvisionerOptions): (
           displayName: params.displayName,
           bio: params.bio,
         });
+        const runtimeResult = applyAgentRuntimeSnapshot(params, { gateway });
+        const combined = {
+          changed: result.changed || runtimeResult.changed,
+          identity: result,
+          runtime: runtimeResult,
+        };
         daemonLog.info("update_agent applied", {
           agentId: params.agentId,
-          changed: result.changed,
-          skipped: result.skipped ?? null,
+          changed: combined.changed,
+          identitySkipped: result.skipped ?? null,
+          runtimeSkipped: runtimeResult.skipped ?? null,
         });
-        return { ok: true, result };
+        return { ok: true, result: combined };
       }
 
       case CONTROL_FRAME_TYPES.PROVISION_AGENT: {
@@ -419,6 +428,31 @@ export function createProvisioner(opts: ProvisionerOptions): (
         );
       }
 
+      case "cloud_gateway_runtime_inbound": {
+        const params = (frame.params ?? {}) as { frame?: unknown };
+        const runtimeFrame = params.frame as GatewayInboundFrame | undefined;
+        if (!runtimeFrame || typeof runtimeFrame !== "object") {
+          return {
+            ok: false,
+            error: {
+              code: "bad_params",
+              message: "cloud_gateway_runtime_inbound requires params.frame",
+            },
+          };
+        }
+        const result = await handleCloudGatewayRuntimeInbound(gateway, runtimeFrame);
+        return result.accepted
+          ? { ok: true, result }
+          : {
+              ok: false,
+              result,
+              error: result.error ?? {
+                code: "runtime_inbound_rejected",
+                message: "cloud gateway runtime inbound was rejected",
+              },
+            };
+      }
+
       case "list_agent_files": {
         const params = (frame.params ?? {}) as unknown as ListAgentFilesParams;
         if (!params.agentId) {
@@ -2410,10 +2444,100 @@ interface HelloIdentityResult {
   skipped: number;
 }
 
+interface RuntimeSnapshotResult {
+  changed: boolean;
+  skipped?: string;
+  routeUpdated?: boolean;
+}
+
+interface RuntimeSnapshotCtx {
+  gateway?: Gateway;
+}
+
+function hasOwnField(obj: object, key: string): boolean {
+  return Object.prototype.hasOwnProperty.call(obj, key);
+}
+
+function cleanNullableString(value: string | null | undefined): string | undefined {
+  if (typeof value !== "string") return undefined;
+  const trimmed = value.trim();
+  return trimmed || undefined;
+}
+
+function applyAgentRuntimeSnapshot(
+  snapshot: AgentIdentitySnapshot,
+  ctx: RuntimeSnapshotCtx = {},
+): RuntimeSnapshotResult {
+  const hasRuntimeFields = (
+    hasOwnField(snapshot, "runtime") ||
+    hasOwnField(snapshot, "runtimeModel") ||
+    hasOwnField(snapshot, "reasoningEffort") ||
+    hasOwnField(snapshot, "thinking")
+  );
+  if (!hasRuntimeFields) return { changed: false, skipped: "no_runtime_fields" };
+
+  const credentialsFile = defaultCredentialsFile(snapshot.agentId);
+  if (!existsSync(credentialsFile)) {
+    return { changed: false, skipped: "credentials_missing" };
+  }
+
+  const credentials = loadStoredCredentials(credentialsFile);
+  let changed = false;
+
+  if (hasOwnField(snapshot, "runtime")) {
+    const runtime = cleanNullableString(snapshot.runtime);
+    if (runtime !== credentials.runtime) {
+      if (runtime) credentials.runtime = runtime;
+      else delete credentials.runtime;
+      changed = true;
+    }
+  }
+
+  if (hasOwnField(snapshot, "runtimeModel")) {
+    const runtimeModel = cleanNullableString(snapshot.runtimeModel);
+    if (runtimeModel !== credentials.runtimeModel) {
+      if (runtimeModel) credentials.runtimeModel = runtimeModel;
+      else delete credentials.runtimeModel;
+      changed = true;
+    }
+  }
+
+  if (hasOwnField(snapshot, "reasoningEffort")) {
+    const reasoningEffort = cleanNullableString(snapshot.reasoningEffort);
+    if (reasoningEffort !== credentials.reasoningEffort) {
+      if (reasoningEffort) credentials.reasoningEffort = reasoningEffort;
+      else delete credentials.reasoningEffort;
+      changed = true;
+    }
+  }
+
+  if (hasOwnField(snapshot, "thinking")) {
+    if (typeof snapshot.thinking === "boolean") {
+      if (credentials.thinking !== snapshot.thinking) {
+        credentials.thinking = snapshot.thinking;
+        changed = true;
+      }
+    } else if (typeof credentials.thinking === "boolean") {
+      delete credentials.thinking;
+      changed = true;
+    }
+  }
+
+  if (!changed) return { changed: false };
+
+  writeCredentialsFile(credentialsFile, credentials);
+  if (ctx.gateway) {
+    upsertManagedRouteForCredentials(credentials, loadConfig(), ctx.gateway);
+    return { changed: true, routeUpdated: true };
+  }
+  return { changed: true };
+}
+
 /**
  * Reconcile every agent identity carried by the `hello.agents` snapshot
- * against the on-disk `identity.md`. Best-effort: a malformed entry or a
- * file-system error for one agent never aborts the rest.
+ * against the on-disk `identity.md` and credentials runtime selectors.
+ * Best-effort: a malformed entry or a file-system error for one agent never
+ * aborts the rest.
  *
  * Identity-snapshot semantics intentionally only touch the metadata
  * line + Bio body — Role/Boundaries paragraphs the user authored locally
@@ -2423,6 +2547,7 @@ interface HelloIdentityResult {
  */
 export function applyHelloIdentitySnapshot(
   snapshot: AgentIdentitySnapshot[] | undefined,
+  ctx: RuntimeSnapshotCtx = {},
 ): HelloIdentityResult {
   const out: HelloIdentityResult = { updated: 0, skipped: 0 };
   if (!Array.isArray(snapshot)) return out;
@@ -2436,7 +2561,8 @@ export function applyHelloIdentitySnapshot(
         displayName: entry.displayName,
         bio: entry.bio,
       });
-      if (result.changed) out.updated += 1;
+      const runtimeResult = applyAgentRuntimeSnapshot(entry, ctx);
+      if (result.changed || runtimeResult.changed) out.updated += 1;
       else out.skipped += 1;
     } catch (err) {
       out.skipped += 1;

package/src/room-recovery-context.ts

@@ -0,0 +1,131 @@
+/**
+ * Build a compact, deterministic recovery block from recent Hub room messages.
+ * Used when a runtime-native session is discarded and the same turn is retried
+ * in a fresh session.
+ */
+import { BotCordClient, loadStoredCredentials } from "@botcord/protocol-core";
+import { sanitizeUntrustedContent } from "./gateway/index.js";
+import type { GatewayInboundMessage } from "./gateway/index.js";
+
+interface CachedClient {
+  client: BotCordClient;
+  credentialsPath: string;
+}
+
+export interface RecentRoomMessagesRecoveryOptions {
+  credentialPathByAgentId: Map<string, string>;
+  defaultCredentialsPath?: string;
+  hubBaseUrl?: string;
+  limit?: number;
+  log?: {
+    warn: (msg: string, meta?: Record<string, unknown>) => void;
+  };
+}
+
+interface RoomMessage {
+  from?: string;
+  from_name?: string;
+  text?: string;
+  type?: string;
+  ts?: string;
+  topic_id?: string | null;
+  topic_title?: string | null;
+}
+
+const DEFAULT_RECENT_LIMIT = 20;
+const MAX_MESSAGE_TEXT_CHARS = 1200;
+
+function stripNewlines(s: string): string {
+  return s.replace(/[\r\n]+/g, " ");
+}
+
+function messageLabel(m: RoomMessage): string {
+  const name = typeof m.from_name === "string" && m.from_name.trim()
+    ? m.from_name
+    : typeof m.from === "string" && m.from.trim()
+      ? m.from
+      : "unknown";
+  return sanitizeUntrustedContent(stripNewlines(name));
+}
+
+function formatRecentMessages(messages: RoomMessage[]): string {
+  if (messages.length === 0) return "[Recent Room Messages]\n(none)";
+  const chronological = [...messages].reverse();
+  const lines = ["[Recent Room Messages]"];
+  for (const m of chronological) {
+    const text = typeof m.text === "string" ? m.text.trim() : "";
+    if (!text) continue;
+    const ts = typeof m.ts === "string" ? m.ts : "";
+    const topic = typeof m.topic_title === "string" && m.topic_title.trim()
+      ? ` topic=${sanitizeUntrustedContent(stripNewlines(m.topic_title))}`
+      : typeof m.topic_id === "string" && m.topic_id
+        ? ` topic=${sanitizeUntrustedContent(stripNewlines(m.topic_id))}`
+        : "";
+    const safeText = sanitizeUntrustedContent(
+      text.length > MAX_MESSAGE_TEXT_CHARS
+        ? `${text.slice(0, MAX_MESSAGE_TEXT_CHARS)}...`
+        : text,
+    );
+    lines.push(`- ${ts ? `${ts} ` : ""}${messageLabel(m)}${topic}: ${safeText}`);
+  }
+  return lines.join("\n");
+}
+
+export function createRecentRoomMessagesRecoveryBuilder(
+  opts: RecentRoomMessagesRecoveryOptions,
+): (message: GatewayInboundMessage) => Promise<string | null> {
+  const clients = new Map<string, CachedClient>();
+  const limit = opts.limit ?? DEFAULT_RECENT_LIMIT;
+
+  function getClient(accountId: string): BotCordClient | null {
+    const existing = clients.get(accountId);
+    if (existing) return existing.client;
+
+    const credsPath =
+      opts.credentialPathByAgentId.get(accountId) ?? opts.defaultCredentialsPath;
+    if (!credsPath) {
+      opts.log?.warn("daemon.recovery-context.no-credentials", { accountId });
+      return null;
+    }
+
+    try {
+      const creds = loadStoredCredentials(credsPath);
+      const client = new BotCordClient({
+        hubUrl: opts.hubBaseUrl ?? creds.hubUrl,
+        agentId: creds.agentId,
+        keyId: creds.keyId,
+        privateKey: creds.privateKey,
+        ...(creds.token ? { token: creds.token } : {}),
+        ...(creds.tokenExpiresAt !== undefined
+          ? { tokenExpiresAt: creds.tokenExpiresAt }
+          : {}),
+      });
+      clients.set(accountId, { client, credentialsPath: credsPath });
+      return client;
+    } catch (err) {
+      opts.log?.warn("daemon.recovery-context.client-init-failed", {
+        accountId,
+        credsPath,
+        error: err instanceof Error ? err.message : String(err),
+      });
+      return null;
+    }
+  }
+
+  return async (message) => {
+    const client = getClient(message.accountId);
+    if (!client) return null;
+    try {
+      const body = await client.roomMessages(message.conversation.id, { limit });
+      const messages = Array.isArray(body?.messages) ? body.messages as RoomMessage[] : [];
+      return formatRecentMessages(messages);
+    } catch (err) {
+      opts.log?.warn("daemon.recovery-context.fetch-failed", {
+        accountId: message.accountId,
+        roomId: message.conversation.id,
+        error: err instanceof Error ? err.message : String(err),
+      });
+      return null;
+    }
+  };
+}

package/src/status-render.ts

@@ -7,6 +7,7 @@ export const STALE_THRESHOLD_MS = 30_000;
 export interface StatusRenderInput {
   pid: number | null;
   alive: boolean;
+  daemonProcesses?: Array<{ pid: number; command?: string }> | null;
   /**
    * Effective list of agent ids the daemon is bound to. Single-agent installs
    * show one entry; multi-agent configs show all. `agentId` (scalar) is kept
@@ -114,10 +115,22 @@ function renderRuntimeCircuitBreakers(
 export function renderStatus(input: StatusRenderInput, now: number = Date.now()): string {
   const lines: string[] = [];
   if (input.pid === null) {
-    lines.push("daemon: stopped");
+    const extras = input.daemonProcesses ?? [];
+    if (extras.length > 0) {
+      lines.push("daemon: no pid file");
+      lines.push(`warning: ${extras.length} daemon process${extras.length === 1 ? "" : "es"} detected without pid file`);
+      lines.push(`pids: ${extras.map((p) => p.pid).join(", ")}`);
+    } else {
+      lines.push("daemon: stopped");
+    }
     return lines.join("\n");
   }
   lines.push(`daemon: pid ${input.pid} (${input.alive ? "alive" : "not alive"})`);
+  const extras = (input.daemonProcesses ?? []).filter((p) => p.pid !== input.pid);
+  if (extras.length > 0) {
+    lines.push(`warning: ${extras.length} additional daemon process${extras.length === 1 ? "" : "es"} detected`);
+    lines.push(`extra pids: ${extras.map((p) => p.pid).join(", ")}`);
+  }
   const agents =
     input.agents && input.agents.length > 0
       ? input.agents