@m1heng-clawd/feishu 0.1.10 → 0.1.12

package/src/wiki-tools/actions.ts

@@ -0,0 +1,166 @@
+import { runWikiApiCall, type WikiClient } from "./common.js";
+import type { FeishuWikiParams } from "./schemas.js";
+
+type ObjType = "doc" | "sheet" | "mindnote" | "bitable" | "file" | "docx" | "slides";
+
+const WIKI_ACCESS_HINT =
+  "To grant wiki access: Open wiki space -> Settings -> Members -> Add the bot. " +
+  "See: https://open.feishu.cn/document/server-docs/docs/wiki-v2/wiki-qa#a40ad4ca";
+
+async function listSpaces(client: WikiClient) {
+  const res = await runWikiApiCall("wiki.space.list", () => client.wiki.space.list({}));
+  const spaces =
+    res.data?.items?.map((s) => ({
+      space_id: s.space_id,
+      name: s.name,
+      description: s.description,
+      visibility: s.visibility,
+    })) ?? [];
+
+  return {
+    spaces,
+    ...(spaces.length === 0 && { hint: WIKI_ACCESS_HINT }),
+  };
+}
+
+async function listNodes(client: WikiClient, spaceId: string, parentNodeToken?: string) {
+  const res = await runWikiApiCall("wiki.spaceNode.list", () =>
+    client.wiki.spaceNode.list({
+      path: { space_id: spaceId },
+      params: { parent_node_token: parentNodeToken },
+    }),
+  );
+
+  return {
+    nodes:
+      res.data?.items?.map((n) => ({
+        node_token: n.node_token,
+        obj_token: n.obj_token,
+        obj_type: n.obj_type,
+        title: n.title,
+        has_child: n.has_child,
+      })) ?? [],
+  };
+}
+
+async function getNode(client: WikiClient, token: string) {
+  const res = await runWikiApiCall("wiki.space.getNode", () =>
+    client.wiki.space.getNode({
+      params: { token },
+    }),
+  );
+
+  const node = res.data?.node;
+  return {
+    node_token: node?.node_token,
+    space_id: node?.space_id,
+    obj_token: node?.obj_token,
+    obj_type: node?.obj_type,
+    title: node?.title,
+    parent_node_token: node?.parent_node_token,
+    has_child: node?.has_child,
+    creator: node?.creator,
+    create_time: node?.node_create_time,
+  };
+}
+
+async function createNode(
+  client: WikiClient,
+  spaceId: string,
+  title: string,
+  objType?: string,
+  parentNodeToken?: string,
+) {
+  const res = await runWikiApiCall("wiki.spaceNode.create", () =>
+    client.wiki.spaceNode.create({
+      path: { space_id: spaceId },
+      data: {
+        obj_type: (objType as ObjType) || "docx",
+        node_type: "origin" as const,
+        title,
+        parent_node_token: parentNodeToken,
+      },
+    }),
+  );
+
+  const node = res.data?.node;
+  return {
+    node_token: node?.node_token,
+    obj_token: node?.obj_token,
+    obj_type: node?.obj_type,
+    title: node?.title,
+  };
+}
+
+async function moveNode(
+  client: WikiClient,
+  spaceId: string,
+  nodeToken: string,
+  targetSpaceId?: string,
+  targetParentToken?: string,
+) {
+  const res = await runWikiApiCall("wiki.spaceNode.move", () =>
+    client.wiki.spaceNode.move({
+      path: { space_id: spaceId, node_token: nodeToken },
+      data: {
+        target_space_id: targetSpaceId || spaceId,
+        target_parent_token: targetParentToken,
+      },
+    }),
+  );
+
+  return {
+    success: true,
+    node_token: res.data?.node?.node_token,
+  };
+}
+
+async function renameNode(
+  client: WikiClient,
+  spaceId: string,
+  nodeToken: string,
+  title: string,
+) {
+  await runWikiApiCall("wiki.spaceNode.updateTitle", () =>
+    client.wiki.spaceNode.updateTitle({
+      path: { space_id: spaceId, node_token: nodeToken },
+      data: { title },
+    }),
+  );
+
+  return {
+    success: true,
+    node_token: nodeToken,
+    title,
+  };
+}
+
+export async function runWikiAction(client: WikiClient, params: FeishuWikiParams) {
+  switch (params.action) {
+    case "spaces":
+      return listSpaces(client);
+    case "nodes":
+      return listNodes(client, params.space_id, params.parent_node_token);
+    case "get":
+      return getNode(client, params.token);
+    case "search":
+      return {
+        error:
+          "Search is not available. Use feishu_wiki with action: 'nodes' to browse or action: 'get' to lookup by token.",
+      };
+    case "create":
+      return createNode(client, params.space_id, params.title, params.obj_type, params.parent_node_token);
+    case "move":
+      return moveNode(
+        client,
+        params.space_id,
+        params.node_token,
+        params.target_space_id,
+        params.target_parent_token,
+      );
+    case "rename":
+      return renameNode(client, params.space_id, params.node_token, params.title);
+    default:
+      return { error: `Unknown action: ${(params as any).action}` };
+  }
+}

