@m1heng-clawd/feishu 0.1.10 → 0.1.12

package/src/drive-tools/actions.ts

@@ -0,0 +1,182 @@
+import { createAndWriteDoc } from "../doc-write-service.js";
+import { runDriveApiCall, type DriveClient } from "./common.js";
+import type { FeishuDriveParams } from "./schemas.js";
+
+type DriveMoveType = "doc" | "docx" | "sheet" | "bitable" | "folder" | "file" | "mindnote" | "slides";
+type DriveDeleteType = DriveMoveType | "shortcut";
+
+async function getRootFolderToken(client: DriveClient): Promise<string> {
+  // Use generic HTTP client to call the root folder meta API
+  // as it's not directly exposed in the SDK.
+  const domain = (client as any).domain ?? "https://open.feishu.cn";
+  const res = await runDriveApiCall("drive.explorer.v2.root_folder.meta", () =>
+    (client as any).httpInstance.get(`${domain}/open-apis/drive/explorer/v2/root_folder/meta`) as Promise<{
+      code?: number;
+      msg?: string;
+      data?: { token?: string };
+    }>,
+  );
+  const token = res.data?.token;
+  if (!token) throw new Error("Root folder token not found");
+  return token;
+}
+
+async function listFolder(client: DriveClient, folderToken?: string) {
+  // Filter out invalid folder_token values (empty, "0", etc.)
+  const validFolderToken = folderToken && folderToken !== "0" ? folderToken : undefined;
+  const res = await runDriveApiCall("drive.file.list", () =>
+    client.drive.file.list({
+      params: validFolderToken ? { folder_token: validFolderToken } : {},
+    }),
+  );
+
+  return {
+    files:
+      res.data?.files?.map((f) => ({
+        token: f.token,
+        name: f.name,
+        type: f.type,
+        url: f.url,
+        created_time: f.created_time,
+        modified_time: f.modified_time,
+        owner_id: f.owner_id,
+      })) ?? [],
+    next_page_token: res.data?.next_page_token,
+  };
+}
+
+async function getFileInfo(client: DriveClient, fileToken: string, folderToken?: string) {
+  // Use list with folder_token to find file info.
+  const res = await runDriveApiCall("drive.file.list", () =>
+    client.drive.file.list({
+      params: folderToken ? { folder_token: folderToken } : {},
+    }),
+  );
+
+  const file = res.data?.files?.find((f) => f.token === fileToken);
+  if (!file) {
+    throw new Error(`File not found: ${fileToken}`);
+  }
+
+  return {
+    token: file.token,
+    name: file.name,
+    type: file.type,
+    url: file.url,
+    created_time: file.created_time,
+    modified_time: file.modified_time,
+    owner_id: file.owner_id,
+  };
+}
+
+async function createFolder(client: DriveClient, name: string, folderToken?: string) {
+  // Feishu supports using folder_token="0" as the root folder.
+  // We try to resolve the real root token (explorer API), but fall back to "0"
+  // because some tenants/apps return 400 for that explorer endpoint.
+  let effectiveToken = folderToken && folderToken !== "0" ? folderToken : "0";
+  if (effectiveToken === "0") {
+    try {
+      effectiveToken = await getRootFolderToken(client);
+    } catch {
+      // ignore and keep "0"
+    }
+  }
+
+  const res = await runDriveApiCall("drive.file.createFolder", () =>
+    client.drive.file.createFolder({
+      data: {
+        name,
+        folder_token: effectiveToken,
+      },
+    }),
+  );
+
+  return {
+    token: res.data?.token,
+    url: res.data?.url,
+  };
+}
+
+async function moveFile(
+  client: DriveClient,
+  fileToken: string,
+  type: string,
+  folderToken: string,
+) {
+  const res = await runDriveApiCall("drive.file.move", () =>
+    client.drive.file.move({
+      path: { file_token: fileToken },
+      data: {
+        type: type as DriveMoveType,
+        folder_token: folderToken,
+      },
+    }),
+  );
+
+  return {
+    success: true,
+    task_id: res.data?.task_id,
+  };
+}
+
+async function deleteFile(client: DriveClient, fileToken: string, type: string) {
+  const res = await runDriveApiCall("drive.file.delete", () =>
+    client.drive.file.delete({
+      path: { file_token: fileToken },
+      params: {
+        type: type as DriveDeleteType,
+      },
+    }),
+  );
+
+  return {
+    success: true,
+    task_id: res.data?.task_id,
+  };
+}
+
+/**
+ * Import markdown content as a new Feishu document.
+ * Uses create + write approach for reliable content import.
+ * Note: docType parameter is accepted for API compatibility but docx is always used.
+ */
+async function importDocument(
+  client: DriveClient,
+  title: string,
+  content: string,
+  mediaMaxBytes: number,
+  folderToken?: string,
+  _docType?: "docx" | "doc",
+) {
+  return createAndWriteDoc(client, title, content, mediaMaxBytes, folderToken);
+}
+
+export async function runDriveAction(
+  client: DriveClient,
+  params: FeishuDriveParams,
+  mediaMaxBytes: number,
+) {
+  switch (params.action) {
+    case "list":
+      return listFolder(client, params.folder_token);
+    case "info":
+      return getFileInfo(client, params.file_token);
+    case "create_folder":
+      return createFolder(client, params.name, params.folder_token);
+    case "move":
+      return moveFile(client, params.file_token, params.type, params.folder_token);
+    case "delete":
+      return deleteFile(client, params.file_token, params.type);
+    case "import_document":
+      return importDocument(
+        client,
+        params.title,
+        params.content,
+        mediaMaxBytes,
+        params.folder_token,
+        params.doc_type || "docx",
+      );
+    default:
+      return { error: `Unknown action: ${(params as any).action}` };
+  }
+}

