@botcord/daemon 0.2.59 → 0.2.61

package/src/gateway/__tests__/botcord-channel.test.ts

@@ -27,6 +27,9 @@ function makeClient(overrides: Partial<BotCordChannelClient> = {}): BotCordChann
     sendMessage: vi
       .fn()
       .mockResolvedValue({ hub_msg_id: "m_provider", queued: true, status: "queued" }),
+    sendTypedMessage: vi
+      .fn()
+      .mockResolvedValue({ hub_msg_id: "m_provider_typed", queued: true, status: "queued" }),
     getHubUrl: vi.fn().mockReturnValue("http://127.0.0.1:1"),
     ...overrides,
   };
@@ -138,6 +141,34 @@ describe("createBotCordChannel — send()", () => {
     expect(client.sendMessage).toHaveBeenCalledWith("rm_dm_1", "hey", {});
     expect(result.providerMessageId).toBeNull();
   });
+
+  it("sends runtime diagnostics as BotCord error envelopes", async () => {
+    const client = makeClient();
+    const channel = createBotCordChannel({
+      id: "botcord-main",
+      accountId: "ag_self",
+      agentId: "ag_self",
+      client,
+    });
+    const result = await channel.send({
+      message: {
+        channel: "botcord",
+        accountId: "ag_self",
+        conversationId: "rm_group_a",
+        threadId: "tp_42",
+        replyTo: "env_source",
+        type: "error",
+        text: "Runtime error: boom",
+      },
+      log: silentLog,
+    });
+    expect(client.sendTypedMessage).toHaveBeenCalledWith("rm_group_a", "error", "Runtime error: boom", {
+      topic: "tp_42",
+      replyTo: "env_source",
+    });
+    expect(client.sendMessage).not.toHaveBeenCalled();
+    expect(result.providerMessageId).toBe("m_provider_typed");
+  });
 });
 
 // ---------------------------------------------------------------------------
@@ -263,6 +294,52 @@ describe("createBotCordChannel — inbox normalization", () => {
     }
   });
 
