@openclaw-cn/feishu

--- package/package.json (excerpt) ---
{
  "name": "@openclaw-cn/feishu",
  "version": "0.1.11",
  "description": "飞书（Larksuite）OpenClaw 中文频道插件，由OpenClaw中文社区维护，提供飞书机器人集成（WebSocket）。",
  "keywords": [
    "feishu",
    "larksuite",
    "openclaw",
    "plugin"
  ],
  "homepage": "https://github.com/openclaw/openclaw-cn/tree/main/extensions/feishu",
  "bugs": {
    "url": "https://github.com/openclaw/openclaw-cn/issues"
  },
  "license": "MIT",
  "repository": {
    "type": "git",
    "url": "https://github.com/openclaw/openclaw-cn.git",
    "directory": "extensions/feishu"
  },
  "files": [
    "openclaw.plugin.json",
    "package.json",
    "README.md",
    "dist/"
  ],
  "type": "module",
  "main": "./dist/index.js",
  "types": "./dist/index.d.ts",
  "exports": {
    ".": {
      "types": "./dist/index.d.ts",
      "import": "./dist/index.js"
    }
  },
  "publishConfig": {
    "access": "public",
    "registry": "https://registry.npmjs.org/"
  },
  "scripts": {
    "build": "tsc",
    "clean": "rm -rf dist"
  },
  "dependencies": {
    "@larksuiteoapi/node-sdk": "^1.56.1",
    "@sinclair/typebox": "^0.34.47",
    "zod": "^4.3.6"
  },
  "peerDependencies": {
    "openclaw": "*",
    "openclaw-cn": "*"
  },
  "peerDependenciesMeta": {
    "openclaw": {
      "optional": true
    },
    "openclaw-cn": {
      "optional": true
    }
  },
  "openclaw": {
    "extensions": [
      "./dist/index.js"
    ],
    "channel": {
      "id": "feishu",
      "label": "飞书",
      "selectionLabel": "飞书 (Lark 开放平台)",
      "docsP

--- bundled output (OSV-MAL flagged — LLM scope expansion) ---

--- dist/index.d.ts (bundled) ---
import type { ClawdbotPluginApi } from "openclaw/plugin-sdk";
declare const plugin: {
    id: string;
    name: string;
    description: string;
    configSchema: {
        safeParse?: (value: unknown) => {
            success: boolean;
            data?: unknown;
            error?: {
                issues?: Array<{
                    path: Array<string | number>;
                    message: string;
                }>;
            };
        };
        parse?: (value: unknown) => unknown;
        validate?: (value: unknown) => {
            ok: true;
            value?: unknown;
        } | {
            ok: false;
            errors: string[];
        };
        uiHints?: Record<string, {
            label?: string;
            help?: string;
            advanced?: boolean;
            sensitive?: boolean;
            placeholder?: string;
        }>;
        jsonSchema?: Record<string, unknown>;
    };
    register(api: ClawdbotPluginApi): void;
};
export default plugin;
//# sourceMappingURL=index.d.ts.map

--- dist/index.js (bundled) ---
// @ts-ignore - dynamic import resolution
import { emptyPluginConfigSchema } from "openclaw/plugin-sdk";
import { feishuPlugin } from "./src/channel.js";
import { setFeishuRuntime } from "./src/runtime.js";
// Core document & knowledge modules
import { registerFeishuDocTools } from "./src/docx.js";
import { registerFeishuDriveTools } from "./src/drive.js";
import { registerFeishuWikiTools } from "./src/wiki.js";
import { registerFeishuPermTools } from "./src/perm.js";
import { registerFeishuBitableTools } from "./src/bitable.js";
// Enhanced modules
import { registerFeishuImTools } from "./src/im.js";
import { registerFeishuTaskTools } from "./src/task.js";
import { registerFeishuCalendarTools } from "./src/calendar.js";
import { registerFeishuSheetsTools } from "./src/sheets.js";
const plugin = {
    id: "feishu",
    name: "Feishu",
    description: "Feishu (Larksuite) channel plugin",
    configSchema: emptyPluginConfigSchema(),
    register(api) {
        setFeishuRuntime(api.runtime);
        api.registerChannel({ plugin: feishuPlugin });
        // Register all tool modules
        const registrations = [
            registerFeishuDocTools,
            registerFeishuDriveTools,
            registerFeishuWikiTools,
            registerFeishuPermTools,
            registerFeishuBitableTools,
            registerFeishuImTools,
            registerFeishuTaskTools,
            registerFeishuCalendarTools,
            registerFeishuSheetsTools,
        ];
        for (const register of registrations) {
            try {
                register(api);
            }
            catch (e) {
                console.error(`[feishu] tool registration failed: ${register.name}`, e);
            }
        }
        // Log directly to console to ensure visibility during startup
        console.log(`[feishu] plugins registered: ${registrations.length} modules loaded`);
    },
};
export default plugin;
//# sourceMappingURL=index.js.map

--- dist/src/accounts.d.ts (bundled) ---
import type { OpenClawConfig as ClawdbotConfig } from "openclaw/plugin-sdk";
import type { FeishuConfig, FeishuDomain, ResolvedFeishuAccount } from "./types.js";
/**
 * List all Feishu account IDs.
 * If no accounts are configured, returns [DEFAULT_ACCOUNT_ID] for backward compatibility.
 */
export declare function listFeishuAccountIds(cfg: ClawdbotConfig): string[];
/**
 * Resolve the default account ID.
 */
export declare function resolveDefaultFeishuAccountId(cfg: ClawdbotConfig): string;
/**
 * Resolve Feishu credentials from a config.
 */
export declare function resolveFeishuCredentials(cfg?: FeishuConfig): {
    appId: string;
    appSecret: string;
    encryptKey?: string;
    verificationToken?: string;
    domain: FeishuDomain;
} | null;
/**
 * Resolve a complete Feishu account with merged config.
 */
export declare function resolveFeishuAccount(params: {
    cfg: ClawdbotConfig;
    accountId?: string | null;
}): ResolvedFeishuAccount;
/**
 * List all enabled and configured accounts.
 */
export declare function listEnabledFeishuAccounts(cfg: ClawdbotConfig): ResolvedFeishuAccount[];
//# sourceMappingURL=accounts.d.ts.map

--- dist/src/accounts.js (bundled) ---
import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "openclaw/plugin-sdk";
/**
 * List all configured account IDs from the accounts field.
 */
function listConfiguredAccountIds(cfg) {
    const accounts = cfg.channels?.feishu?.accounts;
    if (!accounts || typeof accounts !== "object") {
        return [];
    }
    return Object.keys(accounts).filter(Boolean);
}
/**
 * List all Feishu account IDs.
 * If no accounts are configured, returns [DEFAULT_ACCOUNT_ID] for backward compatibility.
 */
export function listFeishuAccountIds(cfg) {
    const ids = listConfiguredAccountIds(cfg);
    if (ids.length === 0) {
        // Backward compatibility: no accounts configured, use default
        return [DEFAULT_ACCOUNT_ID];
    }
    return [...ids].sort((a, b) => a.localeCompare(b));
}
/**
 * Resolve the default account ID.
 */
export function resolveDefaultFeishuAccountId(cfg) {
    const ids = listFeishuAccountIds(cfg);
    if (ids.includes(DEFAULT_ACCOUNT_ID)) {
        return DEFAULT_ACCOUNT_ID;
    }
    return ids[0] ?? DEFAULT_ACCOUNT_ID;
}
/**
 * Get the raw account-specific config.
 */
function resolveAccountConfig(cfg, accountId) {
    const accounts = cfg.channels?.feishu?.accounts;
    if (!accounts || typeof accounts !== "object") {
        return undefined;
    }
    return accounts[accountId];
}
/**
 * Merge top-level config with account-specific config.
 * Account-specific fields override top-level fields.
 */
function mergeFeishuAccountConfig(cfg, accountId) {
    const feishuCfg = cfg.channels?.feishu;
    // Extract base config (exclude accounts field to avoid recursion)
    const { accounts: _ignored, ...base } = feishuCfg ?? {};
    // Get account-specific overrides
    const account = resolveAccountConfig(cfg, accountId) ?? {};
    // Merge: account config overrides base config
    return { ...base, ...account };
}
/**
 * Resolve Feishu credentials from a config.
 */
export function resolveFeishuCredentials(cfg) {
    const appId = cfg?.appId?.trim(

--- dist/src/bitable.d.ts (bundled) ---
import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
import { createFeishuClient } from "./client.js";
export declare function registerFeishuBitableTools(api: OpenClawPluginApi): void;
/** Search records with filter conditions */
export declare function searchRecords(client: ReturnType<typeof createFeishuClient>, appToken: string, tableId: string, filter?: unknown, sort?: unknown, fieldNames?: string[], pageSize?: number, pageToken?: string): Promise<{
    records: {
        fields: Record<string, string | number | number | number | boolean | {
            text?: string;
            link?: string;
        } | {
            location?: string;
            pname?: string;
            cityname?: string;
            adname?: string;
            address?: string;
            name?: string;
            full_address?: string;
        } | Array<{
            id?: string;
            name?: string;
            avatar_url?: string;
        }> | Array<string> | Array<{
            id?: string;
            name?: string;
            en_name?: string;
            email?: string;
            avatar_url?: string;
        }> | Array<{
            file_token?: string;
            name?: string;
            type?: string;
            size?: number;
            url?: string;
            tmp_url?: string;
        }>>;
        record_id?: string | undefined;
        created_by?: {
            id?: string | undefined;
            name?: string | undefined;
            en_name?: string | undefined;
            email?: string | undefined;
            avatar_url?: string | undefined;
        } | undefined;
        created_time?: number | undefined;
        last_modified_