@botcord/daemon 0.2.59 → 0.2.61

package/dist/config.d.ts

@@ -85,7 +85,7 @@ export interface OpenclawDiscoveryConfig {
     autoProvision?: boolean;
 }
 /** 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
  * channel id (typically `gw_...` minted by the Hub); `accountId` is the
@@ -106,6 +106,9 @@ export interface ThirdPartyGatewayProfile {
     allowedChatIds?: string[];
     splitAt?: number;
     baseUrl?: string;
+    appId?: string;
+    domain?: "feishu" | "lark";
+    userOpenId?: string;
 }
 export interface DaemonConfig {
     /**

package/dist/config.js

@@ -216,8 +216,8 @@ export function loadConfig() {
             if (typeof gg.id !== "string" || gg.id.length === 0) {
                 throw new Error(`daemon config thirdPartyGateways[${i}].id must be a non-empty string (${CONFIG_PATH})`);
             }
-            if (gg.type !== "telegram" && gg.type !== "wechat") {
-                throw new Error(`daemon config thirdPartyGateways[${i}].type must be "telegram" or "wechat" (${CONFIG_PATH})`);
+            if (gg.type !== "telegram" && gg.type !== "wechat" && gg.type !== "feishu") {
+                throw new Error(`daemon config thirdPartyGateways[${i}].type must be "telegram", "wechat", or "feishu" (${CONFIG_PATH})`);
             }
             if (typeof gg.accountId !== "string" || gg.accountId.length === 0) {
                 throw new Error(`daemon config thirdPartyGateways[${i}].accountId must be a non-empty string (${CONFIG_PATH})`);

package/dist/cross-room.js

@@ -10,7 +10,9 @@ export function buildCrossRoomDigest(opts) {
     const total = entries.length + 1; // +1 for the current turn's room
     const lines = [
         "[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/dist/daemon-config-map.js

@@ -193,6 +193,12 @@ export function toGatewayConfig(cfg, opts = {}) {
             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);
     }
     // DaemonConfig's typed surface doesn't carry `trustLevel`, but we read it

package/dist/daemon.js

@@ -1,5 +1,5 @@
 import { CONTROL_FRAME_TYPES, shouldWake, } from "@botcord/protocol-core";
-import { Gateway, createBotCordChannel, createTelegramChannel, createWechatChannel, resolveTranscriptEnabled, sanitizeUntrustedContent, } from "./gateway/index.js";
+import { Gateway, createBotCordChannel, createFeishuChannel, createTelegramChannel, createWechatChannel, resolveTranscriptEnabled, sanitizeUntrustedContent, } from "./gateway/index.js";
 import { ActivityTracker } from "./activity-tracker.js";
 import { SESSIONS_PATH, SNAPSHOT_PATH } from "./config.js";
 import { resolveBootAgents } from "./agent-discovery.js";
@@ -118,6 +118,23 @@ export function createDaemonChannel(chCfg, deps) {
                 ...(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 }
+                    : {}),
+                ...(Array.isArray(chCfg.allowedChatIds)
+                    ? { allowedChatIds: chCfg.allowedChatIds }
+                    : {}),
+                ...(typeof chCfg.splitAt === "number" ? { splitAt: chCfg.splitAt } : {}),
+                ...(typeof chCfg.secretFile === "string" ? { secretFile: chCfg.secretFile } : {}),
+            });
         default:
             throw new Error(`unknown channel type "${chCfg.type}"`);
     }
@@ -296,6 +313,9 @@ export async function startDaemon(opts) {
     // effective policy, then defer to the protocol-core `shouldWake` decision.
     const attentionGate = async (msg) => {
         const policy = 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),

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

@@ -23,6 +23,13 @@ export interface BotCordChannelClient {
         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;
 }

package/dist/gateway/channels/botcord.js

@@ -674,7 +674,9 @@ export function createBotCordChannel(options) {
                 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.message_id === "string"
                     ? resp.message_id

package/dist/gateway/channels/feishu-registration.d.ts

@@ -0,0 +1,35 @@
+/**
+ * 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";
+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>;
+}
+export declare function startFeishuRegistration(opts?: FeishuRegistrationOptions): Promise<FeishuRegistrationStart>;
+export declare function pollFeishuRegistration(deviceCode: string, opts?: FeishuRegistrationOptions): Promise<FeishuRegistrationPoll>;

package/dist/gateway/channels/feishu-registration.js

@@ -0,0 +1,101 @@
+/**
+ * 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
+ */
+const FEISHU_ACCOUNTS_BASE = "https://accounts.feishu.cn";
+const LARK_ACCOUNTS_BASE = "https://accounts.larksuite.com";
+function baseForDomain(domain) {
+    return domain === "lark" ? LARK_ACCOUNTS_BASE : FEISHU_ACCOUNTS_BASE;
+}
+function fetcher(opts) {
+    return opts.fetchImpl ?? globalThis.fetch;
+}
+async function postRegistration(action, params, opts) {
+    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);
+    }
+    catch {
+        throw new Error(`feishu registration ${action}: non-json response`);
+    }
+}
+export async function startFeishuRegistration(opts = {}) {
+    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, opts = {}) {
+    const domain = opts.domain ?? "feishu";
+    const data = await postRegistration("poll", { device_code: deviceCode }, { ...opts, domain });
+    const tenantBrand = typeof data.user_info?.tenant_brand === "string"
+        ? String(data.user_info.tenant_brand)
+        : "";
+    const resolvedDomain = 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;
+        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 };
+}

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

@@ -0,0 +1,16 @@
+import type { ChannelAdapter } from "../types.js";
+import type { FeishuDomain } from "./feishu-registration.js";
+export interface FeishuChannelOptions {
+    id: string;
+    accountId: string;
+    appId?: string;
+    appSecret?: string;
+    domain?: FeishuDomain;
+    allowedSenderIds?: string[];
+    allowedChatIds?: string[];
+    splitAt?: number;
+    secretFile?: string;
+    stateFile?: string;
+    stateDebounceMs?: number;
+}
+export declare function createFeishuChannel(opts: FeishuChannelOptions): ChannelAdapter;