+  it("acks error InboxMessages without dispatching them", async () => {
+    const server = await startAuthOkServer();
+    const errorMessage = makeInbox({
+      hub_msg_id: "m_error_1",
+      text: undefined,
+      envelope: {
+        type: "error",
+        from: "ag_peer",
+        payload: { error: { code: "agent_error", message: "Runtime error: boom" } },
+      } as InboxMessage["envelope"],
+    });
+    const client = makeClient({
+      pollInbox: vi.fn().mockResolvedValue({ messages: [errorMessage], count: 1, has_more: false }),
+      getHubUrl: vi.fn().mockReturnValue(server.url),
+    });
+    const channel = createBotCordChannel({
+      id: "botcord-main",
+      accountId: "ag_self",
+      agentId: "ag_self",
+      client,
+      hubBaseUrl: server.url,
+    });
+    const abort = new AbortController();
+    const emits: GatewayInboundEnvelope[] = [];
+    const startPromise = channel.start({
+      config: stubConfig,
+      accountId: "ag_self",
+      abortSignal: abort.signal,
+      log: silentLog,
+      emit: async (env) => {
+        emits.push(env);
+      },
+      setStatus: () => {},
+    });
+    try {
+      await vi.waitFor(() => {
+        expect(client.ackMessages).toHaveBeenCalledWith(["m_error_1"]);
+      });
+      expect(emits).toHaveLength(0);
+    } finally {
+      abort.abort();
+      await startPromise;
+      await server.close();
+    }
+  });
+
   it("marks rm_dm_ and rm_oc_ rooms as direct; rm_oc_ also sets streamable + user-kind", async () => {
     const { emits, server } = await startWithInbox([
       makeInbox({

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

@@ -492,6 +492,7 @@ describe("Dispatcher", () => {
     await dispatcher.handle(makeEnvelope({ id: "msg_error" }));
 
     expect(channel.sends.length).toBe(1);
+    expect(channel.sends[0].message.type).toBe("error");
     expect(channel.sends[0].message.text).toContain("Runtime error");
     expect(channel.sends[0].message.text).toContain("missing openclawAgent");
   });
@@ -1256,6 +1257,7 @@ describe("Dispatcher", () => {
 
     await dispatcher.handle(makeEnvelope({ id: "m1" }));
     expect(channel.sends.length).toBe(1);
+    expect(channel.sends[0].message.type).toBe("error");
     expect(channel.sends[0].message.text).toContain("Runtime error");
     expect(channel.sends[0].message.text).toContain("boom");
     expect(store.all().length).toBe(0);
@@ -1903,7 +1905,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 });
@@ -1920,13 +1922,17 @@ 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.type).toBe("error");
+      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,
@@ -1937,7 +1943,11 @@ 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.type).toBe("error");
+    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");
   });
 
   // ─────────────────────────────────────────────────────────────────────

package/src/gateway/__tests__/feishu-channel.test.ts

@@ -0,0 +1,306 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { createFeishuChannel } from "../channels/feishu.js";
+import type {
+  ChannelStartContext,
+  GatewayInboundEnvelope,
+  GatewayLogger,
+} from "../types.js";
+
+const larkMock = vi.hoisted(() => ({
+  requests: [] as unknown[],
+  responses: [] as unknown[],
+  handlers: {} as Record<string, (data: unknown) => unknown>,
+  wsStartError: null as Error | null,
+  wsClosed: false,
+}));
+
+vi.mock("@larksuiteoapi/node-sdk", () => ({
+  AppType: { SelfBuild: "SelfBuild" },
+  Domain: { Feishu: "feishu", Lark: "lark" },
+  LoggerLevel: { info: "info" },
+  Client: vi.fn().mockImplementation(function Client() {
+    return {
+    request: vi.fn(async (args: unknown) => {
+      larkMock.requests.push(args);
+      const next = larkMock.responses.shift();
+      if (next instanceof Error) throw next;
+      return next ?? { code: 0, data: {} };
+    }),
+    };
+  }),
+  EventDispatcher: vi.fn().mockImplementation(function EventDispatcher() {
+    return {
+      register: vi.fn((handlers: Record<string, (data: unknown) => unknown>) => {
+        Object.assign(larkMock.handlers, handlers);
+      }),
+    };
+  }),
+  WSClient: vi.fn().mockImplementation(function WSClient() {
+    return {
+      start: vi.fn(() => {
+      if (larkMock.wsStartError) return Promise.reject(larkMock.wsStartError);
+      return Promise.resolve();
+      }),
+      close: vi.fn(() => {
+        larkMock.wsClosed = true;
+      }),
+    };
+  }),
+}));
+
+const SILENT_LOG: GatewayLogger = {
+  info: () => {},
+  warn: () => {},
+  error: () => {},
+  debug: () => {},
+};
+
+const stubConfig = {
+  channels: [],
+  defaultRoute: { runtime: "claude-code", cwd: "/tmp" },
+};
+
+function makeStartCtx(abort: AbortController): {
+  ctx: ChannelStartContext;
+  envelopes: GatewayInboundEnvelope[];
+  statuses: Array<Record<string, unknown>>;
+} {
+  const envelopes: GatewayInboundEnvelope[] = [];
+  const statuses: Array<Record<string, unknown>> = [];
+  return {
+    envelopes,
+    statuses,
+    ctx: {
+      config: stubConfig,
+      accountId: "ag_self",
+      abortSignal: abort.signal,
+      log: SILENT_LOG,
+      emit: async (env) => {
+        envelopes.push(env);
+      },
+      setStatus: (patch) => {
+        statuses.push({ ...patch });
+      },
+    },
+  };
+}
+
+let tmp: string;
+
+beforeEach(() => {
+  tmp = mkdtempSync(path.join(tmpdir(), "feishu-channel-"));
+  larkMock.requests = [];
+  larkMock.responses = [];
+  larkMock.handlers = {};
+  larkMock.wsStartError = null;
+  larkMock.wsClosed = false;
+});
+
+afterEach(() => {
+  rmSync(tmp, { recursive: true, force: true });
+});
+
+describe("createFeishuChannel", () => {
+  it("normalizes non-text events and deduplicates repeated message ids", async () => {
+    larkMock.responses.push({
+      code: 0,
+      data: { pingBotInfo: { botID: "ou_bot", botName: "Bot" } },
+    });
+    const adapter = createFeishuChannel({
+      id: "gw_fs",
+      accountId: "ag_self",
+      appId: "cli_a",
+      appSecret: "sec",
+      allowedSenderIds: ["ou_alice"],
+      allowedChatIds: ["oc_chat"],
+      stateFile: path.join(tmp, "state.json"),
+      stateDebounceMs: 0,
+    });
+    const abort = new AbortController();
+    const { ctx, envelopes } = makeStartCtx(abort);
+    const started = adapter.start(ctx);
+    await vi.waitUntil(() => typeof larkMock.handlers["im.message.receive_v1"] === "function");
+
+    const event = {
+      sender: { sender_id: { open_id: "ou_alice" } },
+      message: {
+        message_id: "om_img_1",
+        chat_id: "oc_chat",
+        chat_type: "group",
+        message_type: "image",
+        content: JSON.stringify({ image_key: "img_v2_x" }),
+      },
+    };
+    await larkMock.handlers["im.message.receive_v1"]!(event);
+    await larkMock.handlers["im.message.receive_v1"]!(event);
+    abort.abort();
+    await started;
+
+    expect(envelopes).toHaveLength(1);
+    expect(envelopes[0]!.message.text).toBe("[image: img_v2_x]");
+    expect(envelopes[0]!.message.conversation.id).toBe("feishu:chat:oc_chat");
+  });
+
+  it("sends text replies through Feishu reply API with thread mode", async () => {
+    larkMock.responses.push({ code: 0, data: { message_id: "om_reply_1" } });
+    const adapter = createFeishuChannel({
+      id: "gw_fs",
+      accountId: "ag_self",
+      appId: "cli_a",
+      appSecret: "sec",
+    });
+
+    const result = await adapter.send({
+      log: SILENT_LOG,
+      message: {
+        channel: "gw_fs",
+        accountId: "ag_self",
+        conversationId: "feishu:chat:oc_chat",
+        threadId: "om_root",
+        replyTo: "om_parent",
+        text: "hello",
+      },
+    });
+
+    expect(result.providerMessageId).toBe("om_reply_1");
+    expect(larkMock.requests).toHaveLength(1);
+    const req = larkMock.requests[0] as { url: string; data: Record<string, unknown> };
+    expect(req.url).toBe("/open-apis/im/v1/messages/om_parent/reply");
+    expect(req.data.reply_in_thread).toBe(true);
+    expect(req.data.msg_type).toBe("text");
+  });
+
+  it("uploads image attachments and sends them as Feishu image replies", async () => {
+    larkMock.responses.push(
+      { code: 0, data: { image_key: "img_v2_uploaded" } },
+      { code: 0, data: { message_id: "om_image_reply" } },
+    );
+    const adapter = createFeishuChannel({
+      id: "gw_fs",
+      accountId: "ag_self",
+      appId: "cli_a",
+      appSecret: "sec",
+    });
+
+    const result = await adapter.send({
+      log: SILENT_LOG,
+      message: {
+        channel: "gw_fs",
+        accountId: "ag_self",
+        conversationId: "feishu:chat:oc_chat",
+        text: "",
+        replyTo: "om_parent",
+        attachments: [
+          {
+            data: new Uint8Array([1, 2, 3]),
+            filename: "shot.png",
+            contentType: "image/png",
+          },
+        ],
+      },
+    });
+
+    expect(result.providerMessageId).toBe("om_image_reply");
+    expect(larkMock.requests).toHaveLength(2);
+    const upload = larkMock.requests[0] as { url: string; data: Record<string, unknown> };
+    expect(upload.url).toBe("/open-apis/im/v1/images");
+    expect(upload.data.image_type).toBe("message");
+    const send = larkMock.requests[1] as { url: string; data: Record<string, unknown> };
+    expect(send.url).toBe("/open-apis/im/v1/messages/om_parent/reply");
+    expect(send.data.msg_type).toBe("image");
+    expect(JSON.parse(send.data.content as string)).toEqual({ image_key: "img_v2_uploaded" });
+  });
+
+  it("uploads file attachments and sends them as Feishu file messages", async () => {
+    larkMock.responses.push(
+      { code: 0, data: { file_key: "file_v2_uploaded" } },
+      { code: 0, data: { message_id: "om_file_msg" } },
+    );
+    const adapter = createFeishuChannel({
+      id: "gw_fs",
+      accountId: "ag_self",
+      appId: "cli_a",
+      appSecret: "sec",
+    });
+
+    const result = await adapter.send({
+      log: SILENT_LOG,
+      message: {
+        channel: "gw_fs",
+        accountId: "ag_self",
+        conversationId: "feishu:chat:oc_chat",
+        text: "",
+        attachments: [
+          {
+            data: new Uint8Array([4, 5, 6]),
+            filename: "report.pdf",
+            contentType: "application/pdf",
+          },
+        ],
+      },
+    });
+
+    expect(result.providerMessageId).toBe("om_file_msg");
+    expect(larkMock.requests).toHaveLength(2);
+    const upload = larkMock.requests[0] as { url: string; data: Record<string, unknown> };
+    expect(upload.url).toBe("/open-apis/im/v1/files");
+    expect(upload.data.file_type).toBe("pdf");
+    expect(upload.data.file_name).toBe("report.pdf");
+    const send = larkMock.requests[1] as { url: string; data: Record<string, unknown> };
+    expect(send.url).toBe("/open-apis/im/v1/messages");
+    expect(send.data.msg_type).toBe("file");
+    expect(JSON.parse(send.data.content as string)).toEqual({ file_key: "file_v2_uploaded" });
+  });
+
+  it("exposes typing as a safe no-op because Feishu has no bot typing API", async () => {
+    const debug = vi.fn();
+    const adapter = createFeishuChannel({
+      id: "gw_fs",
+      accountId: "ag_self",
+      appId: "cli_a",
+      appSecret: "sec",
+    });
+
+    await adapter.typing?.({
+      traceId: "feishu:om_1",
+      accountId: "ag_self",
+      conversationId: "feishu:chat:oc_chat",
+      log: { ...SILENT_LOG, debug },
+    });
+
+    expect(larkMock.requests).toHaveLength(0);
+    expect(debug).toHaveBeenCalledWith(
+      "feishu typing ignored: no native bot typing API",
+      expect.objectContaining({ channel: "gw_fs" }),
+    );
+  });
+
+  it("surfaces websocket start failures in channel status", async () => {
+    larkMock.responses.push({
+      code: 0,
+      data: { pingBotInfo: { botID: "ou_bot", botName: "Bot" } },
+    });
+    larkMock.wsStartError = new Error("ws denied");
+    const adapter = createFeishuChannel({
+      id: "gw_fs",
+      accountId: "ag_self",
+      appId: "cli_a",
+      appSecret: "sec",
+      allowedSenderIds: ["ou_alice"],
+      stateFile: path.join(tmp, "state.json"),
+      stateDebounceMs: 0,
+    });
+    const abort = new AbortController();
+    const { ctx, statuses } = makeStartCtx(abort);
+    const started = adapter.start(ctx);
+    await vi.waitUntil(() => statuses.some((s) => s.lastError === "ws denied"));
+    abort.abort();
+    await started;
+
+    expect(adapter.status()?.lastError).toBe("ws denied");
+    expect(adapter.status()?.authorized).toBe(false);
+  });
+});

package/src/gateway/channels/botcord.ts

@@ -55,6 +55,12 @@ export interface BotCordChannelClient {
     text: string,
     options?: { replyTo?: string; topic?: string },
   ): Promise<{ hub_msg_id?: string; message_id?: string } & Record<string, unknown>>;
+  sendTypedMessage?(
+    to: string,
+    type: "result" | "error",
+    text: string,
+    options?: { replyTo?: string; topic?: string },
+  ): Promise<{ hub_msg_id?: string; message_id?: string } & Record<string, unknown>>;
   getHubUrl(): string;
   onTokenRefresh?: (token: string, expiresAt: number) => void;
 }
@@ -804,7 +810,10 @@ export function createBotCordChannel(options: BotCordChannelOptions): ChannelAda
       const options: { replyTo?: string; topic?: string } = {};
       if (message.replyTo) options.replyTo = message.replyTo;
       if (message.threadId) options.topic = message.threadId;
-      const resp = await client.sendMessage(message.conversationId, message.text, options);
+      const resp =
+        message.type === "error" && client.sendTypedMessage
+          ? await client.sendTypedMessage(message.conversationId, "error", message.text, options)
+          : await client.sendMessage(message.conversationId, message.text, options);
       const providerMessageId =
         (resp && typeof resp.hub_msg_id === "string" && resp.hub_msg_id) ||
         (resp && typeof (resp as { message_id?: unknown }).message_id === "string"

package/src/gateway/channels/feishu-registration.ts

@@ -0,0 +1,155 @@
+/**
+ * Feishu/Lark PersonalAgent app registration helpers.
+ *
+ * Mirrors the flow used by `@larksuite/openclaw-lark-tools`:
+ *   POST /oauth/v1/app/registration action=init
+ *   POST /oauth/v1/app/registration action=begin
+ *   POST /oauth/v1/app/registration action=poll
+ */
+
+import type { FetchLike } from "./http-types.js";
+
+export type FeishuDomain = "feishu" | "lark";
+
+const FEISHU_ACCOUNTS_BASE = "https://accounts.feishu.cn";
+const LARK_ACCOUNTS_BASE = "https://accounts.larksuite.com";
+
+export interface FeishuRegistrationOptions {
+  domain?: FeishuDomain;
+  fetchImpl?: FetchLike;
+}
+
+export interface FeishuRegistrationStart {
+  deviceCode: string;
+  verificationUriComplete: string;
+  verificationUri?: string;
+  expiresIn: number;
+  interval: number;
+  domain: FeishuDomain;
+  raw: Record<string, unknown>;
+}
+
+export interface FeishuRegistrationPoll {
+  status: "pending" | "confirmed" | "expired" | "denied" | "failed";
+  appId?: string;
+  appSecret?: string;
+  userOpenId?: string;
+  domain: FeishuDomain;
+  interval?: number;
+  error?: string;
+  raw: Record<string, unknown>;
+}
+
+function baseForDomain(domain: FeishuDomain): string {
+  return domain === "lark" ? LARK_ACCOUNTS_BASE : FEISHU_ACCOUNTS_BASE;
+}
+
+function fetcher(opts: FeishuRegistrationOptions): FetchLike {
+  return opts.fetchImpl ?? ((globalThis.fetch as unknown) as FetchLike);
+}
+
+async function postRegistration(
+  action: string,
+  params: Record<string, string>,
+  opts: FeishuRegistrationOptions,
+): Promise<Record<string, unknown>> {
+  const domain = opts.domain ?? "feishu";
+  const res = await fetcher(opts)(`${baseForDomain(domain)}/oauth/v1/app/registration`, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({ action, ...params }).toString(),
+  });
+  const raw = await res.text();
+  if (!raw) return {};
+  try {
+    return JSON.parse(raw) as Record<string, unknown>;
+  } catch {
+    throw new Error(`feishu registration ${action}: non-json response`);
+  }
+}
+
+export async function startFeishuRegistration(
+  opts: FeishuRegistrationOptions = {},
+): Promise<FeishuRegistrationStart> {
+  const domain = opts.domain ?? "feishu";
+  const init = await postRegistration("init", {}, { ...opts, domain });
+  const methods = Array.isArray(init.supported_auth_methods)
+    ? init.supported_auth_methods.map(String)
+    : [];
+  if (methods.length > 0 && !methods.includes("client_secret")) {
+    throw new Error("feishu registration: client_secret auth is not supported");
+  }
+  const begin = await postRegistration(
+    "begin",
+    {
+      archetype: "PersonalAgent",
+      auth_method: "client_secret",
+      request_user_info: "open_id",
+    },
+    { ...opts, domain },
+  );
+  const deviceCode = typeof begin.device_code === "string" ? begin.device_code : "";
+  const verificationUriComplete =
+    typeof begin.verification_uri_complete === "string"
+      ? begin.verification_uri_complete
+      : "";
+  if (!deviceCode || !verificationUriComplete) {
+    throw new Error("feishu registration: missing device_code or verification_uri_complete");
+  }
+  return {
+    deviceCode,
+    verificationUriComplete,
+    ...(typeof begin.verification_uri === "string"
+      ? { verificationUri: begin.verification_uri }
+      : {}),
+    expiresIn: typeof begin.expire_in === "number" ? begin.expire_in : 600,
+    interval: typeof begin.interval === "number" ? begin.interval : 5,
+    domain,
+    raw: begin,
+  };
+}
+
+export async function pollFeishuRegistration(
+  deviceCode: string,
+  opts: FeishuRegistrationOptions = {},
+): Promise<FeishuRegistrationPoll> {
+  const domain = opts.domain ?? "feishu";
+  const data = await postRegistration(
+    "poll",
+    { device_code: deviceCode },
+    { ...opts, domain },
+  );
+  const tenantBrand =
+    typeof (data.user_info as Record<string, unknown> | undefined)?.tenant_brand === "string"
+      ? String((data.user_info as Record<string, unknown>).tenant_brand)
+      : "";
+  const resolvedDomain: FeishuDomain = tenantBrand === "lark" ? "lark" : domain;
+  const appId = typeof data.client_id === "string" ? data.client_id : undefined;
+  const appSecret =
+    typeof data.client_secret === "string" ? data.client_secret : undefined;
+  if (appId && appSecret) {
+    const userInfo = data.user_info as Record<string, unknown> | undefined;
+    return {
+      status: "confirmed",
+      appId,
+      appSecret,
+      userOpenId: typeof userInfo?.open_id === "string" ? userInfo.open_id : undefined,
+      domain: resolvedDomain,
+      raw: data,
+    };
+  }
+  const error = typeof data.error === "string" ? data.error : "";
+  if (!error || error === "authorization_pending") {
+    return { status: "pending", domain: resolvedDomain, raw: data };
+  }
+  if (error === "slow_down") {
+    return { status: "pending", domain: resolvedDomain, interval: 10, raw: data };
+  }
+  if (error === "access_denied") {
+    return { status: "denied", domain: resolvedDomain, error, raw: data };
+  }
+  if (error === "expired_token" || error === "invalid_grant") {
+    return { status: "expired", domain: resolvedDomain, error, raw: data };
+  }
+  return { status: "failed", domain: resolvedDomain, error: error || "unknown", raw: data };
+}