@botcord/daemon 0.2.61 → 0.2.62

package/dist/acp-logs.d.ts

@@ -0,0 +1,39 @@
+import type { LogFileEntry } from "./log.js";
+export type AcpTraceStream = "child_start" | "child_exit" | "child_error" | "stderr" | "stdout_non_json" | "rpc_in" | "rpc_out";
+export interface AcpTraceMeta {
+    runtime: string;
+    accountId?: string;
+    turnId?: string;
+    roomId?: string;
+    topicId?: string | null;
+    gatewayName?: string;
+    gatewayUrl?: string;
+    hermesProfile?: string;
+    sessionId?: string | null;
+}
+export interface AcpTraceEvent {
+    stream: AcpTraceStream;
+    direction?: "in" | "out";
+    pid?: number;
+    id?: number | string;
+    method?: string;
+    status?: "request" | "notification" | "response" | "error";
+    code?: number | null;
+    signal?: NodeJS.Signals | null;
+    error?: string;
+    chunk?: string;
+    params?: unknown;
+    result?: unknown;
+}
+export interface AcpTraceLogger {
+    path: string;
+    verbose: boolean;
+    write(event: AcpTraceEvent): void;
+}
+interface RuntimeLogFile extends LogFileEntry {
+    bundleName: string;
+}
+export declare function createAcpTraceLogger(meta: AcpTraceMeta): AcpTraceLogger | null;
+export declare function listAcpTraceLogFiles(includeAll?: boolean): LogFileEntry[];
+export declare function listRuntimeLogFiles(includeAll?: boolean): RuntimeLogFile[];
+export {};

package/dist/acp-logs.js

