@botcord/daemon 0.2.61 → 0.2.63

package/src/diagnostics.ts

@@ -2,6 +2,8 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir, hostname, platform, release, arch } from "node:os";
 import path from "node:path";
 import { Buffer } from "node:buffer";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
 import { deflateRawSync } from "node:zlib";
 import {
   AUTH_EXPIRED_FLAG_PATH,
@@ -12,11 +14,14 @@ import {
 import {
   CONFIG_FILE_PATH,
   PID_PATH,
+  SESSIONS_PATH,
   SNAPSHOT_PATH,
   loadConfig,
+  saveConfig,
   type DaemonConfig,
 } from "./config.js";
 import { listDaemonLogFiles, LOG_FILE_PATH, type LogFileEntry } from "./log.js";
+import { listAcpTraceLogFiles, listRuntimeLogFiles } from "./acp-logs.js";
 import {
   channelsFromDaemonConfig,
   defaultHttpFetcher,
@@ -26,16 +31,41 @@ import {
   type DoctorRuntimeEntry,
 } from "./doctor.js";
 import { detectRuntimes } from "./adapters/runtimes.js";
+import { log as daemonLog } from "./log.js";
+import {
+  discoverLocalOpenclawGateways,
+  mergeOpenclawGateways,
+  openclawDiscoveryConfigEnabled,
+} from "./openclaw-discovery.js";
 
 const DIAGNOSTICS_DIR = path.join(homedir(), ".botcord", "diagnostics");
 const MAX_UPLOAD_BYTES = 50 * 1024 * 1024;
 const DEFAULT_ROTATED_LOGS_IN_BUNDLE = 5;
+const require = createRequire(import.meta.url);
+const MODULE_PATH = fileURLToPath(import.meta.url);
+const ENV_ALLOWLIST = new Set([
+  "NODE_ENV",
+  "PATH",
+  "BOTCORD_HUB",
+  "BOTCORD_DAEMON_HOME",
+  "BOTCORD_DAEMON_CONFIG",
+  "BOTCORD_DAEMON_LOG",
+  "BOTCORD_DAEMON_SNAPSHOT_INTERVAL_MS",
+  "BOTCORD_HERMES_AGENT_BIN",
+  "BOTCORD_CLAUDE_CODE_BIN",
+  "BOTCORD_CODEX_BIN",
+  "BOTCORD_GEMINI_BIN",
+  "BOTCORD_DEEPSEEK_TUI_BIN",
+  "BOTCORD_KIMI_CLI_BIN",
+  "OPENCLAW_ACP_URL",
+]);
 
 export interface CreateDiagnosticBundleOptions {
   diagnosticsDir?: string;
   logFile?: string;
   configFile?: string;
   snapshotFile?: string;
+  sessionsFile?: string;
   doctor?: { text: string; json: unknown };
   includeAllLogs?: boolean;
 }
@@ -81,6 +111,81 @@ function safeReadText(file: string): string | null {
   }
 }
 
+function readJsonFile(file: string): Record<string, unknown> | null {
+  try {
+    const parsed = JSON.parse(readFileSync(file, "utf8")) as unknown;
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+      ? parsed as Record<string, unknown>
+      : null;
+  } catch {
+    return null;
+  }
+}
+
+function findDaemonPackageJson(startFile: string): Record<string, unknown> | null {
+  let dir = path.dirname(startFile);
+  for (let i = 0; i < 6; i += 1) {
+    const candidate = path.join(dir, "package.json");
+    const parsed = readJsonFile(candidate);
+    if (parsed?.name === "@botcord/daemon") return parsed;
+    const next = path.dirname(dir);
+    if (next === dir) break;
+    dir = next;
+  }
+  return null;
+}
+
+function readInstalledPackageVersion(packageJsonSpecifier: string): string | null {
+  try {
+    const pkgPath = require.resolve(packageJsonSpecifier);
+    const parsed = readJsonFile(pkgPath);
+    return typeof parsed?.version === "string" ? parsed.version : null;
+  } catch {
+    return null;
+  }
+}
+
+function daemonRuntimeSummary(): Record<string, unknown> {
+  const pkg = findDaemonPackageJson(MODULE_PATH);
+  const version = typeof pkg?.version === "string" ? pkg.version : null;
+  const startedAtMs = Date.now() - Math.round(process.uptime() * 1000);
+  return {
+    packageName: typeof pkg?.name === "string" ? pkg.name : "@botcord/daemon",
+    version,
+    modulePath: MODULE_PATH,
+    entrypoint: process.argv[1] ?? null,
+    execPath: process.execPath,
+    argv: process.argv.map((arg) => redact(arg)),
+    execArgv: process.execArgv.map((arg) => redact(arg)),
+    cwd: process.cwd(),
+    pid: process.pid,
+    ppid: process.ppid,
+    uptimeSec: Math.round(process.uptime()),
+    startedAt: new Date(startedAtMs).toISOString(),
+    versions: {
+      node: process.version,
+      v8: process.versions.v8,
+      uv: process.versions.uv,
+      openssl: process.versions.openssl,
+    },
+    packages: {
+      "@botcord/daemon": version,
+      "@botcord/cli": readInstalledPackageVersion("@botcord/cli/package.json"),
+      "@botcord/protocol-core": readInstalledPackageVersion("@botcord/protocol-core/package.json"),
+    },
+  };
+}
+
+function safeEnvironmentSummary(): Record<string, string> {
+  const out: Record<string, string> = {};
+  for (const [key, value] of Object.entries(process.env)) {
+    if (!value) continue;
+    if (!ENV_ALLOWLIST.has(key) && !key.startsWith("BOTCORD_DAEMON_")) continue;
+    out[key] = redact(value);
+  }
+  return out;
+}
+
 function readUserAuthSummary(): Record<string, unknown> | null {
   const raw = safeReadText(USER_AUTH_PATH);
   if (!raw) return null;
@@ -124,6 +229,7 @@ async function buildDoctorEntries(): Promise<{
   let cfgForEndpoints: DaemonConfig | null = null;
   try {
     cfgForEndpoints = loadConfig();
+    cfgForEndpoints = await refreshDiscoveredOpenclawGateways(cfgForEndpoints);
     channels = channelsFromDaemonConfig(cfgForEndpoints);
   } catch {
     channels = [];
@@ -147,6 +253,31 @@ async function buildDoctorEntries(): Promise<{
   return { text: renderDoctor(input), json: input };
 }
 
+async function refreshDiscoveredOpenclawGateways(cfg: DaemonConfig): Promise<DaemonConfig> {
+  if (!openclawDiscoveryConfigEnabled(cfg)) return cfg;
+  try {
+    const found = await discoverLocalOpenclawGateways({
+      searchPaths: cfg.openclawDiscovery?.searchPaths,
+      defaultPorts: cfg.openclawDiscovery?.defaultPorts,
+      timeoutMs: 500,
+    });
+    const merged = mergeOpenclawGateways(cfg, found);
+    if (!merged.changed) return cfg;
+    saveConfig(merged.cfg);
+    daemonLog.info("openclaw discovery: gateways merged", {
+      source: "diagnostics",
+      added: merged.added.map((g) => ({ name: g.name, url: g.url })),
+    });
+    return merged.cfg;
+  } catch (err) {
+    daemonLog.warn("openclaw discovery failed; continuing", {
+      source: "diagnostics",
+      error: err instanceof Error ? err.message : String(err),
+    });
+    return cfg;
+  }
+}
+
 function crc32(buf: Buffer): number {
   let crc = 0xffffffff;
   for (const b of buf) {
@@ -295,8 +426,11 @@ export async function createDiagnosticBundle(
   const logFile = opts.logFile ?? LOG_FILE_PATH;
   const configFile = opts.configFile ?? CONFIG_FILE_PATH;
   const snapshotFile = opts.snapshotFile ?? SNAPSHOT_PATH;
+  const sessionsFile = opts.sessionsFile ?? SESSIONS_PATH;
   const includeAllLogs = opts.includeAllLogs === true;
   const logs = bundledLogs(logFile, includeAllLogs);
+  const acpLogs = listAcpTraceLogFiles(includeAllLogs);
+  const runtimeLogs = listRuntimeLogFiles(includeAllLogs);
   mkdirSync(diagnosticsDir, { recursive: true, mode: 0o700 });
 
   const doctor = opts.doctor ?? await buildDoctorEntries();
@@ -307,9 +441,12 @@ export async function createDiagnosticBundle(
     release: release(),
     arch: arch(),
     node: process.version,
+    daemon: daemonRuntimeSummary(),
+    environment: safeEnvironmentSummary(),
     pidPath: PID_PATH,
     pid: process.pid,
     configPath: configFile,
+    sessionsPath: sessionsFile,
     snapshotPath: snapshotFile,
     logPath: logFile,
     logsBundled: logs.map((entry) => ({
@@ -318,6 +455,16 @@ export async function createDiagnosticBundle(
       sizeBytes: entry.sizeBytes,
       active: entry.active,
     })),
+    acpLogsBundled: acpLogs.map((entry) => ({
+      name: entry.name,
+      path: entry.path,
+      sizeBytes: entry.sizeBytes,
+    })),
+    runtimeLogsBundled: runtimeLogs.map((entry) => ({
+      name: entry.bundleName,
+      path: entry.path,
+      sizeBytes: entry.sizeBytes,
+    })),
     logsBundleMode: includeAllLogs ? "all" : `active_plus_${DEFAULT_ROTATED_LOGS_IN_BUNDLE}_rotated`,
     diagnosticsDir,
     userAuth: readUserAuthSummary(),
@@ -343,6 +490,20 @@ export async function createDiagnosticBundle(
       });
     }
   }
+  for (const entry of acpLogs) {
+    const log = safeReadText(entry.path);
+    entries.push({
+      name: `acp-logs/${entry.name.split(path.sep).join("/")}`,
+      data: log ?? `no ACP log file at ${entry.path}\n`,
+    });
+  }
+  for (const entry of runtimeLogs) {
+    const log = safeReadText(entry.path);
+    entries.push({
+      name: entry.bundleName,
+      data: log ?? `no runtime log file at ${entry.path}\n`,
+    });
+  }
   const config = safeReadText(configFile);
   entries.push({
     name: "config.json.redacted",
@@ -353,6 +514,11 @@ export async function createDiagnosticBundle(
     name: "snapshot.json",
     data: snapshot ?? `no snapshot file at ${snapshotFile}\n`,
   });
+  const sessions = safeReadText(sessionsFile);
+  entries.push({
+    name: "sessions.json.redacted",
+    data: sessions ?? `no sessions file at ${sessionsFile}\n`,
+  });
 
   const zip = createZip(entries);
   const out = path.join(diagnosticsDir, filename);

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

@@ -344,6 +344,32 @@ describe("Dispatcher", () => {
     expect(store.all().length).toBe(0);
   });
 
+  it("drops the stored session when a resumed turn errors without text even if the adapter returns the same id", async () => {
+    let callNo = 0;
+    const runtimeFactory: RuntimeFactory = () => {
+      callNo += 1;
+      if (callNo === 1) return new FakeRuntime({ reply: "ok", newSessionId: "sid-1" });
+      return new FakeRuntime({
+        reply: "",
+        newSessionId: "sid-1",
+        errorText: "acp error -32603: Internal error",
+      });
+    };
+    const { dispatcher, store, channel } = await scaffold({ runtimeFactory });
+
+    await dispatcher.handle(
+      makeEnvelope({ id: "msg_1", conversation: { id: "rm_x", kind: "direct" } }),
+    );
+    expect(store.all()[0].runtimeSessionId).toBe("sid-1");
+
+    await dispatcher.handle(
+      makeEnvelope({ id: "msg_2", conversation: { id: "rm_x", kind: "direct" } }),
+    );
+
+    expect(store.all().length).toBe(0);
+    expect(channel.sends[0].message.type).toBe("error");
+  });
+
   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/__tests__/hermes-agent-adapter.test.ts

@@ -183,6 +183,33 @@ describe("HermesAgentAdapter", () => {
     expect(res.error).toBeUndefined();
   });
 
+  it("drains late assistant text after a prompt RPC error before closing stdin", async () => {
+    const script = makeAcpServer(
+      "late-after-error.js",
+      `
+        if (msg.method === "initialize") {
+          reply(msg, { protocolVersion: 1 });
+        } else if (msg.method === "session/new") {
+          reply(msg, { sessionId: "sess-late-error" });
+        } else if (msg.method === "session/prompt") {
+          err(msg, -32603, "Internal error");
+          setTimeout(() => {
+            notify("session/update", {
+              sessionId: msg.params.sessionId,
+              update: { sessionUpdate: "agent_message_chunk", content: { type: "text", text: "late but valid" } }
+            });
+            process.exit(0);
+          }, 25);
+        }
+      `,
+    );
+
+    const res = await runAdapter(script);
+    expect(res.newSessionId).toBe("sess-late-error");
+    expect(res.text).toBe("late but valid");
+    expect(res.error).toContain("acp error -32603");
+  });
+
   it("owner trust → request_permission selects an allow_* option", async () => {
     const script = makeAcpServer(
       "perm-allow.js",

package/src/gateway/dispatcher.ts

@@ -1200,6 +1200,14 @@ export class Dispatcher {
           systemContext,
           onBlock,
           onStatus,
+          context: {
+            turnId,
+            messageId: msg.id,
+            roomId: msg.conversation.id,
+            topicId: msg.conversation.threadId ?? null,
+            channel: msg.channel,
+            conversationKind: msg.conversation.kind,
+          },
           gateway: route.gateway,
           ...(route.hermesProfile ? { hermesProfile: route.hermesProfile } : {}),
         });
@@ -1329,16 +1337,34 @@ export class Dispatcher {
 
       if (!result) return;
 
+      const replyText = (result.text || "").trim();
+      const finalTextField = truncateTextField(result.text || "");
+
       // Persist session before reply so next turn sees the new id even if send fails.
       //
       // Adapter contract:
-      //   result.newSessionId truthy  → upsert the entry
-      //   result.newSessionId empty + had-inbound-sessionId + result.error
-      //                               → the prior session is dead (e.g. Claude Code
-      //                                 "--resume <missing-uuid>"); delete the entry so
+      //   had-inbound-sessionId + result.error + no reply text
+      //                               → the prior session is suspect/dead; delete it so
       //                                 we don't keep resuming a stale id every turn
+      //                                 even when the adapter echoes that id back
+      //   result.newSessionId truthy  → upsert the entry
       //   otherwise                   → no-op (e.g. codex intentionally never persists)
-      if (result.newSessionId) {
+      if (sessionId && result.error && !replyText) {
+        try {
+          await this.sessionStore.delete(key);
+          this.log.info("dispatcher: dropped stale runtime session", {
+            key,
+            prevRuntimeSessionId: sessionId,
+            nextRuntimeSessionId: result.newSessionId || null,
+            error: result.error,
+          });
+        } catch (err) {
+          this.log.warn("dispatcher: session-store.delete failed", {
+            key,
+            error: err instanceof Error ? err.message : String(err),
+          });
+        }
+      } else if (result.newSessionId) {
         const session: GatewaySessionEntry = {
           key,
           runtime: route.runtime,
@@ -1381,9 +1407,6 @@ export class Dispatcher {
         }
       }
 
-      const replyText = (result.text || "").trim();
-      const finalTextField = truncateTextField(result.text || "");
-
       if (!replyText) {
         if (result.error) {
           this.log.warn("dispatcher: runtime returned error without reply text", {

package/src/gateway/runtimes/acp-stream.ts

@@ -1,4 +1,5 @@
 import { spawn, type ChildProcessWithoutNullStreams } from "node:child_process";
+import { createAcpTraceLogger, type AcpTraceLogger } from "../../acp-logs.js";
 import { consoleLogger } from "../log.js";
 import type {
   RuntimeAdapter,
@@ -33,9 +34,17 @@ const ASSISTANT_TEXT_CAP = 1 * 1024 * 1024;
 const KILL_GRACE_MS = 5_000;
 /** Deadline for the initial `initialize` handshake. */
 const INITIALIZE_TIMEOUT_MS = 30_000;
+/** Short drain window for late `session/update` chunks after a prompt RPC error. */
+const PROMPT_ERROR_DRAIN_MS = 750;
 /** ACP protocol version this client targets. */
 export const ACP_PROTOCOL_VERSION = 1;
 
+function stringField(obj: unknown, key: string): string | undefined {
+  if (!obj || typeof obj !== "object") return undefined;
+  const value = (obj as Record<string, unknown>)[key];
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
 export interface AcpInitializeResult {
   protocolVersion?: number;
   agentInfo?: { name?: string; version?: string };
@@ -119,6 +128,7 @@ class AcpConnection {
       ): Promise<unknown> | unknown;
     },
     private readonly logId: string,
+    private readonly trace: AcpTraceLogger | null = null,
   ) {
     child.stdout.setEncoding("utf8");
     child.stdout.on("data", (chunk: string) => this.onStdout(chunk));
@@ -142,9 +152,11 @@ class AcpConnection {
 
   private dispatchLine(line: string): void {
     let msg: any;
+
     try {
       msg = JSON.parse(line);
     } catch {
+      this.trace?.write({ stream: "stdout_non_json", chunk: line });
       log.warn(`${this.logId} non-json acp line`, { line: line.slice(0, 200) });
       return;
     }
@@ -155,11 +167,26 @@ class AcpConnection {
       if (!pending) return;
       this.pending.delete(msg.id);
       if (msg.error) {
+        this.trace?.write({
+          stream: "rpc_in",
+          direction: "in",
+          id: msg.id,
+          status: "error",
+          code: typeof msg.error.code === "number" ? msg.error.code : undefined,
+          error: msg.error.message ?? "(no message)",
+        });
         const err = new Error(
           `acp error ${msg.error.code ?? "?"}: ${msg.error.message ?? "(no message)"}`,
         );
         pending.reject(err);
       } else {
+        this.trace?.write({
+          stream: "rpc_in",
+          direction: "in",
+          id: msg.id,
+          status: "response",
+          result: msg.result ?? null,
+        });
         pending.resolve(msg.result ?? null);
       }
       return;
@@ -167,8 +194,23 @@ class AcpConnection {
     if (typeof msg.method === "string") {
       // Server→client request (has `id`) or notification (no `id`)
       if (msg.id !== undefined) {
+        this.trace?.write({
+          stream: "rpc_in",
+          direction: "in",
+          id: msg.id,
+          method: msg.method,
+          status: "request",
+          params: msg.params,
+        });
         void this.handleServerRequest(msg.id, msg.method, msg.params);
       } else {
+        this.trace?.write({
+          stream: "rpc_in",
+          direction: "in",
+          method: msg.method,
+          status: "notification",
+          params: msg.params,
+        });
         try {
           this.handlers.onNotification(msg.method, msg.params);
         } catch (err) {
@@ -199,6 +241,15 @@ class AcpConnection {
     const reply = error
       ? { jsonrpc: "2.0", id, error }
       : { jsonrpc: "2.0", id, result: result ?? null };
+    this.trace?.write({
+      stream: "rpc_out",
+      direction: "out",
+      id,
+      status: error ? "error" : "response",
+      code: error?.code,
+      error: error?.message,
+      result: error ? undefined : result ?? null,
+    });
     this.writeMessage(reply);
   }
 
@@ -221,11 +272,26 @@ class AcpConnection {
         resolve: (v) => resolve(v as T),
         reject,
       });
+      this.trace?.write({
+        stream: "rpc_out",
+        direction: "out",
+        id,
+        method,
+        status: "request",
+        params,
+      });
       this.writeMessage({ jsonrpc: "2.0", id, method, params });
     });
   }
 
   notify(method: string, params: unknown): void {
+    this.trace?.write({
+      stream: "rpc_out",
+      direction: "out",
+      method,
+      status: "notification",
+      params,
+    });
     this.writeMessage({ jsonrpc: "2.0", method, params });
   }
 
@@ -323,6 +389,20 @@ export abstract class AcpRuntimeAdapter implements RuntimeAdapter {
       env: this.spawnEnv(opts),
       stdio: ["pipe", "pipe", "pipe"],
     }) as ChildProcessWithoutNullStreams;
+    const trace = createAcpTraceLogger({
+      runtime: this.id,
+      accountId: opts.accountId,
+      turnId: stringField(opts.context, "turnId"),
+      roomId: stringField(opts.context, "roomId"),
+      topicId: stringField(opts.context, "topicId") ?? null,
+      hermesProfile: opts.hermesProfile,
+      sessionId: opts.sessionId,
+    });
+    trace?.write({
+      stream: "child_start",
+      pid: child.pid,
+      params: { command: binary, args, cwd: opts.cwd },
+    });
 
     let killTimer: ReturnType<typeof setTimeout> | null = null;
     const onAbort = () => {
@@ -351,6 +431,7 @@ export abstract class AcpRuntimeAdapter implements RuntimeAdapter {
     child.stderr.setEncoding("utf8");
     child.stderr.on("data", (chunk: string) => {
       stderrTail = (stderrTail + chunk).slice(-STDERR_TAIL_CAP);
+      trace?.write({ stream: "stderr", pid: child.pid, chunk });
     });
 
     const state: AcpRunState = {
@@ -414,13 +495,25 @@ export abstract class AcpRuntimeAdapter implements RuntimeAdapter {
         },
       },
       this.id,
+      trace,
     );
 
     const childExit = new Promise<number>((resolve) => {
-      child.on("close", (code) => resolve(code ?? 0));
+      child.on("close", (code, signal) => {
+        trace?.write({ stream: "child_exit", pid: child.pid, code, signal });
+        resolve(code ?? 0);
+      });
+      child.on("error", (err) => {
+        trace?.write({
+          stream: "child_error",
+          pid: child.pid,
+          error: err instanceof Error ? err.message : String(err),
+        });
+      });
     });
 
     let newSessionId = opts.sessionId ?? "";
+    let promptStarted = false;
 
     try {
       // 1) initialize
@@ -471,6 +564,7 @@ export abstract class AcpRuntimeAdapter implements RuntimeAdapter {
       newSessionId = sessionId;
 
       // 3) session/prompt
+      promptStarted = true;
       const promptResult = (await conn.request<unknown>("session/prompt", {
         sessionId,
         prompt: [{ type: "text", text: opts.text }],
@@ -508,6 +602,9 @@ export abstract class AcpRuntimeAdapter implements RuntimeAdapter {
       const tail = stderrTail.slice(-STDERR_ERROR_SNIPPET).trim();
       state.errorText =
         state.errorText ?? (tail ? `${baseMsg}; stderr: ${tail}` : baseMsg);
+      if (promptStarted && !opts.signal.aborted) {
+        await sleepUnlessAborted(PROMPT_ERROR_DRAIN_MS, opts.signal);
+      }
       try {
         child.stdin.end();
       } catch {
@@ -563,3 +660,17 @@ export abstract class AcpRuntimeAdapter implements RuntimeAdapter {
     });
   }
 }
+
+function sleepUnlessAborted(ms: number, signal: AbortSignal): Promise<void> {
+  if (signal.aborted) return Promise.resolve();
+  return new Promise((resolve) => {
+    const t = setTimeout(done, ms);
+    if (typeof t.unref === "function") t.unref();
+    function done(): void {
+      signal.removeEventListener("abort", done);
+      clearTimeout(t);
+      resolve();
+    }
+    signal.addEventListener("abort", done, { once: true });
+  });
+}