@botcord/daemon 0.2.57 → 0.2.59

package/dist/log.js

@@ -1,8 +1,10 @@
-import { appendFileSync, mkdirSync } from "node:fs";
+import { appendFileSync, mkdirSync, readdirSync, renameSync, statSync, unlinkSync } from "node:fs";
 import { homedir } from "node:os";
 import path from "node:path";
 const LOG_DIR = path.join(homedir(), ".botcord", "logs");
 const LOG_FILE = path.join(LOG_DIR, "daemon.log");
+const LOG_ROTATE_MAX_BYTES = 10 * 1024 * 1024;
+const LOG_ROTATE_KEEP = 20;
 let inited = false;
 function ensureDir() {
     if (inited)
@@ -39,10 +41,96 @@ export function formatLogLine(level, msg, fields, date = new Date()) {
     const suffix = `ts=${date.toISOString()}`;
     return detail ? `${prefix} ${detail} ${suffix}` : `${prefix} ${suffix}`;
 }
+function rotatedName(file, date = new Date()) {
+    const stamp = date.toISOString().replace(/[:.]/g, "-");
+    return `${file}.${stamp}.${process.pid}`;
+}
+export function listDaemonLogFiles(logFile = LOG_FILE) {
+    const dir = path.dirname(logFile);
+    const base = path.basename(logFile);
+    const entries = [];
+    try {
+        const st = statSync(logFile);
+        if (st.isFile()) {
+            entries.push({
+                path: logFile,
+                name: base,
+                sizeBytes: st.size,
+                mtimeMs: st.mtimeMs,
+                active: true,
+            });
+        }
+    }
+    catch {
+        // no active log
+    }
+    let names = [];
+    try {
+        names = readdirSync(dir);
+    }
+    catch {
+        return entries;
+    }
+    for (const name of names) {
+        if (!name.startsWith(`${base}.`))
+            continue;
+        const file = path.join(dir, name);
+        try {
+            const st = statSync(file);
+            if (!st.isFile())
+                continue;
+            entries.push({
+                path: file,
+                name,
+                sizeBytes: st.size,
+                mtimeMs: st.mtimeMs,
+                active: false,
+            });
+        }
+        catch {
+            // ignore disappearing files
+        }
+    }
+    return entries.sort((a, b) => {
+        if (a.active !== b.active)
+            return a.active ? -1 : 1;
+        return b.mtimeMs - a.mtimeMs || b.name.localeCompare(a.name);
+    });
+}
+export function rotateLogIfNeeded(logFile = LOG_FILE, nextBytes = 0, maxBytes = LOG_ROTATE_MAX_BYTES, keep = LOG_ROTATE_KEEP) {
+    let currentSize = 0;
+    try {
+        const st = statSync(logFile);
+        if (!st.isFile())
+            return;
+        currentSize = st.size;
+    }
+    catch {
+        return;
+    }
+    if (currentSize + nextBytes <= maxBytes)
+        return;
+    try {
+        renameSync(logFile, rotatedName(logFile));
+    }
+    catch {
+        return;
+    }
+    const rotated = listDaemonLogFiles(logFile).filter((entry) => !entry.active);
+    for (const entry of rotated.slice(Math.max(0, keep))) {
+        try {
+            unlinkSync(entry.path);
+        }
+        catch {
+            // best-effort cleanup
+        }
+    }
+}
 function write(level, msg, fields) {
     ensureDir();
     const line = formatLogLine(level, msg, fields);
     try {
+        rotateLogIfNeeded(LOG_FILE, Buffer.byteLength(line) + 1);
         appendFileSync(LOG_FILE, line + "\n", { mode: 0o600 });
     }
     catch {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botcord/daemon",
-  "version": "0.2.57",
+  "version": "0.2.59",
   "description": "BotCord local daemon — bridges Hub inbox push to local Claude Code / Codex / Gemini CLIs",
   "type": "module",
   "bin": {

package/src/__tests__/diagnostics.test.ts

@@ -1,4 +1,4 @@
-import { existsSync, mkdtempSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, mkdtempSync, readFileSync, utimesSync, writeFileSync } from "node:fs";
 import { execFileSync } from "node:child_process";
 import { tmpdir } from "node:os";
 import path from "node:path";
@@ -25,6 +25,12 @@ describe("diagnostics bundle", () => {
     });
     expect(bundle.filename).toMatch(/^botcord-daemon-diagnostics-.*\.zip$/);
     expect(bundle.path).toContain(diagnosticsDir);
+    if (process.platform === "linux") {
+      expect(bundle.revealCommand).toContain(diagnosticsDir);
+    } else {
+      expect(bundle.revealCommand).toContain(bundle.path);
+    }
+    expect(bundle.copyPathCommand).toContain(bundle.path);
     expect(existsSync(bundle.path)).toBe(true);
     const bytes = readFileSync(bundle.path);
     expect(bytes.subarray(0, 4).toString("binary")).toBe("PK\u0003\u0004");
@@ -43,4 +49,40 @@ describe("diagnostics bundle", () => {
     expect(log).toContain("Authorization: Bearer [REDACTED]");
     expect(log).toContain('"refreshToken":"[REDACTED]"');
   }, 20_000);
+
+  it("bundles active log plus latest 5 rotated logs by default, or all with includeAllLogs", async () => {
+    const tmp = mkdtempSync(path.join(tmpdir(), "botcord-diag-logs-test-"));
+    const logFile = path.join(tmp, "daemon.log");
+    const configFile = path.join(tmp, "config.json");
+    const snapshotFile = path.join(tmp, "snapshot.json");
+    writeFileSync(logFile, "active\n");
+    writeFileSync(configFile, "{}\n");
+    writeFileSync(snapshotFile, "{}\n");
+    for (let i = 0; i < 7; i += 1) {
+      const rotated = path.join(tmp, `daemon.log.rot-${i}`);
+      writeFileSync(rotated, `rotated ${i}\n`);
+      const t = new Date(1_700_000_000_000 + i * 1000);
+      utimesSync(rotated, t, t);
+    }
+
+    const baseOpts = {
+      diagnosticsDir: path.join(tmp, "diagnostics"),
+      logFile,
+      configFile,
+      snapshotFile,
+      doctor: { text: "doctor ok", json: { ok: true } },
+    };
+    const bundle = await createDiagnosticBundle(baseOpts);
+    const listing = execFileSync("unzip", ["-l", bundle.path], { encoding: "utf8" });
+    expect(listing).toContain("daemon.log");
+    expect(listing).toContain("logs/daemon.log.rot-6");
+    expect(listing).toContain("logs/daemon.log.rot-2");
+    expect(listing).not.toContain("logs/daemon.log.rot-1");
+    expect(listing).not.toContain("logs/daemon.log.rot-0");
+
+    const full = await createDiagnosticBundle({ ...baseOpts, includeAllLogs: true });
+    const fullListing = execFileSync("unzip", ["-l", full.path], { encoding: "utf8" });
+    expect(fullListing).toContain("logs/daemon.log.rot-0");
+    expect(fullListing).toContain("logs/daemon.log.rot-6");
+  }, 20_000);
 });

package/src/__tests__/log.test.ts

@@ -1,5 +1,8 @@
 import { describe, expect, it } from "vitest";
-import { formatLogLine } from "../log.js";
+import { mkdtempSync, readdirSync, rmSync, utimesSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { formatLogLine, listDaemonLogFiles, rotateLogIfNeeded } from "../log.js";
 
 describe("formatLogLine", () => {
   it("renders compact text with level, message, details, and trailing timestamp", () => {
@@ -27,4 +30,28 @@ describe("formatLogLine", () => {
       '[INFO] botcord ws server error msg={"type":"error","code":503} ts=2026-05-01T00:22:07.131Z',
     );
   });
+
+  it("rotates oversized logs and keeps the newest 20 rotated files", () => {
+    const tmp = mkdtempSync(path.join(tmpdir(), "botcord-log-test-"));
+    try {
+      const logFile = path.join(tmp, "daemon.log");
+      writeFileSync(logFile, "active log line\n");
+      for (let i = 0; i < 20; i += 1) {
+        const rotated = path.join(tmp, `daemon.log.old-${String(i).padStart(2, "0")}`);
+        writeFileSync(rotated, `old ${i}\n`);
+        const t = new Date(1_700_000_000_000 + i * 1000);
+        utimesSync(rotated, t, t);
+      }
+
+      rotateLogIfNeeded(logFile, 1, 10, 20);
+      const logs = listDaemonLogFiles(logFile);
+      const rotated = logs.filter((entry) => !entry.active);
+
+      expect(rotated).toHaveLength(20);
+      expect(rotated.some((entry) => entry.name === "daemon.log.old-00")).toBe(false);
+      expect(rotated.some((entry) => entry.name.startsWith("daemon.log."))).toBe(true);
+    } finally {
+      rmSync(tmp, { recursive: true, force: true });
+    }
+  });
 });

package/src/__tests__/wechat-channel.test.ts

@@ -222,6 +222,53 @@ describe("wechat channel adapter", () => {
     expect(JSON.parse(stateRaw).cursor).toBe("cursor-after-1");
   });
 
+  it("normalizes media-only inbound items so dispatcher can defer them", async () => {
+    const calls: Array<{ url: string; body: Record<string, unknown> | null }> = [];
+    const fetchImpl = buildFetchStub(
+      [
+        {
+          match: "getupdates",
+          respond: (idx) => {
+            if (idx === 0) {
+              return {
+                body: {
+                  ret: 0,
+                  get_updates_buf: "cursor-after-media",
+                  msgs: [
+                    {
+                      message_type: 1,
+                      from_user_id: "alice@im.wechat",
+                      context_token: "ctx-media",
+                      client_id: "wechat-media-1",
+                      item_list: [{ type: 4, file_item: { file_name: "report.pdf", len: 123 } }],
+                    },
+                  ],
+                },
+              };
+            }
+            return { body: { ret: 0, get_updates_buf: "cursor-after-media", msgs: [] } };
+          },
+        },
+      ],
+      calls,
+    );
+    const adapter = createWechatChannel({
+      id: "gw_wx_media",
+      accountId: "ag_test",
+      botToken: "tok-123",
+      stateFile: path.join(tmp, "state.json"),
+      fetchImpl,
+      stateDebounceMs: 0,
+      allowedSenderIds: ["alice@im.wechat"],
+    });
+    const h = startAdapter(adapter, { stopAfterEnvelopes: 1 });
+    await h.pollDone;
+
+    expect(h.envelopes).toHaveLength(1);
+    expect(h.envelopes[0]!.message.id).toBe("wechat-media-1");
+    expect(h.envelopes[0]!.message.text).toBe("[File: report.pdf]");
+  });
+
   it("drops messages missing context_token", async () => {
     const calls: Array<{ url: string; body: Record<string, unknown> | null }> = [];
     const fetchImpl = buildFetchStub(
@@ -1080,7 +1127,7 @@ describe("W1: traceContexts hard cap", () => {
     rmSync(tmpCap, { recursive: true, force: true });
   });
 
-  it("inserting 5001 entries keeps the map at <= 5000 (oldest pruned)", async () => {
+  it("keeps trace context map at the configured cap (oldest pruned)", async () => {
     // Build an adapter with a fake clock so we can control updatedAt order.
     let nowMs = 1_000_000;
     const fetchImpl = buildFetchStub(
@@ -1088,8 +1135,9 @@ describe("W1: traceContexts hard cap", () => {
         {
           match: "getupdates",
           respond: (idx) => {
-            if (idx < 5001) {
-              // Each poll returns one message so we get 5001 trace entries.
+            if (idx < 3) {
+              // Each poll returns one message so we get one more entry than
+              // the test cap without looping 5001 times in CI.
               nowMs += 1;
               return {
                 body: {
@@ -1106,7 +1154,7 @@ describe("W1: traceContexts hard cap", () => {
                 },
               };
             }
-            return { body: { ret: 0, get_updates_buf: `buf-5001`, msgs: [] } };
+            return { body: { ret: 0, get_updates_buf: `buf-3`, msgs: [] } };
           },
         },
       ],
@@ -1121,11 +1169,12 @@ describe("W1: traceContexts hard cap", () => {
       stateDebounceMs: 0,
       allowedSenderIds: ["alice@im.wechat"],
       now: () => nowMs,
+      traceContextMax: 2,
     });
-    const h = startAdapter(adapter, { stopAfterEnvelopes: 5001 });
+    const h = startAdapter(adapter, { stopAfterEnvelopes: 3 });
     await h.pollDone;
-    // 5001 messages were accepted; the cap should have kept the map <= 5000.
-    expect(h.envelopes.length).toBe(5001);
+    // 3 messages were accepted; the cap should have kept the map <= 2.
+    expect(h.envelopes.length).toBe(3);
     // We can't read traceContexts directly, but we verify that the send() for
     // the very first trace ID now fails (it was evicted as the oldest entry).
     const firstTraceId = h.envelopes[0]!.message.trace!.id;

package/src/diagnostics.ts

@@ -16,7 +16,7 @@ import {
   loadConfig,
   type DaemonConfig,
 } from "./config.js";
-import { LOG_FILE_PATH } from "./log.js";
+import { listDaemonLogFiles, LOG_FILE_PATH, type LogFileEntry } from "./log.js";
 import {
   channelsFromDaemonConfig,
   defaultHttpFetcher,
@@ -29,6 +29,7 @@ import { detectRuntimes } from "./adapters/runtimes.js";
 
 const DIAGNOSTICS_DIR = path.join(homedir(), ".botcord", "diagnostics");
 const MAX_UPLOAD_BYTES = 50 * 1024 * 1024;
+const DEFAULT_ROTATED_LOGS_IN_BUNDLE = 5;
 
 export interface CreateDiagnosticBundleOptions {
   diagnosticsDir?: string;
@@ -36,6 +37,7 @@ export interface CreateDiagnosticBundleOptions {
   configFile?: string;
   snapshotFile?: string;
   doctor?: { text: string; json: unknown };
+  includeAllLogs?: boolean;
 }
 
 export interface DiagnosticBundleResult {
@@ -43,6 +45,8 @@ export interface DiagnosticBundleResult {
   filename: string;
   sizeBytes: number;
   createdAt: string;
+  revealCommand: string;
+  copyPathCommand: string;
 }
 
 export interface DiagnosticUploadResult {
@@ -242,6 +246,45 @@ function createZip(entries: Array<{ name: string; data: string | Buffer }>): Buf
   return Buffer.concat([...localParts, central, end]);
 }
 
+function shellQuote(s: string): string {
+  return `'${s.replace(/'/g, `'\\''`)}'`;
+}
+
+function diagnosticBundleCommands(filePath: string): {
+  revealCommand: string;
+  copyPathCommand: string;
+} {
+  if (process.platform === "darwin") {
+    return {
+      revealCommand: `open -R ${shellQuote(filePath)}`,
+      copyPathCommand: `printf '%s' ${shellQuote(filePath)} | pbcopy`,
+    };
+  }
+
+  if (process.platform === "win32") {
+    const psPath = filePath.replace(/'/g, "''");
+    return {
+      revealCommand: `explorer.exe /select,"${filePath.replace(/"/g, '""')}"`,
+      copyPathCommand: `powershell.exe -NoProfile -Command "Set-Clipboard -Value '${psPath}'"`,
+    };
+  }
+
+  return {
+    revealCommand: `xdg-open ${shellQuote(path.dirname(filePath))}`,
+    copyPathCommand: `printf '%s' ${shellQuote(filePath)} | xclip -selection clipboard`,
+  };
+}
+
+function bundledLogs(logFile: string, includeAllLogs: boolean): LogFileEntry[] {
+  const all = listDaemonLogFiles(logFile);
+  const active = all.filter((entry) => entry.active);
+  const rotated = all.filter((entry) => !entry.active);
+  return [
+    ...active,
+    ...(includeAllLogs ? rotated : rotated.slice(0, DEFAULT_ROTATED_LOGS_IN_BUNDLE)),
+  ];
+}
+
 export async function createDiagnosticBundle(
   opts: CreateDiagnosticBundleOptions = {},
 ): Promise<DiagnosticBundleResult> {
@@ -252,6 +295,8 @@ 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 includeAllLogs = opts.includeAllLogs === true;
+  const logs = bundledLogs(logFile, includeAllLogs);
   mkdirSync(diagnosticsDir, { recursive: true, mode: 0o700 });
 
   const doctor = opts.doctor ?? await buildDoctorEntries();
@@ -267,6 +312,13 @@ export async function createDiagnosticBundle(
     configPath: configFile,
     snapshotPath: snapshotFile,
     logPath: logFile,
+    logsBundled: logs.map((entry) => ({
+      name: entry.name,
+      path: entry.path,
+      sizeBytes: entry.sizeBytes,
+      active: entry.active,
+    })),
+    logsBundleMode: includeAllLogs ? "all" : `active_plus_${DEFAULT_ROTATED_LOGS_IN_BUNDLE}_rotated`,
     diagnosticsDir,
     userAuth: readUserAuthSummary(),
   };
@@ -277,11 +329,20 @@ export async function createDiagnosticBundle(
     { name: "doctor.txt", data: doctor.text + "\n" },
     { name: "doctor.json", data: JSON.stringify(doctor.json, null, 2) + "\n" },
   ];
-  const log = safeReadText(logFile);
-  entries.push({
-    name: "daemon.log",
-    data: log ?? `no log file at ${logFile}\n`,
-  });
+  if (logs.length === 0) {
+    entries.push({
+      name: "daemon.log",
+      data: `no log file at ${logFile}\n`,
+    });
+  } else {
+    for (const entry of logs) {
+      const log = safeReadText(entry.path);
+      entries.push({
+        name: entry.active ? "daemon.log" : `logs/${entry.name}`,
+        data: log ?? `no log file at ${entry.path}\n`,
+      });
+    }
+  }
   const config = safeReadText(configFile);
   entries.push({
     name: "config.json.redacted",
@@ -296,11 +357,13 @@ export async function createDiagnosticBundle(
   const zip = createZip(entries);
   const out = path.join(diagnosticsDir, filename);
   writeFileSync(out, zip, { mode: 0o600 });
+  const commands = diagnosticBundleCommands(out);
   return {
     path: out,
     filename,
     sizeBytes: zip.length,
     createdAt: createdAt.toISOString(),
+    ...commands,
   };
 }
 

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

@@ -362,6 +362,58 @@ describe("Dispatcher", () => {
     expect(runtime.calls[0].text).toBe("WRAPPED:hello");
   });
 
+  it("defers multimodal-only BotCord messages until the next text turn and preserves order", async () => {
+    const runtime = new FakeRuntime({ reply: "ok", newSessionId: "sid-1" });
+    const { store, dir } = await makeStore();
+    tempDirs.push(dir);
+    const channel = new FakeChannel();
+    const dispatcher = new Dispatcher({
+      config: baseConfig(),
+      channels: new Map<string, ChannelAdapter>([[channel.id, channel]]),
+      runtime: () => runtime,
+      sessionStore: store,
+      log: silentLogger(),
+      composeUserTurn: (msg) => {
+        const raw = msg.raw as { batch?: Array<{ text?: string }> };
+        return (raw.batch ?? [{ text: msg.text }]).map((m) => m.text).join("\n");
+      },
+    });
+    const acceptMedia = vi.fn(async () => {});
+    const acceptText = vi.fn(async () => {});
+
+    await dispatcher.handle(makeEnvelope({
+      id: "h_media",
+      text: '{"attachments":[{"filename":"a.png"}]}\nAttachments\na.png',
+      raw: {
+        hub_msg_id: "h_media",
+        text: '{"attachments":[{"filename":"a.png"}]}\nAttachments\na.png',
+        envelope: {
+          type: "message",
+          payload: { attachments: [{ filename: "a.png", url: "/hub/files/f_1" }] },
+        },
+      },
+    }, { accept: acceptMedia }));
+
+    expect(acceptMedia).toHaveBeenCalledTimes(1);
+    expect(runtime.calls.length).toBe(0);
+
+    await dispatcher.handle(makeEnvelope({
+      id: "h_text",
+      text: "please inspect this",
+      raw: {
+        hub_msg_id: "h_text",
+        text: "please inspect this",
+        envelope: { type: "message", payload: { text: "please inspect this" } },
+      },
+    }, { accept: acceptText }));
+
+    expect(acceptText).toHaveBeenCalledTimes(1);
+    expect(runtime.calls.length).toBe(1);
+    expect(runtime.calls[0].text).toBe(
+      '{"attachments":[{"filename":"a.png"}]}\nAttachments\na.png\nplease inspect this',
+    );
+  });
+
   it("falls back to raw text when composeUserTurn throws", async () => {
     const runtime = new FakeRuntime({ reply: "ok", newSessionId: "sid-1" });
     const { store, dir } = await makeStore();

package/src/gateway/channels/wechat.ts

@@ -65,6 +65,8 @@ export interface WechatChannelOptions {
   stateDebounceMs?: number;
   /** Test hook: override Date.now() for trace cache TTL assertions. */
   now?: () => number;
+  /** Test hook: override trace context cache cap without a 5000-poll test. */
+  traceContextMax?: number;
 }
 
 interface WechatSecret {
@@ -75,6 +77,9 @@ interface WechatSecret {
 interface WechatItem {
   type?: number;
   text_item?: { text?: string };
+  image_item?: Record<string, unknown>;
+  file_item?: { file_name?: string; len?: unknown; [k: string]: unknown };
+  video_item?: { file_name?: string; video_size?: unknown; [k: string]: unknown };
   [k: string]: unknown;
 }
 
@@ -138,6 +143,10 @@ export function createWechatChannel(opts: WechatChannelOptions): ChannelAdapter
   const fetchImpl: FetchLike =
     opts.fetchImpl ?? ((globalThis.fetch as unknown) as FetchLike);
   const now: () => number = opts.now ?? (() => Date.now());
+  const traceContextMax =
+    opts.traceContextMax && opts.traceContextMax > 0
+      ? opts.traceContextMax
+      : TRACE_CONTEXT_MAX;
 
   let botToken: string | undefined = opts.botToken;
   let stateStore: GatewayStateStore | null = null;
@@ -195,7 +204,7 @@ export function createWechatChannel(opts: WechatChannelOptions): ChannelAdapter
 
   function rememberTrace(traceId: string, ctx: TraceContext): void {
     // W1: prune oldest entry by updatedAt when cap is reached.
-    if (traceContexts.size >= TRACE_CONTEXT_MAX) {
+    if (traceContexts.size >= traceContextMax) {
       let oldestKey: string | undefined;
       let oldestAt = Infinity;
       for (const [k, v] of traceContexts) {
@@ -392,16 +401,40 @@ export function createWechatChannel(opts: WechatChannelOptions): ChannelAdapter
     return parts.join("\n").trim();
   }
 
+  function extractMultimodalSummary(msg: WechatInboundMsg): string {
+    const parts: string[] = [];
+    for (const item of msg.item_list ?? []) {
+      if (!item || item.type === 1) continue;
+      if (item.type === 2) {
+        parts.push("[Image]");
+        continue;
+      }
+      if (item.type === 5) {
+        const name = item.video_item?.file_name;
+        parts.push(name ? `[Video: ${name}]` : "[Video]");
+        continue;
+      }
+      if (item.type === 4) {
+        const name = item.file_item?.file_name;
+        parts.push(name ? `[File: ${name}]` : "[File]");
+        continue;
+      }
+      parts.push(`[Unsupported media item: type=${String(item.type ?? "unknown")}]`);
+    }
+    return parts.join("\n").trim();
+  }
+
   function normalizeInbound(msg: WechatInboundMsg): GatewayInboundMessage | null {
     if (msg.message_type !== 1) return null;
     const fromUid = typeof msg.from_user_id === "string" ? msg.from_user_id : "";
     const contextToken = typeof msg.context_token === "string" ? msg.context_token : "";
     if (!fromUid || !contextToken) return null;
     const text = extractText(msg);
-    if (!text) return null;
+    const multimodalSummary = text ? "" : extractMultimodalSummary(msg);
+    if (!text && !multimodalSummary) return null;
     if (!allowedSenderIds.has(fromUid)) return null;
 
-    const sanitized = sanitizeUntrustedContent(text);
+    const sanitized = sanitizeUntrustedContent(text || multimodalSummary);
     const receivedAt = now();
     // W10: append randomUUID() to the fallback so two messages received in
     // the same millisecond can't collide. Trace id below already does this.