package/src/drive-tools/common.ts

@@ -0,0 +1,18 @@
+import { createFeishuClient } from "../client.js";
+import {
+  errorResult,
+  json,
+  runFeishuApiCall,
+  type FeishuApiResponse,
+} from "../tools-common/feishu-api.js";
+
+export type DriveClient = ReturnType<typeof createFeishuClient>;
+
+export { json, errorResult };
+
+export async function runDriveApiCall<T extends FeishuApiResponse>(
+  context: string,
+  fn: () => Promise<T>,
+): Promise<T> {
+  return runFeishuApiCall(context, fn);
+}

package/src/drive-tools/index.ts

@@ -0,0 +1,2 @@
+export { registerFeishuDriveTools } from "./register.js";
+export { FeishuDriveSchema, type FeishuDriveParams } from "./schemas.js";

package/src/drive-tools/register.ts

@@ -0,0 +1,71 @@
+import type { TSchema } from "@sinclair/typebox";
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import type { ResolvedFeishuAccount } from "../types.js";
+import { hasFeishuToolEnabledForAnyAccount, withFeishuToolClient } from "../tools-common/tool-exec.js";
+import { runDriveAction } from "./actions.js";
+import { errorResult, json, type DriveClient } from "./common.js";
+import { FeishuDriveSchema, type FeishuDriveParams } from "./schemas.js";
+
+type DriveToolSpec<P> = {
+  name: string;
+  label: string;
+  description: string;
+  parameters: TSchema;
+  run: (args: { client: DriveClient; account: ResolvedFeishuAccount }, params: P) => Promise<unknown>;
+};
+
+function registerDriveTool<P>(api: OpenClawPluginApi, spec: DriveToolSpec<P>) {
+  api.registerTool(
+    {
+      name: spec.name,
+      label: spec.label,
+      description: spec.description,
+      parameters: spec.parameters,
+      async execute(_toolCallId, params) {
+        try {
+          return await withFeishuToolClient({
+            api,
+            toolName: spec.name,
+            requiredTool: "drive",
+            run: async ({ client, account }) =>
+              json(await spec.run({ client: client as DriveClient, account }, params as P)),
+          });
+        } catch (err) {
+          return errorResult(err);
+        }
+      },
+    },
+    { name: spec.name },
+  );
+}
+
+export function registerFeishuDriveTools(api: OpenClawPluginApi) {
+  if (!api.config) {
+    api.logger.debug?.("feishu_drive: No config available, skipping drive tools");
+    return;
+  }
+
+  if (!hasFeishuToolEnabledForAnyAccount(api.config)) {
+    api.logger.debug?.("feishu_drive: No Feishu accounts configured, skipping drive tools");
+    return;
+  }
+
+  if (!hasFeishuToolEnabledForAnyAccount(api.config, "drive")) {
+    api.logger.debug?.("feishu_drive: drive tool disabled in config");
+    return;
+  }
+
+  registerDriveTool<FeishuDriveParams>(api, {
+    name: "feishu_drive",
+    label: "Feishu Drive",
+    description:
+      "Feishu cloud storage operations. Actions: list, info, create_folder, move, delete, import_document. Use 'import_document' to create documents from Markdown with better structure preservation than block-by-block writing.",
+    parameters: FeishuDriveSchema,
+    run: async ({ client, account }, params) => {
+      const mediaMaxBytes = (account.config?.mediaMaxMb ?? 30) * 1024 * 1024;
+      return runDriveAction(client, params, mediaMaxBytes);
+    },
+  });
+
+  api.logger.debug?.("feishu_drive: Registered feishu_drive tool");
+}

