@botcord/daemon 0.2.57 → 0.2.59

package/dist/diagnostics.d.ts

@@ -9,12 +9,15 @@ export interface CreateDiagnosticBundleOptions {
         text: string;
         json: unknown;
     };
+    includeAllLogs?: boolean;
 }
 export interface DiagnosticBundleResult {
     path: string;
     filename: string;
     sizeBytes: number;
     createdAt: string;
+    revealCommand: string;
+    copyPathCommand: string;
 }
 export interface DiagnosticUploadResult {
     bundleId: string;

package/dist/diagnostics.js

@@ -5,11 +5,12 @@ 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 { LOG_FILE_PATH } from "./log.js";
+import { listDaemonLogFiles, LOG_FILE_PATH } from "./log.js";
 import { channelsFromDaemonConfig, defaultHttpFetcher, renderDoctor, runDoctor, } from "./doctor.js";
 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;
 const SECRET_PATTERNS = [
     [/(Authorization:\s*Bearer\s+)[^\s"']+/gi, "$1[REDACTED]"],
     [/("?(?:accessToken|access_token|refreshToken|refresh_token|token|privateKey|private_key|secret)"?\s*:\s*")[^"]+(")/gi, "$1[REDACTED]$2"],
@@ -189,6 +190,37 @@ function createZip(entries) {
     ]);
     return Buffer.concat([...localParts, central, end]);
 }
+function shellQuote(s) {
+    return `'${s.replace(/'/g, `'\\''`)}'`;
+}
+function diagnosticBundleCommands(filePath) {
+    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, includeAllLogs) {
+    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 = {}) {
     const createdAt = new Date();
     const stamp = createdAt.toISOString().replace(/[:.]/g, "-");
@@ -197,6 +229,8 @@ export async function createDiagnosticBundle(opts = {}) {
     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();
     const status = {
@@ -211,6 +245,13 @@ export async function createDiagnosticBundle(opts = {}) {
         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(),
     };
@@ -220,11 +261,21 @@ export async function createDiagnosticBundle(opts = {}) {
         { 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",
@@ -238,11 +289,13 @@ export async function createDiagnosticBundle(opts = {}) {
     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,
     };
 }
 export async function uploadDiagnosticBundle(opts) {

package/dist/gateway/channels/wechat.d.ts

@@ -18,6 +18,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;
 }
 /**
  * WeChat (iLink Bot API) channel adapter.

package/dist/gateway/channels/wechat.js

@@ -53,6 +53,9 @@ export function createWechatChannel(opts) {
     const allowedSenderIds = new Set((opts.allowedSenderIds ?? []).map((s) => String(s)));
     const fetchImpl = opts.fetchImpl ?? globalThis.fetch;
     const now = opts.now ?? (() => Date.now());
+    const traceContextMax = opts.traceContextMax && opts.traceContextMax > 0
+        ? opts.traceContextMax
+        : TRACE_CONTEXT_MAX;
     let botToken = opts.botToken;
     let stateStore = null;
     let stopCallback = null;
@@ -103,7 +106,7 @@ export function createWechatChannel(opts) {
     }
     function rememberTrace(traceId, ctx) {
         // W1: prune oldest entry by updatedAt when cap is reached.
-        if (traceContexts.size >= TRACE_CONTEXT_MAX) {
+        if (traceContexts.size >= traceContextMax) {
             let oldestKey;
             let oldestAt = Infinity;
             for (const [k, v] of traceContexts) {
@@ -282,6 +285,29 @@ export function createWechatChannel(opts) {
         }
         return parts.join("\n").trim();
     }
+    function extractMultimodalSummary(msg) {
+        const parts = [];
+        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) {
         if (msg.message_type !== 1)
             return null;
@@ -290,11 +316,12 @@ export function createWechatChannel(opts) {
         if (!fromUid || !contextToken)
             return null;
         const text = extractText(msg);
-        if (!text)
+        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.

package/dist/gateway/dispatcher.d.ts

@@ -94,6 +94,7 @@ export declare class Dispatcher {
     private readonly resolveHubUrl?;
     private readonly transcript;
     private readonly queues;
+    private readonly deferredMultimodal;
     /**
      * Last `/hub/typing` ping timestamp per (accountId, conversationId).
      * Used to debounce cancel-previous bursts so we don't trip Hub's 20/min
@@ -107,6 +108,8 @@ export declare class Dispatcher {
     turns(): Record<string, TurnStatusSnapshot>;
     private safeAck;
     private getQueue;
+    private deferMultimodal;
+    private takeDeferredMultimodal;
     private runCancelPrevious;
     /**
      * Serial mode with coalesce-on-drain semantics:

package/dist/gateway/dispatcher.js

@@ -78,6 +78,7 @@ export class Dispatcher {
     resolveHubUrl;
     transcript;
     queues = new Map();
+    deferredMultimodal = new Map();
     /**
      * Last `/hub/typing` ping timestamp per (accountId, conversationId).
      * Used to debounce cancel-previous bursts so we don't trip Hub's 20/min
@@ -125,6 +126,10 @@ export class Dispatcher {
             await this.safeAck(envelope);
             return;
         }
+        const managed = this.managedRoutes ? Array.from(this.managedRoutes.values()) : undefined;
+        const route = resolveRoute(msg, this.config, managed);
+        const mode = resolveQueueMode(route, msg.conversation.kind);
+        const queueKey = buildQueueKey(msg);
         // Pre-skip: empty/whitespace text.
         const rawText = typeof msg.text === "string" ? msg.text.trim() : "";
         if (!rawText) {
@@ -135,20 +140,76 @@ export class Dispatcher {
         // From here on, the inbound is a real conversation event — generate a
         // turnId and write the inbound transcript record.
         const turnId = randomUUID();
-        const managed = this.managedRoutes ? Array.from(this.managedRoutes.values()) : undefined;
-        const route = resolveRoute(msg, this.config, managed);
-        const mode = resolveQueueMode(route, msg.conversation.kind);
-        const queueKey = buildQueueKey(msg);
+        // Multimodal-only arrivals (files/images without sender-authored text)
+        // should not wake the runtime on their own. Ack them, record the inbound
+        // event, and prepend them to the next text-bearing turn for this queue.
+        if (isMultimodalOnlyMessage(msg)) {
+            await this.safeAck(envelope);
+            this.emitInbound(turnId, msg);
+            this.deferMultimodal(queueKey, { route, msg, channel, turnId, queuedAt: Date.now() });
+            this.log.info("dispatcher: deferred multimodal-only inbound", {
+                agentId: msg.accountId,
+                roomId: msg.conversation.id,
+                topicId: msg.conversation.threadId ?? null,
+                turnId,
+                messageId: msg.id,
+                senderId: msg.sender.id,
+                senderKind: msg.sender.kind,
+                mode,
+                queueKey,
+            });
+            if (this.onInbound) {
+                try {
+                    await this.onInbound(msg);
+                }
+                catch (err) {
+                    this.log.warn("dispatcher: onInbound threw — continuing", {
+                        messageId: msg.id,
+                        error: err instanceof Error ? err.message : String(err),
+                    });
+                }
+            }
+            return;
+        }
+        const deferred = this.takeDeferredMultimodal(queueKey);
+        let dispatchMsg = msg;
+        let dispatchTurnId = turnId;
+        let dispatchRoute = route;
+        let dispatchChannel = channel;
+        let text = rawText;
+        let mergedFromDeferredTurnIds = [];
+        if (deferred.length > 0) {
+            const merged = this.mergeSerialBuffer([...deferred, { route, msg, channel, turnId }], queueKey);
+            if (merged) {
+                dispatchMsg = merged.msg;
+                dispatchTurnId = merged.turnId;
+                dispatchRoute = merged.route;
+                dispatchChannel = merged.channel;
+                text = merged.text;
+                mergedFromDeferredTurnIds = deferred.map((e) => e.turnId);
+                for (const entry of deferred) {
+                    this.transcript.write({
+                        ts: nowIso(),
+                        kind: "dropped",
+                        turnId: entry.turnId,
+                        agentId: entry.msg.accountId,
+                        roomId: entry.msg.conversation.id,
+                        topicId: entry.msg.conversation.threadId ?? null,
+                        reason: "batch_merged",
+                        supersededBy: dispatchTurnId,
+                    });
+                }
+            }
+        }
         // Compose the final user-turn text only for cancel-previous mode, where
         // the dispatcher consumes the pre-composed text directly. Serial mode
         // re-runs the composer at drain time on the merged message (so it sees
         // the full coalesced batch instead of any single arrival), so calling
         // the composer here would just be redundant work.
-        let text = rawText;
         let composeFailedError;
         if (mode === "cancel-previous" && this.composeUserTurn) {
             try {
-                const composed = this.composeUserTurn(msg);
+                const composed = this.composeUserTurn(dispatchMsg);
                 if (typeof composed === "string" && composed.length > 0) {
                     text = composed;
                 }
@@ -156,7 +217,7 @@ export class Dispatcher {
             catch (err) {
                 composeFailedError = err instanceof Error ? err.message : String(err);
                 this.log.warn("dispatcher: composeUserTurn threw — using raw text", {
-                    messageId: msg.id,
+                    messageId: dispatchMsg.id,
                     error: composeFailedError,
                 });
             }
@@ -197,29 +258,29 @@ export class Dispatcher {
         if (this.attentionGate) {
             let wake = true;
             try {
-                const result = this.attentionGate(msg);
+                const result = this.attentionGate(dispatchMsg);
                 wake = result instanceof Promise ? await result : result;
             }
             catch (err) {
                 this.log.warn("dispatcher: attentionGate threw — waking", {
-                    messageId: msg.id,
+                    messageId: dispatchMsg.id,
                     error: err instanceof Error ? err.message : String(err),
                 });
                 wake = true;
             }
             if (!wake) {
                 this.log.debug("dispatcher skip turn: attention policy", {
-                    messageId: msg.id,
-                    accountId: msg.accountId,
-                    conversationId: msg.conversation.id,
+                    messageId: dispatchMsg.id,
+                    accountId: dispatchMsg.accountId,
+                    conversationId: dispatchMsg.conversation.id,
                 });
                 this.transcript.write({
                     ts: nowIso(),
                     kind: "attention_skipped",
-                    turnId,
-                    agentId: msg.accountId,
-                    roomId: msg.conversation.id,
-                    topicId: msg.conversation.threadId ?? null,
+                    turnId: dispatchTurnId,
+                    agentId: dispatchMsg.accountId,
+                    roomId: dispatchMsg.conversation.id,
+                    topicId: dispatchMsg.conversation.threadId ?? null,
                     reason: "attention_gate_false",
                 });
                 return;
@@ -229,19 +290,19 @@ export class Dispatcher {
             this.transcript.write({
                 ts: nowIso(),
                 kind: "compose_failed",
-                turnId,
-                agentId: msg.accountId,
-                roomId: msg.conversation.id,
-                topicId: msg.conversation.threadId ?? null,
+                turnId: dispatchTurnId,
+                agentId: dispatchMsg.accountId,
+                roomId: dispatchMsg.conversation.id,
+                topicId: dispatchMsg.conversation.threadId ?? null,
                 error: composeFailedError,
                 fallback: "raw_text",
             });
         }
         if (mode === "cancel-previous") {
-            await this.runCancelPrevious(queueKey, route, text, msg, channel, turnId);
+            await this.runCancelPrevious(queueKey, dispatchRoute, text, dispatchMsg, dispatchChannel, dispatchTurnId, mergedFromDeferredTurnIds);
         }
         else {
-            await this.runSerial(queueKey, route, text, msg, channel, turnId);
+            await this.runSerial(queueKey, dispatchRoute, text, dispatchMsg, dispatchChannel, dispatchTurnId, mergedFromDeferredTurnIds);
         }
     }
     /** Snapshot of currently running turns keyed by queue key. */
@@ -283,7 +344,37 @@ export class Dispatcher {
         }
         return q;
     }
-    async runCancelPrevious(queueKey, route, text, msg, channel, turnId) {
+    deferMultimodal(queueKey, entry) {
+        const list = this.deferredMultimodal.get(queueKey) ?? [];
+        list.push(entry);
+        while (list.length > MAX_BATCH_BUFFER_ENTRIES) {
+            const dropped = list.shift();
+            this.log.warn("dispatcher: deferred multimodal buffer overflow — dropped oldest", {
+                queueKey,
+                droppedMessageId: dropped.msg.id,
+                bufferCap: MAX_BATCH_BUFFER_ENTRIES,
+            });
+            this.transcript.write({
+                ts: nowIso(),
+                kind: "dropped",
+                turnId: dropped.turnId,
+                agentId: dropped.msg.accountId,
+                roomId: dropped.msg.conversation.id,
+                topicId: dropped.msg.conversation.threadId ?? null,
+                reason: "queue_overflow",
+                supersededBy: null,
+            });
+        }
+        this.deferredMultimodal.set(queueKey, list);
+    }
+    takeDeferredMultimodal(queueKey) {
+        const list = this.deferredMultimodal.get(queueKey);
+        if (!list || list.length === 0)
+            return [];
+        this.deferredMultimodal.delete(queueKey);
+        return list;
+    }
+    async runCancelPrevious(queueKey, route, text, msg, channel, turnId, mergedFromTurnIds = []) {
         const q = this.getQueue(queueKey);
         // Bump the generation on every arrival. Older arrivals still awaiting
         // the prior turn's teardown will observe `myGen !== q.cancelGen` when
@@ -342,7 +433,7 @@ export class Dispatcher {
             });
             return;
         }
-        await this.runTurn(queueKey, route, text, msg, channel, turnId, []);
+        await this.runTurn(queueKey, route, text, msg, channel, turnId, mergedFromTurnIds);
     }
     /**
      * Serial mode with coalesce-on-drain semantics:
@@ -362,7 +453,7 @@ export class Dispatcher {
      * merged message so the runtime sees a single coherent prompt covering all
      * coalesced messages.
      */
-    async runSerial(queueKey, route, _text, msg, channel, turnId) {
+    async runSerial(queueKey, route, _text, msg, channel, turnId, mergedFromTurnIds = []) {
         const q = this.getQueue(queueKey);
         q.serialBuffer.push({ route, msg, channel, turnId });
         while (q.serialBuffer.length > MAX_BATCH_BUFFER_ENTRIES) {
@@ -409,8 +500,10 @@ export class Dispatcher {
                         });
                     }
                 }
-                const mergedFromTurnIds = drained.length > 1 ? drained.slice(0, -1).map((e) => e.turnId) : [];
-                await this.runTurn(queueKey, merged.route, merged.text, merged.msg, merged.channel, merged.turnId, mergedFromTurnIds);
+                const mergedTurnIds = drained.length > 1
+                    ? [...mergedFromTurnIds, ...drained.slice(0, -1).map((e) => e.turnId)]
+                    : mergedFromTurnIds;
+                await this.runTurn(queueKey, merged.route, merged.text, merged.msg, merged.channel, merged.turnId, mergedTurnIds);
             }
         }
         finally {
@@ -478,8 +571,13 @@ export class Dispatcher {
         const latestRaw = latest.msg.raw ?? {};
         const mergedRaw = { ...latestRaw, batch: items };
         const anyMentioned = entries.some((e) => e.msg.mentioned === true);
+        const mergedText = entries
+            .map((e) => (typeof e.msg.text === "string" ? e.msg.text.trim() : ""))
+            .filter((s) => s.length > 0)
+            .join("\n");
         const mergedMsg = {
             ...latest.msg,
+            ...(mergedText ? { text: mergedText } : {}),
             mentioned: anyMentioned,
             raw: mergedRaw,
         };
@@ -1296,6 +1394,67 @@ function isOwnerChatRoom(msg) {
 function isBotCordChannel(channel) {
     return channel.type === "botcord" || channel.id === "botcord";
 }
+function isMultimodalOnlyMessage(msg) {
+    if (!hasMultimodalContent(msg.raw))
+        return false;
+    return !hasAuthoredText(msg.raw);
+}
+function hasAuthoredText(raw) {
+    if (!raw || typeof raw !== "object")
+        return false;
+    const obj = raw;
+    const batch = obj.batch;
+    if (Array.isArray(batch))
+        return batch.some((item) => hasAuthoredText(item));
+    if (typeof obj.text === "string" && obj.text.trim().length > 0) {
+        // BotCord's /hub/inbox `text` may be synthesized from attachment metadata
+        // when payload text is empty, so prefer envelope payload below when present.
+        if (!obj.envelope || typeof obj.envelope !== "object")
+            return true;
+    }
+    const envelope = obj.envelope;
+    const payload = envelope?.payload;
+    if (payload) {
+        for (const key of ["text", "body", "message"]) {
+            const value = payload[key];
+            if (typeof value === "string" && value.trim().length > 0)
+                return true;
+        }
+        return false;
+    }
+    const itemList = obj.item_list;
+    if (Array.isArray(itemList)) {
+        return itemList.some((item) => {
+            if (!item || typeof item !== "object")
+                return false;
+            const textItem = item.text_item;
+            return typeof textItem?.text === "string" && textItem.text.trim().length > 0;
+        });
+    }
+    return typeof obj.text === "string" && obj.text.trim().length > 0;
+}
+function hasMultimodalContent(raw) {
+    if (!raw || typeof raw !== "object")
+        return false;
+    const obj = raw;
+    const batch = obj.batch;
+    if (Array.isArray(batch))
+        return batch.some((item) => hasMultimodalContent(item));
+    const envelope = obj.envelope;
+    const payload = envelope?.payload;
+    const attachments = payload?.attachments;
+    if (Array.isArray(attachments) && attachments.length > 0)
+        return true;
+    const itemList = obj.item_list;
+    if (Array.isArray(itemList)) {
+        return itemList.some((item) => {
+            if (!item || typeof item !== "object")
+                return false;
+            return item.type !== 1;
+        });
+    }
+    return false;
+}
 function resolveQueueMode(route, kind) {
     if (route.queueMode)
         return route.queueMode;

package/dist/index.js

@@ -82,9 +82,12 @@ Commands:
   route list
   route remove --room <rm_xxx>|--prefix <rm_xxx>
   config                                  Print resolved config
-  doctor [--json] [--bundle]              Scan local runtimes (${ADAPTER_LIST});
+  doctor [--json] [--bundle] [--full-log] Scan local runtimes (${ADAPTER_LIST});
                                           --bundle also writes a zip under
-                                          ~/.botcord/diagnostics/
+                                          ~/.botcord/diagnostics/. Bundles
+                                          daemon.log plus the latest 5 rotated
+                                          logs by default; --full-log bundles
+                                          all retained rotated logs.
   memory get [--agent <ag_xxx>] [--json]  Show current working memory
   memory set [--agent <ag_xxx>] --goal <text>
                                           Pin/update the agent's work goal
@@ -109,6 +112,7 @@ const BOOLEAN_FLAGS = new Set([
     "follow",
     "json",
     "bundle",
+    "full-log",
     "help",
     "h",
     "mentioned",
@@ -1216,13 +1220,17 @@ const fsFileReader = {
 };
 async function cmdDoctor(args) {
     if (args.flags.bundle === true) {
-        const bundle = await createDiagnosticBundle();
+        const bundle = await createDiagnosticBundle({
+            includeAllLogs: args.flags["full-log"] === true,
+        });
         if (args.flags.json === true) {
             console.log(JSON.stringify({ bundle }, null, 2));
             return;
         }
         console.log(`diagnostic bundle written: ${bundle.path}`);
         console.log(`size: ${bundle.sizeBytes} bytes`);
+        console.log(`open in Finder/file manager: ${bundle.revealCommand}`);
+        console.log(`copy path to clipboard: ${bundle.copyPathCommand}`);
         console.log("Send this zip file to the BotCord developer/support contact.");
         return;
     }

package/dist/log.d.ts

@@ -1,5 +1,14 @@
 type Level = "info" | "warn" | "error" | "debug";
+export interface LogFileEntry {
+    path: string;
+    name: string;
+    sizeBytes: number;
+    mtimeMs: number;
+    active: boolean;
+}
 export declare function formatLogLine(level: Level, msg: string, fields: Record<string, unknown> | undefined, date?: Date): string;
+export declare function listDaemonLogFiles(logFile?: string): LogFileEntry[];
+export declare function rotateLogIfNeeded(logFile?: string, nextBytes?: number, maxBytes?: number, keep?: number): void;
 export declare const log: {
     info: (msg: string, fields?: Record<string, unknown>) => void;
     warn: (msg: string, fields?: Record<string, unknown>) => void;