@botcord/daemon 0.2.63 → 0.2.64

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

@@ -1276,6 +1276,50 @@ describe("Dispatcher", () => {
     expect(blockTypes).toEqual(["system", "tool_use"]);
   });
 
+  it("transcript: records runtime blocks even when channel streaming is disabled", async () => {
+    const blocks: StreamBlock[] = [
+      {
+        raw: {
+          params: {
+            update: {
+              sessionUpdate: "tool_call",
+              toolCall: { name: "botcord_send", rawInput: { text: "hello" } },
+            },
+          },
+        },
+        kind: "tool_use",
+        seq: 7,
+      },
+    ];
+    const runtime = new FakeRuntime({ blocks, reply: "ok", newSessionId: "sid" });
+    const channel = new FakeChannel();
+    const records: import("../transcript.js").TranscriptRecord[] = [];
+    const { store, dir } = await makeStore();
+    tempDirs.push(dir);
+    const channels = new Map<string, ChannelAdapter>([[channel.id, channel]]);
+    const dispatcher = new Dispatcher({
+      config: baseConfig(),
+      channels,
+      runtime: () => runtime,
+      sessionStore: store,
+      log: silentLogger(),
+      transcript: { enabled: true, rootDir: dir, write: (rec) => records.push(rec) },
+    });
+
+    await dispatcher.handle(
+      makeEnvelope({ trace: { id: "tr", streamable: false } }),
+    );
+
+    expect(channel.streams).toHaveLength(0);
+    const block = records.find((r) => r.kind === "block");
+    expect(block).toMatchObject({
+      kind: "block",
+      blockType: "tool_use",
+      seq: 7,
+      summary: { type: "tool_use", name: "botcord_send" },
+    });
+  });
+
   it("runtime throws: sends error reply, does not write session", async () => {
     const runtime = new FakeRuntime({ throwError: "boom" });
     const channel = new FakeChannel();

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

@@ -1,5 +1,5 @@
-import { mkdtemp, readFile, rm } from "node:fs/promises";
-import { existsSync, statSync } from "node:fs";
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { existsSync, statSync, utimesSync } from "node:fs";
 import { tmpdir } from "node:os";
 import path from "node:path";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
@@ -7,7 +7,9 @@ import { Dispatcher, type RuntimeFactory } from "../dispatcher.js";
 import { SessionStore } from "../session-store.js";
 import {
   createTranscriptWriter,
+  cleanupTranscriptFiles,
   resolveTranscriptEnabled,
+  TRANSCRIPT_RETENTION_MS,
   TRANSCRIPT_TEXT_LIMIT,
   truncateTextField,
   type TranscriptRecord,
@@ -239,6 +241,10 @@ describe("resolveTranscriptEnabled", () => {
     expect(resolveTranscriptEnabled("yes", true)).toBe(true);
     expect(resolveTranscriptEnabled("yes", false)).toBe(false);
   });
+  it("defaults on when env and config are both unset", () => {
+    expect(resolveTranscriptEnabled(undefined, undefined)).toBe(true);
+    expect(resolveTranscriptEnabled("yes", undefined)).toBe(true);
+  });
 });
 
 describe("truncateTextField", () => {
@@ -460,6 +466,25 @@ describe("Dispatcher transcript integration", () => {
     expect(files).toContain("_default.jsonl");
   });
 
+  it("cleans transcript files older than the retention window", async () => {
+    const tmp = await mkdtemp(path.join(tmpdir(), "transcript-clean-"));
+    cleanups.push(() => rm(tmp, { recursive: true, force: true }));
+    const oldFile = transcriptFilePath(tmp, "ag_me", "rm_old", null);
+    const freshFile = transcriptFilePath(tmp, "ag_me", "rm_fresh", null);
+    await mkdir(path.dirname(oldFile), { recursive: true });
+    await mkdir(path.dirname(freshFile), { recursive: true });
+    await writeFile(oldFile, "{}\n", { mode: 0o600 });
+    await writeFile(freshFile, "{}\n", { mode: 0o600 });
+    const oldDate = new Date(Date.now() - TRANSCRIPT_RETENTION_MS - 60_000);
+    utimesSync(oldFile, oldDate, oldDate);
+
+    const removed = cleanupTranscriptFiles(tmp, Date.now() - TRANSCRIPT_RETENTION_MS);
+
+    expect(removed).toBe(1);
+    expect(existsSync(oldFile)).toBe(false);
+    expect(existsSync(freshFile)).toBe(true);
+  });
+
   it("disabled writer does not create files", async () => {
     const tmp = await mkdtemp(path.join(tmpdir(), "transcript-off-"));
     cleanups.push(() => rm(tmp, { recursive: true, force: true }));

package/src/gateway/channels/botcord.ts

@@ -25,6 +25,7 @@ import { sanitizeUntrustedContent } from "./sanitize.js";
 import { revokeAgent } from "../../provision.js";
 
 const RECONNECT_BACKOFF = [1000, 2000, 4000, 8000, 16000, 30000];
+const RECONNECT_JITTER_RATIO = 0.25;
 const KEEPALIVE_INTERVAL = 20_000;
 const MAX_AUTH_FAILURES = 5;
 const SEEN_MESSAGES_CAP = 500;
@@ -33,6 +34,11 @@ const DM_ROOM_PREFIX = "rm_dm_";
 const INBOX_POLL_LIMIT = 50;
 const CHANNEL_PERMANENT_STOP = "channel_permanent_stop";
 
+function withReconnectJitter(delayMs: number): { delayMs: number; jitterMs: number } {
+  const jitterMs = Math.floor(Math.random() * delayMs * RECONNECT_JITTER_RATIO);
+  return { delayMs: delayMs + jitterMs, jitterMs };
+}
+
 type InboxDrainTrigger =
   | "ws_auth_ok"
   | "ws_inbox_update"
@@ -477,6 +483,7 @@ export function createBotCordChannel(options: BotCordChannelOptions): ChannelAda
     let reconnectTimer: NodeJS.Timeout | null = null;
     let keepaliveTimer: NodeJS.Timeout | null = null;
     let reconnectAttempt = 0;
+    let connectionSeq = 0;
     let consecutiveAuthFailures = 0;
     let running = true;
     let permanentStopping = false;
@@ -603,23 +610,36 @@ export function createBotCordChannel(options: BotCordChannelOptions): ChannelAda
 
     function scheduleReconnect() {
       if (!running) return;
-      const delay =
+      if (reconnectTimer) return;
+      if (ws && (ws.readyState === WebSocket.CONNECTING || ws.readyState === WebSocket.OPEN)) {
+        return;
+      }
+      const baseDelayMs =
         RECONNECT_BACKOFF[Math.min(reconnectAttempt, RECONNECT_BACKOFF.length - 1)];
+      const { delayMs, jitterMs } = withReconnectJitter(baseDelayMs);
       reconnectAttempt += 1;
       markStatus({
         connected: false,
         restartPending: true,
         reconnectAttempts: reconnectAttempt,
       });
-      log.info("botcord ws reconnect scheduled", { delayMs: delay, attempt: reconnectAttempt });
+      log.info("botcord ws reconnect scheduled", {
+        delayMs,
+        baseDelayMs,
+        jitterMs,
+        attempt: reconnectAttempt,
+      });
       reconnectTimer = setTimeout(() => {
         reconnectTimer = null;
         void connect();
-      }, delay);
+      }, delayMs);
     }
 
     async function connect() {
       if (!running) return;
+      if (ws && (ws.readyState === WebSocket.CONNECTING || ws.readyState === WebSocket.OPEN)) {
+        return;
+      }
       const agentId = options.agentId;
       markStatus({ connected: false, restartPending: false });
       if (pendingRefresh) {
@@ -644,8 +664,11 @@ export function createBotCordChannel(options: BotCordChannelOptions): ChannelAda
       const url = buildHubWebSocketUrl(hubUrl);
       log.info("botcord ws connecting", { url, agentId });
 
+      const connectionId = ++connectionSeq;
+      let socket: WebSocket;
       try {
-        ws = new wsCtor(url);
+        socket = new wsCtor(url);
+        ws = socket;
       } catch (err) {
         log.error("botcord ws construct failed", { agentId, err: String(err) });
         markStatus({ lastError: String(err) });
@@ -653,11 +676,20 @@ export function createBotCordChannel(options: BotCordChannelOptions): ChannelAda
         return;
       }
 
-      ws.on("open", () => {
-        ws!.send(JSON.stringify({ type: "auth", token }));
+      socket.on("open", () => {
+        if (!running || ws !== socket || connectionId !== connectionSeq) {
+          try {
+            socket.close();
+          } catch {
+            // ignore
+          }
+          return;
+        }
+        socket.send(JSON.stringify({ type: "auth", token }));
       });
 
-      ws.on("message", (data: WebSocket.RawData) => {
+      socket.on("message", (data: WebSocket.RawData) => {
+        if (ws !== socket || connectionId !== connectionSeq) return;
         let msg: { type?: string; agent_id?: string } | null = null;
         try {
           msg = JSON.parse(String(data));
@@ -677,10 +709,11 @@ export function createBotCordChannel(options: BotCordChannelOptions): ChannelAda
           });
           log.info("botcord ws authenticated", { agentId: msg.agent_id });
           void fireInbox("ws_auth_ok");
+          if (keepaliveTimer) clearInterval(keepaliveTimer);
           keepaliveTimer = setInterval(() => {
-            if (ws && ws.readyState === WebSocket.OPEN) {
+            if (ws === socket && socket.readyState === WebSocket.OPEN) {
               try {
-                ws.send(JSON.stringify({ type: "ping" }));
+                socket.send(JSON.stringify({ type: "ping" }));
               } catch {
                 // ignore
               }
@@ -696,10 +729,15 @@ export function createBotCordChannel(options: BotCordChannelOptions): ChannelAda
         }
       });
 
-      ws.on("close", (code: number, reason: Buffer) => {
+      socket.on("close", (code: number, reason: Buffer) => {
         const reasonStr = reason?.toString() || "";
+        if (ws !== socket || connectionId !== connectionSeq) {
+          log.debug("botcord ws stale close ignored", { agentId, code, reason: reasonStr });
+          return;
+        }
         log.info("botcord ws closed", { agentId, code, reason: reasonStr });
         clearTimers();
+        ws = null;
         markStatus({ connected: false });
         if (!running) {
           if (permanentStopping) return;
@@ -740,7 +778,8 @@ export function createBotCordChannel(options: BotCordChannelOptions): ChannelAda
         scheduleReconnect();
       });
 
-      ws.on("error", (err: Error) => {
+      socket.on("error", (err: Error) => {
+        if (ws !== socket || connectionId !== connectionSeq) return;
         log.warn("botcord ws error", { agentId, err: String(err) });
         markStatus({ lastError: String(err) });
       });

package/src/gateway/dispatcher.ts

@@ -37,6 +37,8 @@ const DEFAULT_TURN_TIMEOUT_MS = 30 * 60 * 1000;
  * (or `botcord send` CLI via Bash) to actually deliver replies.
  */
 const OWNER_CHAT_ROOM_PREFIX = "rm_oc_";
+const TRANSCRIPT_BLOCK_RAW_LIMIT = 16 * 1024;
+const SECRET_KEY_RE = /token|secret|private.?key|api.?key|authorization|password/i;
 
 /** Maximum number of buffered serial entries per queue. Excess entries drop oldest. */
 const MAX_BATCH_BUFFER_ENTRIES = 40;
@@ -66,6 +68,62 @@ const TYPING_REFRESH_MS = 4000;
 /** LRU cap on the typing-recency map so long-running daemons don't grow unbounded. */
 const TYPING_RECENCY_CAP = 1024;
 
+function transcriptBlocksVerbose(): boolean {
+  return process.env.BOTCORD_TRANSCRIPT_BLOCKS === "verbose" ||
+    process.env.BOTCORD_TRACE_VERBOSE === "1";
+}
+
+function summarizeStreamBlock(block: StreamBlock): TranscriptBlockSummary {
+  const summary: TranscriptBlockSummary = { type: block.kind };
+  const raw = block.raw as {
+    text?: unknown;
+    name?: unknown;
+    update?: unknown;
+    params?: { update?: unknown };
+  } | null | undefined;
+  if (raw && typeof raw === "object") {
+    if (typeof raw.text === "string") summary.chars = raw.text.length;
+    if (typeof raw.name === "string") summary.name = raw.name;
+    const update = raw.params?.update ?? raw.update;
+    if (update && typeof update === "object") {
+      const u = update as Record<string, unknown>;
+      if (typeof u.sessionUpdate === "string" && !summary.name) summary.name = u.sessionUpdate;
+      const toolCall = u.toolCall;
+      if (toolCall && typeof toolCall === "object") {
+        const toolName = (toolCall as Record<string, unknown>).name;
+        if (typeof toolName === "string") summary.name = toolName;
+      }
+    }
+  }
+  return summary;
+}
+
+function redactAndCap(value: unknown, budget = TRANSCRIPT_BLOCK_RAW_LIMIT): unknown {
+  const seen = new WeakSet<object>();
+  const walk = (v: unknown): unknown => {
+    if (typeof v === "string") {
+      return redactSecretString(v.length > budget ? `${v.slice(0, budget)}…` : v);
+    }
+    if (Array.isArray(v)) return v.slice(0, 50).map(walk);
+    if (!v || typeof v !== "object") return v;
+    if (seen.has(v)) return "[Circular]";
+    seen.add(v);
+    const out: Record<string, unknown> = {};
+    for (const [key, child] of Object.entries(v as Record<string, unknown>).slice(0, 80)) {
+      out[key] = SECRET_KEY_RE.test(key) ? "[REDACTED]" : walk(child);
+    }
+    return out;
+  };
+  return walk(value);
+}
+
+function redactSecretString(value: string): string {
+  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]");
+}
+
 /** Factory signature for building a runtime adapter at turn dispatch time. */
 export type RuntimeFactory = (
   runtimeId: string,
@@ -943,13 +1001,23 @@ export class Dispatcher {
     const canStream =
       streamable && typeof traceId === "string" && typeof channel.streamBlock === "function";
     const recordBlock = (block: StreamBlock): void => {
-      const summary: TranscriptBlockSummary = { type: block.kind };
-      const raw = block.raw as { text?: unknown; name?: unknown } | null | undefined;
-      if (raw && typeof raw === "object") {
-        if (typeof raw.text === "string") summary.chars = raw.text.length;
-        if (typeof raw.name === "string") summary.name = raw.name;
-      }
+      const summary = summarizeStreamBlock(block);
       slot.blocks.push(summary);
+      if (this.transcript.enabled) {
+        this.transcript.write({
+          ts: new Date().toISOString(),
+          kind: "block",
+          turnId,
+          agentId: msg.accountId,
+          roomId: msg.conversation.id,
+          topicId: msg.conversation.threadId ?? null,
+          runtime: route.runtime,
+          seq: block.seq,
+          blockType: block.kind,
+          summary,
+          ...(transcriptBlocksVerbose() ? { raw: redactAndCap(block.raw) } : {}),
+        });
+      }
     };
 
     // Owner-chat lifecycle state for typing/thinking. The dispatcher is the
@@ -1118,13 +1186,14 @@ export class Dispatcher {
         }
       : undefined;
 
-    const onBlock = canStream
+    const onBlock = (canStream || this.transcript.enabled)
       ? (block: StreamBlock) => {
           // Always record adapter-emitted blocks for transcript fidelity, even
           // after abort — the transcript reflects what the runtime emitted,
           // not what the dispatcher chose to forward.
           recordBlock(block);
           if (controller.signal.aborted) return;
+          if (!canStream) return;
           // Synthesize thinking.started before non-assistant blocks. After
           // we've seen any assistant_text, only `tool_use` may re-enter
           // thinking — terminal markers like `system`/`other` (codex
@@ -1144,7 +1213,7 @@ export class Dispatcher {
             thinkingActive = false;
             sawAssistantText = true;
           }
-          forwardBlockToChannel!(block);
+          forwardBlockToChannel?.(block);
         }
       : undefined;
 

package/src/gateway/gateway.ts

@@ -78,7 +78,8 @@ export interface GatewayBootOptions {
    * Tri-state convenience: if `transcript` is not provided, the gateway
    * constructs a writer using this flag plus `transcriptRootDir`. Use
    * {@link resolveTranscriptEnabled} to combine `BOTCORD_TRANSCRIPT` env with
-   * the persistent daemon-config flag.
+   * the persistent daemon-config flag. When omitted, transcripts are enabled
+   * by default.
    */
   transcriptEnabled?: boolean;
   /** Root directory for transcript files. Defaults to `~/.botcord/agents`. */
@@ -145,7 +146,7 @@ export class Gateway {
       opts.transcript
       ?? createTranscriptWriter({
         log: this.log,
-        enabled: opts.transcriptEnabled === true,
+        enabled: opts.transcriptEnabled,
         rootDir: opts.transcriptRootDir,
       });
 

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

@@ -35,7 +35,7 @@ interface AcpProcessHandle {
   /** Pending JSON-RPC requests keyed by id. */
   pending: Map<number, PendingCall>;
   /** Per-ACP-sessionId notification subscribers. */
-  subscribers: Map<string, (note: AcpNotification) => void>;
+  subscribers: Map<string, AcpSubscriber>;
   nextId: number;
   buffer: string;
   nonJsonStdoutTail: string[];
@@ -66,6 +66,18 @@ interface AcpNotification {
   params: any;
 }
 
+interface AcpTurnTraceContext {
+  turnId?: string;
+  messageId?: string;
+  roomId?: string;
+  topicId?: string | null;
+}
+
+interface AcpSubscriber {
+  notify: (note: AcpNotification) => void;
+  traceContext: AcpTurnTraceContext;
+}
+
 const ACP_POOL = new Map<string, AcpProcessHandle>();
 
 function poolKey(accountId: string, gatewayName: string): string {
@@ -183,6 +195,12 @@ export class OpenclawAcpAdapter implements RuntimeAdapter {
       // synthetic test calls).
       conversationKey: stringField(opts.context, "conversationKey") ?? "default",
     });
+    const traceContext: AcpTurnTraceContext = {
+      turnId: stringField(opts.context, "turnId"),
+      messageId: stringField(opts.context, "messageId"),
+      roomId: stringField(opts.context, "roomId"),
+      topicId: nullableStringField(opts.context, "topicId"),
+    };
 
     const key = poolKey(opts.accountId, gateway.name);
     let handle: AcpProcessHandle;
@@ -273,7 +291,17 @@ export class OpenclawAcpAdapter implements RuntimeAdapter {
           throw new Error(`newSession failed: ${(err as Error).message}`);
         }
       }
-      handle.subscribers.set(acpSessionId, onNotification);
+      handle.subscribers.set(acpSessionId, { notify: onNotification, traceContext });
+      handle.trace?.write({
+        stream: "turn_context",
+        ...traceContext,
+        params: {
+          sessionId: acpSessionId,
+          sessionKey,
+          openclawAgent,
+          cwd: opts.cwd,
+        },
+      });
 
       if (opts.signal?.aborted) {
         return failResult(acpSessionId, "openclaw-acp: aborted before prompt");
@@ -308,7 +336,18 @@ export class OpenclawAcpAdapter implements RuntimeAdapter {
             });
             handle.subscribers.delete(acpSessionId);
             acpSessionId = fresh;
-            handle.subscribers.set(acpSessionId, onNotification);
+            handle.subscribers.set(acpSessionId, { notify: onNotification, traceContext });
+            handle.trace?.write({
+              stream: "turn_context",
+              ...traceContext,
+              params: {
+                sessionId: acpSessionId,
+                sessionKey,
+                openclawAgent,
+                cwd: opts.cwd,
+                recreatedFrom: oldSessionId,
+              },
+            });
             log.info("openclaw-acp.session-recreated", {
               accountId: opts.accountId,
               oldSessionId,
@@ -627,19 +666,20 @@ function routeMessage(handle: AcpProcessHandle, msg: any): void {
   }
   // Notification.
   if (msg?.method && msg?.params) {
+    const sid = msg.params?.sessionId;
+    const sub = typeof sid === "string" ? handle.subscribers.get(sid) : undefined;
     handle.trace?.write({
       stream: "rpc_in",
       direction: "in",
       method: msg.method,
       status: "notification",
+      ...(sub?.traceContext ?? {}),
       params: msg.params,
     });
-    const sid = msg.params?.sessionId;
     if (typeof sid === "string") {
-      const sub = handle.subscribers.get(sid);
       if (sub) {
         try {
-          sub({ method: msg.method, params: msg.params });
+          sub.notify({ method: msg.method, params: msg.params });
         } catch (err) {
           log.warn("openclaw-acp.subscriber-threw", {
             error: err instanceof Error ? err.message : String(err),
@@ -1026,6 +1066,16 @@ function stringField(bag: Record<string, unknown> | undefined, key: string): str
   return typeof v === "string" && v.length > 0 ? v : undefined;
 }
 
+function nullableStringField(
+  bag: Record<string, unknown> | undefined,
+  key: string,
+): string | null | undefined {
+  if (!bag) return undefined;
+  const v = bag[key];
+  if (v === null) return null;
+  return typeof v === "string" && v.length > 0 ? v : undefined;
+}
+
 /**
  * Build the OpenClaw ACP `sessionKey` for a daemon turn. `accountId` is
  * always included to prevent two daemon agents from colliding on the same