package/src/wiki-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 WikiClient = ReturnType<typeof createFeishuClient>;
+
+export { json, errorResult };
+
+export async function runWikiApiCall<T extends FeishuApiResponse>(
+  context: string,
+  fn: () => Promise<T>,
+): Promise<T> {
+  return runFeishuApiCall(context, fn);
+}

package/src/wiki-tools/index.ts

@@ -0,0 +1,2 @@
+export { registerFeishuWikiTools } from "./register.js";
+export { FeishuWikiSchema, type FeishuWikiParams } from "./schemas.js";

package/src/wiki-tools/register.ts

@@ -0,0 +1,66 @@
+import type { TSchema } from "@sinclair/typebox";
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import { hasFeishuToolEnabledForAnyAccount, withFeishuToolClient } from "../tools-common/tool-exec.js";
+import { runWikiAction } from "./actions.js";
+import { errorResult, json, type WikiClient } from "./common.js";
+import { FeishuWikiSchema, type FeishuWikiParams } from "./schemas.js";
+
+type WikiToolSpec<P> = {
+  name: string;
+  label: string;
+  description: string;
+  parameters: TSchema;
+  run: (client: WikiClient, params: P) => Promise<unknown>;
+};
+
+function registerWikiTool<P>(api: OpenClawPluginApi, spec: WikiToolSpec<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: "wiki",
+            run: async ({ client }) => json(await spec.run(client as WikiClient, params as P)),
+          });
+        } catch (err) {
+          return errorResult(err);
+        }
+      },
+    },
+    { name: spec.name },
+  );
+}
+
+export function registerFeishuWikiTools(api: OpenClawPluginApi) {
+  if (!api.config) {
+    api.logger.debug?.("feishu_wiki: No config available, skipping wiki tools");
+    return;
+  }
+
+  if (!hasFeishuToolEnabledForAnyAccount(api.config)) {
+    api.logger.debug?.("feishu_wiki: No Feishu accounts configured, skipping wiki tools");
+    return;
+  }
+
+  if (!hasFeishuToolEnabledForAnyAccount(api.config, "wiki")) {
+    api.logger.debug?.("feishu_wiki: wiki tool disabled in config");
+    return;
+  }
+
+  registerWikiTool<FeishuWikiParams>(api, {
+    name: "feishu_wiki",
+    label: "Feishu Wiki",
+    description:
+      "Feishu knowledge base operations. Actions: spaces, nodes, get, create, move, rename",
+    parameters: FeishuWikiSchema,
+    run: (client, params) => runWikiAction(client, params),
+  });
+
+  api.logger.debug?.("feishu_wiki: Registered feishu_wiki tool");
+}

package/src/bitable.ts

@@ -1 +0,0 @@
-export { registerFeishuBitableTools } from "./bitable-tools/register.js";

package/src/drive.ts

