@botcord/daemon 0.2.58 → 0.2.59

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";
@@ -49,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(

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 {
@@ -273,6 +275,16 @@ function diagnosticBundleCommands(filePath: string): {
   };
 }
 
+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> {
@@ -283,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();
@@ -298,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(),
   };
@@ -308,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",

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

@@ -77,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;
 }
 
@@ -398,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.