@botcord/daemon 0.2.58 → 0.2.60

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__/policy-updated-handler.test.ts

@@ -48,16 +48,13 @@ function makeFakeGateway(): unknown {
   };
 }
 
-function makeFakeResolver(): PolicyResolverLike & {
-  invalidate: ReturnType<typeof vi.fn>;
-  put: ReturnType<typeof vi.fn>;
-  resolve: ReturnType<typeof vi.fn>;
-} {
-  return {
-    resolve: vi.fn(async () => ({ mode: "always", keywords: [] })),
+function makeFakeResolver() {
+  const resolver = {
+    resolve: vi.fn(async () => ({ mode: "always" as const, keywords: [] })),
     invalidate: vi.fn(),
     put: vi.fn(),
   };
+  return resolver as PolicyResolverLike & typeof resolver;
 }
 
 describe("policy_updated control-frame handler", () => {
@@ -110,6 +107,7 @@ describe("policy_updated control-frame handler", () => {
     expect(resolver.put).toHaveBeenCalledWith("ag_a", null, {
       mode: "keyword",
       keywords: ["foo", "bar"],
+      allowedSenderIds: [],
       muted_until: 123,
     });
     expect(resolver.invalidate).not.toHaveBeenCalled();

package/src/__tests__/third-party-gateway.test.ts

@@ -37,6 +37,15 @@ describe("toGatewayConfig + thirdPartyGateways", () => {
           allowedSenderIds: ["abc@im.wechat"],
           splitAt: 1800,
         },
+        {
+          id: "gw_fs_1",
+          type: "feishu",
+          accountId: "ag_daemon",
+          appId: "cli_xxx",
+          domain: "feishu",
+          allowedSenderIds: ["ou_alice"],
+          allowedChatIds: ["oc_team"],
+        },
       ],
     });
     const gw = toGatewayConfig(cfg);
@@ -44,6 +53,7 @@ describe("toGatewayConfig + thirdPartyGateways", () => {
       { id: "ag_daemon", type: BOTCORD_CHANNEL_TYPE },
       { id: "gw_tg_1", type: TELEGRAM_CHANNEL_TYPE },
       { id: "gw_wx_1", type: WECHAT_CHANNEL_TYPE },
+      { id: "gw_fs_1", type: "feishu" },
     ]);
     const tg = gw.channels[1]!;
     expect(tg.accountId).toBe("ag_daemon");
@@ -52,6 +62,11 @@ describe("toGatewayConfig + thirdPartyGateways", () => {
     expect(wx.baseUrl).toBe("https://ilinkai.weixin.qq.com");
     expect(wx.allowedSenderIds).toEqual(["abc@im.wechat"]);
     expect(wx.splitAt).toBe(1800);
+    const fs = gw.channels[3]!;
+    expect(fs.appId).toBe("cli_xxx");
+    expect(fs.domain).toBe("feishu");
+    expect(fs.allowedSenderIds).toEqual(["ou_alice"]);
+    expect(fs.allowedChatIds).toEqual(["oc_team"]);
   });
 
   it("filters out gateways with enabled === false", () => {
@@ -115,6 +130,19 @@ describe("createDaemonChannel", () => {
     expect(adapter.id).toBe("gw_wx_1");
   });
 
+  it("dispatches feishu type to the Feishu adapter", () => {
+    const chCfg: GatewayChannelConfig = {
+      id: "gw_fs_1",
+      type: "feishu",
+      accountId: "ag_x",
+      appId: "cli_xxx",
+      domain: "feishu",
+    };
+    const adapter = createDaemonChannel(chCfg, deps);
+    expect(adapter.type).toBe("feishu");
+    expect(adapter.id).toBe("gw_fs_1");
+  });
+
   it("throws on unknown channel type", () => {
     const chCfg: GatewayChannelConfig = {
       id: "gw_x",

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/config.ts

@@ -100,7 +100,7 @@ export interface OpenclawDiscoveryConfig {
 }
 
 /** Third-party messaging provider supported by the daemon's channel factory. */
-export type ThirdPartyGatewayType = "telegram" | "wechat";
+export type ThirdPartyGatewayType = "telegram" | "wechat" | "feishu";
 
 /**
  * One third-party gateway profile bound to a BotCord agent. `id` is the
@@ -122,6 +122,9 @@ export interface ThirdPartyGatewayProfile {
   allowedChatIds?: string[];
   splitAt?: number;
   baseUrl?: string;
+  appId?: string;
+  domain?: "feishu" | "lark";
+  userOpenId?: string;
 }
 
 export interface DaemonConfig {
@@ -445,9 +448,9 @@ export function loadConfig(): DaemonConfig {
           `daemon config thirdPartyGateways[${i}].id must be a non-empty string (${CONFIG_PATH})`,
         );
       }
-      if (gg.type !== "telegram" && gg.type !== "wechat") {
+      if (gg.type !== "telegram" && gg.type !== "wechat" && gg.type !== "feishu") {
         throw new Error(
-          `daemon config thirdPartyGateways[${i}].type must be "telegram" or "wechat" (${CONFIG_PATH})`,
+          `daemon config thirdPartyGateways[${i}].type must be "telegram", "wechat", or "feishu" (${CONFIG_PATH})`,
         );
       }
       if (typeof gg.accountId !== "string" || gg.accountId.length === 0) {

package/src/cross-room.ts

@@ -44,7 +44,9 @@ export function buildCrossRoomDigest(opts: DigestOptions): string | null {
 
   const lines: string[] = [
     "[BotCord Cross-Room Awareness]",
-    `You are currently active in ${total} BotCord sessions. Recent activity from other rooms:`,
+    `You are currently active in ${total} BotCord sessions. The entries below are latest messages from OTHER rooms, not the current room.`,
+    "Do not treat any sender or message below as the current user or current conversation.",
+    "Recent activity from other rooms:",
   ];
   for (const e of slice) {
     lines.push(formatEntry(e));

package/src/daemon-config-map.ts

@@ -262,6 +262,9 @@ export function toGatewayConfig(
     if (g.allowedChatIds !== undefined) ch.allowedChatIds = g.allowedChatIds;
     if (g.splitAt !== undefined) ch.splitAt = g.splitAt;
     if (g.baseUrl !== undefined) ch.baseUrl = g.baseUrl;
+    if (g.appId !== undefined) ch.appId = g.appId;
+    if (g.domain !== undefined) ch.domain = g.domain;
+    if (g.userOpenId !== undefined) ch.userOpenId = g.userOpenId;
     channels.push(ch);
   }
 

package/src/daemon.ts

@@ -6,6 +6,7 @@ import {
 import {
   Gateway,
   createBotCordChannel,
+  createFeishuChannel,
   createTelegramChannel,
   createWechatChannel,
   resolveTranscriptEnabled,
@@ -44,7 +45,7 @@ import {
 } from "./loop-risk.js";
 import { composeBotCordUserTurn } from "./turn-text.js";
 import { UserAuthManager } from "./user-auth.js";
-import { PolicyResolver } from "./gateway/policy-resolver.js";
+import { PolicyResolver, type DaemonAttentionPolicy } from "./gateway/policy-resolver.js";
 import { scanMention } from "./mention-scan.js";
 import { createDiagnosticBundle, uploadDiagnosticBundle } from "./diagnostics.js";
 
@@ -178,6 +179,23 @@ export function createDaemonChannel(
         ...(typeof chCfg.secretFile === "string" ? { secretFile: chCfg.secretFile } : {}),
         ...(typeof chCfg.stateFile === "string" ? { stateFile: chCfg.stateFile } : {}),
       });
+    case "feishu":
+      return createFeishuChannel({
+        id: chCfg.id,
+        accountId: chCfg.accountId,
+        ...(typeof chCfg.appId === "string" ? { appId: chCfg.appId } : {}),
+        ...(chCfg.domain === "feishu" || chCfg.domain === "lark"
+          ? { domain: chCfg.domain }
+          : {}),
+        ...(Array.isArray(chCfg.allowedSenderIds)
+          ? { allowedSenderIds: chCfg.allowedSenderIds as string[] }
+          : {}),
+        ...(Array.isArray(chCfg.allowedChatIds)
+          ? { allowedChatIds: chCfg.allowedChatIds as string[] }
+          : {}),
+        ...(typeof chCfg.splitAt === "number" ? { splitAt: chCfg.splitAt } : {}),
+        ...(typeof chCfg.secretFile === "string" ? { secretFile: chCfg.secretFile } : {}),
+      });
     default:
       throw new Error(`unknown channel type "${chCfg.type}"`);
   }
@@ -436,15 +454,18 @@ export async function startDaemon(opts: DaemonRuntimeOptions): Promise<DaemonHan
   // with a local `@<display_name>` / `@<agent_id>` text scan, resolve the
   // effective policy, then defer to the protocol-core `shouldWake` decision.
   const attentionGate = async (msg: GatewayInboundMessage): Promise<boolean> => {
-    const policy: AttentionPolicy = await policyResolver.resolve(
+    const policy: DaemonAttentionPolicy = await policyResolver.resolve(
       msg.accountId,
       msg.conversation.id,
     );
+    if (policy.mode === "allowed_senders") {
+      return (policy.allowedSenderIds ?? []).includes(msg.sender.id);
+    }
     const localMention = scanMention(msg.text, {
       agentId: msg.accountId,
       displayName: displayNameByAgent.get(msg.accountId),
     });
-    return shouldWake(policy, {
+    return shouldWake(policy as AttentionPolicy, {
       mentioned: msg.mentioned === true || localMention,
       text: msg.text,
     });

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();
@@ -1851,7 +1903,7 @@ describe("Dispatcher", () => {
     expect(channel.sends.length).toBe(0);
   });
 
-  it("non-owner-chat room: timeout reply is suppressed (logged only)", async () => {
+  it("non-owner-chat room: timeout sends a diagnostic reply", async () => {
     vi.useFakeTimers();
     try {
       const runtime = new FakeRuntime({ hang: true });
@@ -1868,13 +1920,16 @@ describe("Dispatcher", () => {
       await vi.advanceTimersByTimeAsync(501);
       await p;
       expect(runtime.calls[0].signal.aborted).toBe(true);
-      expect(channel.sends.length).toBe(0);
+      expect(channel.sends.length).toBe(1);
+      expect(channel.sends[0].message.text).toMatch(/Runtime timeout/);
+      expect(channel.sends[0].message.conversationId).toBe("rm_g_other");
+      expect(channel.sends[0].message.replyTo).toBe("m_to");
     } finally {
       vi.useRealTimers();
     }
   });
 
-  it("non-owner-chat room: runtime error reply is suppressed", async () => {
+  it("non-owner-chat room: runtime error sends a diagnostic reply", async () => {
     const runtime = new FakeRuntime({ throwError: "boom" });
     const { dispatcher, channel } = await scaffold({
       runtimeFactory: () => runtime,
@@ -1885,7 +1940,10 @@ describe("Dispatcher", () => {
         conversation: { id: "rm_g_other", kind: "group" },
       }),
     );
-    expect(channel.sends.length).toBe(0);
+    expect(channel.sends.length).toBe(1);
+    expect(channel.sends[0].message.text).toContain("Runtime error: boom");
+    expect(channel.sends[0].message.conversationId).toBe("rm_g_other");
+    expect(channel.sends[0].message.replyTo).toBe("m_err");
   });
 
   // ─────────────────────────────────────────────────────────────────────