package/src/{drive-schema.ts → drive-tools/schemas.ts}

@@ -52,7 +52,8 @@ export const FeishuDriveSchema = Type.Union([
       description: "Document title",
     }),
     content: Type.String({
-      description: "Markdown content to import. Supports full Markdown syntax including tables, lists, code blocks, etc.",
+      description:
+        "Markdown content to import. Supports full Markdown syntax including tables, lists, code blocks, etc.",
     }),
     folder_token: Type.Optional(
       Type.String({

package/src/media.ts

@@ -354,7 +354,8 @@ export async function sendFileFeishu(params: {
   cfg: ClawdbotConfig;
   to: string;
   fileKey: string;
-  msgType?: "file" | "media";
+  /** Use "audio" for audio, "media" for video, "file" for documents */
+  msgType?: "file" | "audio" | "media";
   replyToMessageId?: string;
   accountId?: string;
 }): Promise<SendMediaResult> {
@@ -495,12 +496,13 @@ export async function sendMediaFeishu(params: {
       fileType,
       accountId,
     });
-    const isMedia = fileType === "mp4" || fileType === "opus";
+    // Feishu requires msg_type "audio" for audio, "media" for video, "file" for documents
+    const msgType = fileType === "opus" ? "audio" : fileType === "mp4" ? "media" : "file";
     return sendFileFeishu({
       cfg,
       to,
       fileKey,
-      msgType: isMedia ? "media" : "file",
+      msgType,
       replyToMessageId,
       accountId,
     });

package/src/onboarding.ts

@@ -23,6 +23,7 @@ import { probeFeishu } from "./probe.js";
 import type { FeishuConfig } from "./types.js";
 
 const channel = "feishu" as const;
+let onboardingDmPolicyAccountId: string | undefined;
 
 function resolveOnboardingAccountId(cfg: ClawdbotConfig, accountId?: string | null): string {
   const raw = accountId?.trim();
@@ -32,6 +33,10 @@ function resolveOnboardingAccountId(cfg: ClawdbotConfig, accountId?: string | nu
   return resolveDefaultFeishuAccountId(cfg);
 }
 
+function resolveDmPolicyAccountId(cfg: ClawdbotConfig, accountId?: string | null): string {
+  return resolveOnboardingAccountId(cfg, accountId ?? onboardingDmPolicyAccountId);
+}
+
 function upsertFeishuAccountConfig(
   cfg: ClawdbotConfig,
   accountId: string,
@@ -79,7 +84,7 @@ function setFeishuDmPolicy(
   dmPolicy: DmPolicy,
   accountId?: string,
 ): ClawdbotConfig {
-  const resolvedAccountId = resolveOnboardingAccountId(cfg, accountId);
+  const resolvedAccountId = resolveDmPolicyAccountId(cfg, accountId);
   const account = resolveFeishuAccount({ cfg, accountId: resolvedAccountId });
   // Feishu channel config does not support "disabled" as a dmPolicy value.
   const effectiveDmPolicy = dmPolicy === "disabled" ? "pairing" : dmPolicy;
@@ -110,7 +115,7 @@ async function promptFeishuAllowFrom(params: {
   prompter: WizardPrompter;
   accountId?: string;
 }): Promise<ClawdbotConfig> {
-  const accountId = resolveOnboardingAccountId(params.cfg, params.accountId);
+  const accountId = resolveDmPolicyAccountId(params.cfg, params.accountId);
   const existing = resolveFeishuAccount({ cfg: params.cfg, accountId }).config.allowFrom ?? [];
   const accountLabel = accountId === DEFAULT_ACCOUNT_ID ? "default" : accountId;
   await params.prompter.note(
@@ -189,10 +194,10 @@ const dmPolicy: ChannelOnboardingDmPolicy = {
   policyKey: "channels.feishu.dmPolicy",
   allowFromKey: "channels.feishu.allowFrom",
   getCurrent: (cfg) => {
-    const accountId = resolveDefaultFeishuAccountId(cfg);
+    const accountId = resolveDmPolicyAccountId(cfg);
     return resolveFeishuAccount({ cfg, accountId }).config.dmPolicy ?? "pairing";
   },
-  setPolicy: (cfg, policy, accountId?: string) => setFeishuDmPolicy(cfg, policy, accountId),
+  setPolicy: (cfg, policy) => setFeishuDmPolicy(cfg, policy, onboardingDmPolicyAccountId),
   promptAllowFrom: promptFeishuAllowFrom,
 };
 
@@ -260,6 +265,7 @@ export const feishuOnboardingAdapter: ChannelOnboardingAdapter = {
         defaultAccountId: defaultFeishuAccountId,
       });
     }
+    onboardingDmPolicyAccountId = feishuAccountId;
     const accountLabel = feishuAccountId === DEFAULT_ACCOUNT_ID ? "default" : feishuAccountId;
     const currentAccount = resolveFeishuAccount({ cfg, accountId: feishuAccountId });
     const resolved = resolveFeishuCredentials(currentAccount.config);
@@ -429,6 +435,10 @@ export const feishuOnboardingAdapter: ChannelOnboardingAdapter = {
 
   dmPolicy,
 
+  onAccountRecorded: (accountId) => {
+    onboardingDmPolicyAccountId = normalizeAccountId(accountId);
+  },
+
   disable: (cfg) => ({
     ...cfg,
     channels: {

package/src/perm-tools/actions.ts

@@ -0,0 +1,111 @@
+import { runPermApiCall, type PermClient } from "./common.js";
+import type { FeishuPermParams } from "./schemas.js";
+
+type ListTokenType =
+  | "doc"
+  | "sheet"
+  | "file"
+  | "wiki"
+  | "bitable"
+  | "docx"
+  | "mindnote"
+  | "minutes"
+  | "slides";
+type CreateTokenType =
+  | "doc"
+  | "sheet"
+  | "file"
+  | "wiki"
+  | "bitable"
+  | "docx"
+  | "folder"
+  | "mindnote"
+  | "minutes"
+  | "slides";
+type MemberType =
+  | "email"
+  | "openid"
+  | "unionid"
+  | "openchat"
+  | "opendepartmentid"
+  | "userid"
+  | "groupid"
+  | "wikispaceid";
+type PermType = "view" | "edit" | "full_access";
+
+async function listMembers(client: PermClient, token: string, type: string) {
+  const res = await runPermApiCall("drive.permissionMember.list", () =>
+    client.drive.permissionMember.list({
+      path: { token },
+      params: { type: type as ListTokenType },
+    }),
+  );
+
+  return {
+    members:
+      res.data?.items?.map((m) => ({
+        member_type: m.member_type,
+        member_id: m.member_id,
+        perm: m.perm,
+        name: m.name,
+      })) ?? [],
+  };
+}
+
+async function addMember(
+  client: PermClient,
+  token: string,
+  type: string,
+  memberType: string,
+  memberId: string,
+  perm: string,
+) {
+  const res = await runPermApiCall("drive.permissionMember.create", () =>
+    client.drive.permissionMember.create({
+      path: { token },
+      params: { type: type as CreateTokenType, need_notification: false },
+      data: {
+        member_type: memberType as MemberType,
+        member_id: memberId,
+        perm: perm as PermType,
+      },
+    }),
+  );
+
+  return {
+    success: true,
+    member: res.data?.member,
+  };
+}
+
+async function removeMember(
+  client: PermClient,
+  token: string,
+  type: string,
+  memberType: string,
+  memberId: string,
+) {
+  await runPermApiCall("drive.permissionMember.delete", () =>
+    client.drive.permissionMember.delete({
+      path: { token, member_id: memberId },
+      params: { type: type as CreateTokenType, member_type: memberType as MemberType },
+    }),
+  );
+
+  return {
+    success: true,
+  };
+}
+
+export async function runPermAction(client: PermClient, params: FeishuPermParams) {
+  switch (params.action) {
+    case "list":
+      return listMembers(client, params.token, params.type);
+    case "add":
+      return addMember(client, params.token, params.type, params.member_type, params.member_id, params.perm);
+    case "remove":
+      return removeMember(client, params.token, params.type, params.member_type, params.member_id);
+    default:
+      return { error: `Unknown action: ${(params as any).action}` };
+  }
+}

package/src/perm-tools/common.ts

@@ -0,0 +1,18 @@
+import { createFeishuClient } from "../client.js";
+import {
+  errorResult,
+  json,
+  runFeishuApiCall,
+  type FeishuApiResponse,
+} from "../tools-common/feishu-api.js";
+
+export type PermClient = ReturnType<typeof createFeishuClient>;
+
+export { json, errorResult };
+
+export async function runPermApiCall<T extends FeishuApiResponse>(
+  context: string,
+  fn: () => Promise<T>,
+): Promise<T> {
+  return runFeishuApiCall(context, fn);
+}

package/src/perm-tools/index.ts

@@ -0,0 +1,2 @@
+export { registerFeishuPermTools } from "./register.js";
+export { FeishuPermSchema, type FeishuPermParams } from "./schemas.js";

package/src/perm-tools/register.ts

@@ -0,0 +1,65 @@
+import type { TSchema } from "@sinclair/typebox";
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import { hasFeishuToolEnabledForAnyAccount, withFeishuToolClient } from "../tools-common/tool-exec.js";
+import { runPermAction } from "./actions.js";
+import { errorResult, json, type PermClient } from "./common.js";
+import { FeishuPermSchema, type FeishuPermParams } from "./schemas.js";
+
+type PermToolSpec<P> = {
+  name: string;
+  label: string;
+  description: string;
+  parameters: TSchema;
+  run: (client: PermClient, params: P) => Promise<unknown>;
+};
+
+function registerPermTool<P>(api: OpenClawPluginApi, spec: PermToolSpec<P>) {
+  api.registerTool(
+    {
+      name: spec.name,
+      label: spec.label,
+      description: spec.description,
+      parameters: spec.parameters,
+      async execute(_toolCallId, params) {
+        try {
+          return await withFeishuToolClient({
+            api,
+            toolName: spec.name,
+            requiredTool: "perm",
+            run: async ({ client }) => json(await spec.run(client as PermClient, params as P)),
+          });
+        } catch (err) {
+          return errorResult(err);
+        }
+      },
+    },
+    { name: spec.name },
+  );
+}
+
+export function registerFeishuPermTools(api: OpenClawPluginApi) {
+  if (!api.config) {
+    api.logger.debug?.("feishu_perm: No config available, skipping perm tools");
+    return;
+  }
+
+  if (!hasFeishuToolEnabledForAnyAccount(api.config)) {
+    api.logger.debug?.("feishu_perm: No Feishu accounts configured, skipping perm tools");
+    return;
+  }
+
+  if (!hasFeishuToolEnabledForAnyAccount(api.config, "perm")) {
+    api.logger.debug?.("feishu_perm: perm tool disabled in config (default: false)");
+    return;
+  }
+
+  registerPermTool<FeishuPermParams>(api, {
+    name: "feishu_perm",
+    label: "Feishu Perm",
+    description: "Feishu permission management. Actions: list, add, remove",
+    parameters: FeishuPermSchema,
+    run: (client, params) => runPermAction(client, params),
+  });
+
+  api.logger.debug?.("feishu_perm: Registered feishu_perm tool");
+}

package/src/policy.ts

@@ -1,6 +1,8 @@
 import type { ChannelGroupContext, GroupToolPolicyConfig } from "openclaw/plugin-sdk";
 import type { FeishuConfig, FeishuGroupConfig } from "./types.js";
 
+export type FeishuGroupCommandMentionBypass = "never" | "single_bot" | "always";
+
 export type FeishuAllowlistMatch = {
   allowed: boolean;
   matchKey?: string;
@@ -90,3 +92,14 @@ export function resolveFeishuReplyPolicy(params: {
 
   return { requireMention };
 }
+
+export function resolveFeishuGroupCommandMentionBypass(params: {
+  globalConfig?: FeishuConfig;
+  groupConfig?: FeishuGroupConfig;
+}): FeishuGroupCommandMentionBypass {
+  return (
+    params.groupConfig?.groupCommandMentionBypass ??
+    params.globalConfig?.groupCommandMentionBypass ??
+    "single_bot"
+  );
+}

package/src/reply-dispatcher.ts

@@ -9,6 +9,7 @@ import {
 import { resolveFeishuAccount } from "./accounts.js";
 import { createFeishuClient } from "./client.js";
 import { buildMentionedCardContent, type MentionTarget } from "./mention.js";
+import { normalizeFeishuMarkdownLinks } from "./text/markdown-links.js";
 import { getFeishuRuntime } from "./runtime.js";
 import { sendMarkdownCardFeishu, sendMessageFeishu } from "./send.js";
 import { FeishuStreamingSession } from "./streaming-card.js";
@@ -120,7 +121,7 @@ export function createFeishuReplyDispatcher(params: CreateFeishuReplyDispatcherP
       if (mentionTargets?.length) {
         text = buildMentionedCardContent(mentionTargets, text);
       }
-      await streaming.close(text);
+      await streaming.close(normalizeFeishuMarkdownLinks(text));
     }
     streaming = null;
     streamingStartPromise = null;
@@ -217,11 +218,12 @@ export function createFeishuReplyDispatcher(params: CreateFeishuReplyDispatcherP
       onModelSelected: prefixContext.onModelSelected,
       onPartialReply: streamingEnabled
         ? (payload: ReplyPayload) => {
-            if (!payload.text || payload.text === lastPartial) {
+            const partialText = normalizeFeishuMarkdownLinks(payload.text ?? "");
+            if (!partialText || partialText === lastPartial) {
               return;
             }
-            lastPartial = payload.text;
-            streamText = payload.text;
+            lastPartial = partialText;
+            streamText = partialText;
             partialUpdateQueue = partialUpdateQueue.then(async () => {
               if (streamingStartPromise) {
                 await streamingStartPromise;