@@ -0,0 +1,333 @@
+import { appendFileSync, existsSync, mkdirSync, readdirSync, renameSync, statSync, unlinkSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+const ACP_LOG_DIR = path.join(homedir(), ".botcord", "logs", "acp");
+const ACP_LOG_MAX_BYTES = 2 * 1024 * 1024;
+const ACP_LOG_KEEP = 20;
+const ACP_LOG_DIAGNOSTICS_DEFAULT = 10;
+const ACP_LOG_DIAGNOSTICS_ALL = 50;
+const RUNTIME_LOG_DEFAULT_PER_ROOT = 5;
+const RUNTIME_LOG_ALL_PER_ROOT = 25;
+const RUNTIME_LOG_MAX_FILE_BYTES = 2 * 1024 * 1024;
+const SECRET_KEY_RE = /token|secret|private.?key|api.?key|authorization|password/i;
+export function createAcpTraceLogger(meta) {
+    if (process.env.BOTCORD_ACP_LOGS === "0")
+        return null;
+    const runtime = safePathSegment(meta.runtime || "acp");
+    const key = safePathSegment([
+        meta.accountId,
+        meta.gatewayName,
+        meta.hermesProfile,
+        meta.roomId,
+    ].filter(Boolean).join("_") || "default");
+    const dir = path.join(ACP_LOG_DIR, runtime);
+    const file = path.join(dir, `${key}.jsonl`);
+    const verbose = process.env.BOTCORD_ACP_TRACE === "verbose";
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    return {
+        path: file,
+        verbose,
+        write(event) {
+            writeAcpTrace(file, meta, event, verbose);
+        },
+    };
+}
+export function listAcpTraceLogFiles(includeAll = false) {
+    const limit = includeAll ? ACP_LOG_DIAGNOSTICS_ALL : ACP_LOG_DIAGNOSTICS_DEFAULT;
+    const out = [];
+    collectFiles(ACP_LOG_DIR, out, (name) => name.endsWith(".jsonl") || name.includes(".jsonl."));
+    return out
+        .sort((a, b) => b.mtimeMs - a.mtimeMs || b.name.localeCompare(a.name))
+        .slice(0, limit);
+}
+export function listRuntimeLogFiles(includeAll = false) {
+    const limit = includeAll ? RUNTIME_LOG_ALL_PER_ROOT : RUNTIME_LOG_DEFAULT_PER_ROOT;
+    const out = [];
+    for (const root of runtimeLogRoots()) {
+        const files = [];
+        collectFiles(root.dir, files, looksLikeLogFile, 4);
+        for (const entry of files
+            .sort((a, b) => b.mtimeMs - a.mtimeMs || b.name.localeCompare(a.name))
+            .slice(0, limit)) {
+            out.push({
+                ...entry,
+                bundleName: path.posix.join("runtime-logs", root.label, relativeBundlePath(root.dir, entry.path)),
+            });
+        }
+    }
+    return out;
+}
+function writeAcpTrace(file, meta, event, verbose) {
+    try {
+        rotateIfNeeded(file);
+        const record = {
+            ts: new Date().toISOString(),
+            runtime: meta.runtime,
+            accountId: meta.accountId,
+            turnId: meta.turnId,
+            roomId: meta.roomId,
+            topicId: meta.topicId ?? undefined,
+            gatewayName: meta.gatewayName,
+            gatewayUrl: meta.gatewayUrl,
+            hermesProfile: meta.hermesProfile,
+            sessionId: event.params && typeof event.params === "object"
+                ? pickString(event.params, "sessionId") ?? meta.sessionId ?? undefined
+                : meta.sessionId ?? undefined,
+            ...summarizeEvent(event, verbose),
+        };
+        appendFileSync(file, JSON.stringify(record) + "\n", { mode: 0o600 });
+    }
+    catch {
+        // ACP trace logging must never affect runtime execution.
+    }
+}
+function summarizeEvent(event, verbose) {
+    const out = {
+        stream: event.stream,
+    };
+    if (event.direction)
+        out.direction = event.direction;
+    if (event.pid !== undefined)
+        out.pid = event.pid;
+    if (event.id !== undefined)
+        out.id = event.id;
+    if (event.method)
+        out.method = event.method;
+    if (event.status)
+        out.status = event.status;
+    if (event.code !== undefined)
+        out.code = event.code;
+    if (event.signal !== undefined)
+        out.signal = event.signal;
+    if (event.error)
+        out.error = truncate(event.error, 1000);
+    if (event.chunk)
+        out.chunk = truncate(redactSecretString(event.chunk), 2000);
+    if (event.params !== undefined)
+        out.params = summarizePayload(event.params, verbose);
+    if (event.result !== undefined)
+        out.result = summarizePayload(event.result, verbose);
+    return out;
+}
+function summarizePayload(value, verbose) {
+    const redacted = redactSecrets(value);
+    if (verbose)
+        return capPayload(redacted);
+    if (Array.isArray(redacted))
+        return { type: "array", length: redacted.length };
+    if (!redacted || typeof redacted !== "object")
+        return redacted;
+    const obj = redacted;
+    const out = {};
+    for (const [key, v] of Object.entries(obj)) {
+        if (key === "prompt") {
+            out.prompt = summarizePrompt(v);
+        }
+        else if (key === "cwd" || key === "sessionId") {
+            out[key] = v;
+        }
+        else if (key === "_meta") {
+            out[key] = summarizePayload(v, false);
+        }
+        else if (key === "update") {
+            out.update = summarizeUpdate(v);
+        }
+        else if (key === "toolCall") {
+            out.toolCall = summarizeToolCall(v);
+        }
+        else if (typeof v === "string") {
+            out[key] = stringSummary(v);
+        }
+        else if (Array.isArray(v)) {
+            out[key] = { type: "array", length: v.length };
+        }
+        else if (v && typeof v === "object") {
+            out[key] = { type: "object", keys: Object.keys(v).slice(0, 20) };
+        }
+        else {
+            out[key] = v;
+        }
+    }
+    return out;
+}
+function summarizePrompt(value) {
+    if (!Array.isArray(value))
+        return summarizePayload(value, false);
+    return value.map((item) => {
+        if (!item || typeof item !== "object")
+            return summarizePayload(item, false);
+        const obj = item;
+        const text = typeof obj.text === "string" ? obj.text : "";
+        return {
+            type: obj.type,
+            textBytes: text ? Buffer.byteLength(text, "utf8") : undefined,
+            textPreview: text ? truncate(text.replace(/\s+/g, " "), 120) : undefined,
+        };
+    });
+}
+function summarizeUpdate(value) {
+    if (!value || typeof value !== "object")
+        return summarizePayload(value, false);
+    const obj = value;
+    const out = {};
+    if (typeof obj.sessionUpdate === "string")
+        out.sessionUpdate = obj.sessionUpdate;
+    if (typeof obj.title === "string")
+        out.title = stringSummary(obj.title);
+    if (obj.content !== undefined)
+        out.content = summarizePayload(obj.content, false);
+    return Object.keys(out).length > 0 ? out : { type: "object", keys: Object.keys(obj).slice(0, 20) };
+}
+function summarizeToolCall(value) {
+    if (!value || typeof value !== "object")
+        return summarizePayload(value, false);
+    const obj = value;
+    return {
+        name: typeof obj.name === "string" ? obj.name : undefined,
+        rawInput: obj.rawInput === undefined ? undefined : summarizePayload(obj.rawInput, false),
+    };
+}
+function redactSecrets(value) {
+    if (Array.isArray(value))
+        return value.map(redactSecrets);
+    if (!value || typeof value !== "object") {
+        return typeof value === "string" ? redactSecretString(value) : value;
+    }
+    const out = {};
+    for (const [key, v] of Object.entries(value)) {
+        out[key] = SECRET_KEY_RE.test(key) ? "[REDACTED]" : redactSecrets(v);
+    }
+    return out;
+}
+function redactSecretString(value) {
+    return value
+        .replace(/(Authorization:\s*Bearer\s+)[^\s"']+/gi, "$1[REDACTED]")
+        .replace(/\b(token=)[^\s"']+/gi, "$1[REDACTED]")
+        .replace(/\b(drt_|dit_|gho_)[A-Za-z0-9_-]+/g, "$1[REDACTED]");
+}
+function capPayload(value) {
+    if (typeof value === "string")
+        return truncate(value, 2000);
+    if (Array.isArray(value))
+        return value.slice(0, 50).map(capPayload);
+    if (!value || typeof value !== "object")
+        return value;
+    const out = {};
+    for (const [key, v] of Object.entries(value).slice(0, 50)) {
+        out[key] = capPayload(v);
+    }
+    return out;
+}
+function stringSummary(value) {
+    return {
+        bytes: Buffer.byteLength(value, "utf8"),
+        preview: truncate(value.replace(/\s+/g, " "), 160),
+    };
+}
+function truncate(value, max) {
+    return value.length > max ? `${value.slice(0, max)}…` : value;
+}
+function pickString(obj, key) {
+    const value = obj[key];
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function rotateIfNeeded(file) {
+    try {
+        const st = statSync(file);
+        if (!st.isFile() || st.size <= ACP_LOG_MAX_BYTES)
+            return;
+        renameSync(file, `${file}.${new Date().toISOString().replace(/[:.]/g, "-")}.${process.pid}`);
+        const dir = path.dirname(file);
+        const base = path.basename(file);
+        const rotated = readdirSync(dir)
+            .filter((name) => name.startsWith(`${base}.`))
+            .map((name) => {
+            const p = path.join(dir, name);
+            const st = statSync(p);
+            return { p, mtimeMs: st.mtimeMs };
+        })
+            .sort((a, b) => b.mtimeMs - a.mtimeMs);
+        for (const entry of rotated.slice(ACP_LOG_KEEP))
+            unlinkSync(entry.p);
+    }
+    catch {
+        // best-effort
+    }
+}
+function collectFiles(dir, out, accept, maxDepth = 3) {
+    if (maxDepth < 0)
+        return;
+    let names;
+    try {
+        names = readdirSync(dir);
+    }
+    catch {
+        return;
+    }
+    for (const name of names) {
+        const file = path.join(dir, name);
+        try {
+            const st = statSync(file);
+            if (st.isDirectory()) {
+                collectFiles(file, out, accept, maxDepth - 1);
+            }
+            else if (st.isFile() && st.size <= RUNTIME_LOG_MAX_FILE_BYTES && accept(name, file)) {
+                out.push({
+                    path: file,
+                    name: path.relative(ACP_LOG_DIR, file) || name,
+                    sizeBytes: st.size,
+                    mtimeMs: st.mtimeMs,
+                    active: true,
+                });
+            }
+        }
+        catch {
+            // ignore disappearing files
+        }
+    }
+}
+function runtimeLogRoots() {
+    const roots = [
+        { label: "openclaw", dir: path.join(homedir(), ".openclaw", "logs") },
+        { label: "qclaw", dir: path.join(homedir(), ".qclaw", "logs") },
+        { label: "hermes", dir: path.join(homedir(), ".hermes", "logs") },
+    ];
+    const hermesProfiles = path.join(homedir(), ".hermes", "profiles");
+    try {
+        for (const name of readdirSync(hermesProfiles)) {
+            roots.push({
+                label: path.posix.join("hermes-profiles", safePathSegment(name)),
+                dir: path.join(hermesProfiles, name, "logs"),
+            });
+        }
+    }
+    catch {
+        // no profiles
+    }
+    const botcordAgents = path.join(homedir(), ".botcord", "agents");
+    try {
+        for (const agent of readdirSync(botcordAgents)) {
+            roots.push({
+                label: path.posix.join("botcord-hermes", safePathSegment(agent)),
+                dir: path.join(botcordAgents, agent, "hermes-home", "logs"),
+            });
+        }
+    }
+    catch {
+        // no botcord agent homes
+    }
+    return roots.filter((root) => existsSync(root.dir));
+}
+function looksLikeLogFile(name) {
+    const lower = name.toLowerCase();
+    return (lower.endsWith(".log") ||
+        lower.endsWith(".jsonl") ||
+        lower.endsWith(".txt") ||
+        lower.includes("log"));
+}
+function relativeBundlePath(root, file) {
+    return path.relative(root, file).split(path.sep).map(safePathSegment).join("/");
+}
+function safePathSegment(raw) {
+    return raw.replace(/[^A-Za-z0-9._-]+/g, "_").slice(0, 120) || "unknown";
+}

package/dist/diagnostics.js

@@ -4,10 +4,13 @@ import path from "node:path";
 import { Buffer } from "node:buffer";
 import { deflateRawSync } from "node:zlib";
 import { AUTH_EXPIRED_FLAG_PATH, USER_AUTH_PATH, } from "./user-auth.js";
-import { CONFIG_FILE_PATH, PID_PATH, SNAPSHOT_PATH, loadConfig, } from "./config.js";
+import { CONFIG_FILE_PATH, PID_PATH, SNAPSHOT_PATH, loadConfig, saveConfig, } from "./config.js";
 import { listDaemonLogFiles, LOG_FILE_PATH } from "./log.js";
+import { listAcpTraceLogFiles, listRuntimeLogFiles } from "./acp-logs.js";
 import { channelsFromDaemonConfig, defaultHttpFetcher, renderDoctor, runDoctor, } 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;
@@ -76,6 +79,7 @@ async function buildDoctorEntries() {
     let cfgForEndpoints = null;
     try {
         cfgForEndpoints = loadConfig();
+        cfgForEndpoints = await refreshDiscoveredOpenclawGateways(cfgForEndpoints);
         channels = channelsFromDaemonConfig(cfgForEndpoints);
     }
     catch {
@@ -99,6 +103,33 @@ async function buildDoctorEntries() {
     });
     return { text: renderDoctor(input), json: input };
 }
+async function refreshDiscoveredOpenclawGateways(cfg) {
+    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) {
     let crc = 0xffffffff;
     for (const b of buf) {
@@ -231,6 +262,8 @@ export async function createDiagnosticBundle(opts = {}) {
     const snapshotFile = opts.snapshotFile ?? SNAPSHOT_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();
     const status = {
@@ -251,6 +284,16 @@ export async function createDiagnosticBundle(opts = {}) {
             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(),
@@ -276,6 +319,20 @@ export async function createDiagnosticBundle(opts = {}) {
             });
         }
     }
+    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",

package/dist/gateway/dispatcher.js

@@ -959,6 +959,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 } : {}),
                 });
@@ -1087,16 +1095,35 @@ 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 = {
                     key,
                     runtime: route.runtime,
@@ -1141,8 +1168,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", {