@@ -1,264 +0,0 @@
-import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
-import type * as Lark from "@larksuiteoapi/node-sdk";
-import { FeishuDriveSchema, type FeishuDriveParams } from "./drive-schema.js";
-import { hasFeishuToolEnabledForAnyAccount, withFeishuToolClient } from "./tools-common/tool-exec.js";
-import { writeDoc } from "./docx.js";
-
-// ============ Helpers ============
-
-function json(data: unknown) {
-  return {
-    content: [{ type: "text" as const, text: JSON.stringify(data, null, 2) }],
-    details: data,
-  };
-}
-
-// ============ Actions ============
-
-async function getRootFolderToken(client: Lark.Client): 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 (client as any).httpInstance.get(
-    `${domain}/open-apis/drive/explorer/v2/root_folder/meta`,
-  )) as { code: number; msg?: string; data?: { token?: string } };
-  if (res.code !== 0) throw new Error(res.msg ?? "Failed to get root folder");
-  const token = res.data?.token;
-  if (!token) throw new Error("Root folder token not found");
-  return token;
-}
-
-async function listFolder(client: Lark.Client, folderToken?: string) {
-  // Filter out invalid folder_token values (empty, "0", etc.)
-  const validFolderToken = folderToken && folderToken !== "0" ? folderToken : undefined;
-  const res = await client.drive.file.list({
-    params: validFolderToken ? { folder_token: validFolderToken } : {},
-  });
-  if (res.code !== 0) throw new Error(res.msg);
-
-  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: Lark.Client, fileToken: string, folderToken?: string) {
-  // Use list with folder_token to find file info
-  const res = await client.drive.file.list({
-    params: folderToken ? { folder_token: folderToken } : {},
-  });
-  if (res.code !== 0) throw new Error(res.msg);
-
-  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: Lark.Client, 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 client.drive.file.createFolder({
-    data: {
-      name,
-      folder_token: effectiveToken,
-    },
-  });
-  if (res.code !== 0) throw new Error(res.msg);
-
-  return {
-    token: res.data?.token,
-    url: res.data?.url,
-  };
-}
-
-async function moveFile(
-  client: Lark.Client,
-  fileToken: string,
-  type: string,
-  folderToken: string,
-) {
-  const res = await client.drive.file.move({
-    path: { file_token: fileToken },
-    data: {
-      type: type as "doc" | "docx" | "sheet" | "bitable" | "folder" | "file" | "mindnote" | "slides",
-      folder_token: folderToken,
-    },
-  });
-  if (res.code !== 0) throw new Error(res.msg);
-
-  return {
-    success: true,
-    task_id: res.data?.task_id,
-  };
-}
-
-async function deleteFile(client: Lark.Client, fileToken: string, type: string) {
-  const res = await client.drive.file.delete({
-    path: { file_token: fileToken },
-    params: {
-      type: type as
-        | "doc"
-        | "docx"
-        | "sheet"
-        | "bitable"
-        | "folder"
-        | "file"
-        | "mindnote"
-        | "slides"
-        | "shortcut",
-    },
-  });
-  if (res.code !== 0) throw new Error(res.msg);
-
-  return {
-    success: true,
-    task_id: res.data?.task_id,
-  };
-}
-
-// ============ Import Document Functions ============
-
-/**
- * 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: Lark.Client,
-  title: string,
-  content: string,
-  mediaMaxBytes: number,
-  folderToken?: string,
-  _docType?: "docx" | "doc",
-) {
-  // Step 1: Create empty document
-  const createRes = await client.docx.document.create({
-    data: { title, folder_token: folderToken },
-  });
-  
-  if (createRes.code !== 0) {
-    throw new Error(`Failed to create document: ${createRes.msg}`);
-  }
-
-  const docId = createRes.data?.document?.document_id;
-  if (!docId) {
-    throw new Error("Document created but no document_id returned");
-  }
-
-  // Step 2: Write markdown content to the document
-  // This ensures proper structure preservation using the writeDoc function
-  const writeResult = await writeDoc(client, docId, content, mediaMaxBytes);
-
-  return {
-    success: true,
-    document_id: docId,
-    title: title,
-    url: `https://feishu.cn/docx/${docId}`,
-    import_method: "create_and_write",
-    blocks_added: writeResult.blocks_added,
-    images_processed: writeResult.images_processed,
-    ...("warning" in writeResult && { warning: writeResult.warning }),
-  };
-}
-
-// ============ Tool Registration ============
-
-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;
-  }
-
-  api.registerTool(
-    {
-      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,
-      async execute(_toolCallId, params) {
-        const p = params as FeishuDriveParams;
-        try {
-          return await withFeishuToolClient({
-            api,
-            toolName: "feishu_drive",
-            requiredTool: "drive",
-            run: async ({ client, account }) => {
-              const mediaMaxBytes = (account.config?.mediaMaxMb ?? 30) * 1024 * 1024;
-              switch (p.action) {
-                case "list":
-                  return json(await listFolder(client, p.folder_token));
-                case "info":
-                  return json(await getFileInfo(client, p.file_token));
-                case "create_folder":
-                  return json(await createFolder(client, p.name, p.folder_token));
-                case "move":
-                  return json(await moveFile(client, p.file_token, p.type, p.folder_token));
-                case "delete":
-                  return json(await deleteFile(client, p.file_token, p.type));
-                case "import_document":
-                  return json(
-                    await importDocument(
-                      client,
-                      p.title,
-                      p.content,
-                      mediaMaxBytes,
-                      p.folder_token,
-                      (p as any).doc_type || "docx",
-                    ),
-                  );
-                default:
-                  return json({ error: `Unknown action: ${(p as any).action}` });
-              }
-            },
-          });
-        } catch (err) {
-          return json({ error: err instanceof Error ? err.message : String(err) });
-        }
-      },
-    },
-    { name: "feishu_drive" },
-  );
-
-  api.logger.debug?.("feishu_drive: Registered feishu_drive tool");
-}

package/src/perm.ts

@@ -1,165 +0,0 @@
-import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
-import type * as Lark from "@larksuiteoapi/node-sdk";
-import { FeishuPermSchema, type FeishuPermParams } from "./perm-schema.js";
-import { hasFeishuToolEnabledForAnyAccount, withFeishuToolClient } from "./tools-common/tool-exec.js";
-
-// ============ Helpers ============
-
-function json(data: unknown) {
-  return {
-    content: [{ type: "text" as const, text: JSON.stringify(data, null, 2) }],
-    details: data,
-  };
-}
-
-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";
-
-// ============ Actions ============
-
-async function listMembers(client: Lark.Client, token: string, type: string) {
-  const res = await client.drive.permissionMember.list({
-    path: { token },
-    params: { type: type as ListTokenType },
-  });
-  if (res.code !== 0) throw new Error(res.msg);
-
-  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: Lark.Client,
-  token: string,
-  type: string,
-  memberType: string,
-  memberId: string,
-  perm: string,
-) {
-  const res = await 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,
-    },
-  });
-  if (res.code !== 0) throw new Error(res.msg);
-
-  return {
-    success: true,
-    member: res.data?.member,
-  };
-}
-
-async function removeMember(
-  client: Lark.Client,
-  token: string,
-  type: string,
-  memberType: string,
-  memberId: string,
-) {
-  const res = await client.drive.permissionMember.delete({
-    path: { token, member_id: memberId },
-    params: { type: type as CreateTokenType, member_type: memberType as MemberType },
-  });
-  if (res.code !== 0) throw new Error(res.msg);
-
-  return {
-    success: true,
-  };
-}
-
-// ============ Tool Registration ============
-
-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;
-  }
-
-  api.registerTool(
-    {
-      name: "feishu_perm",
-      label: "Feishu Perm",
-      description: "Feishu permission management. Actions: list, add, remove",
-      parameters: FeishuPermSchema,
-      async execute(_toolCallId, params) {
-        const p = params as FeishuPermParams;
-        try {
-          return await withFeishuToolClient({
-            api,
-            toolName: "feishu_perm",
-            requiredTool: "perm",
-            run: async ({ client }) => {
-              switch (p.action) {
-                case "list":
-                  return json(await listMembers(client, p.token, p.type));
-                case "add":
-                  return json(
-                    await addMember(client, p.token, p.type, p.member_type, p.member_id, p.perm),
-                  );
-                case "remove":
-                  return json(await removeMember(client, p.token, p.type, p.member_type, p.member_id));
-                default:
-                  return json({ error: `Unknown action: ${(p as any).action}` });
-              }
-            },
-          });
-        } catch (err) {
-          return json({ error: err instanceof Error ? err.message : String(err) });
-        }
-      },
-    },
-    { name: "feishu_perm" },
-  );
-
-  api.logger.debug?.("feishu_perm: Registered feishu_perm tool");
-}

package/src/task.ts

@@ -1 +0,0 @@
-export { registerFeishuTaskTools } from "./task-tools/register.js";