@m1heng-clawd/feishu 0.1.11 → 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/docx.ts

@@ -1,276 +0,0 @@
-import { Type } from "@sinclair/typebox";
-import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
-import type * as Lark from "@larksuiteoapi/node-sdk";
-import { FeishuDocSchema, type FeishuDocParams } from "./doc-schema.js";
-import { appendDoc, createAndWriteDoc, createDoc, writeDoc } from "./doc-write-service.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,
-  };
-}
-
-const BLOCK_TYPE_NAMES: Record<number, string> = {
-  1: "Page",
-  2: "Text",
-  3: "Heading1",
-  4: "Heading2",
-  5: "Heading3",
-  12: "Bullet",
-  13: "Ordered",
-  14: "Code",
-  15: "Quote",
-  17: "Todo",
-  18: "Bitable",
-  21: "Diagram",
-  22: "Divider",
-  23: "File",
-  27: "Image",
-  30: "Sheet",
-  31: "Table",
-  32: "TableCell",
-};
-
-const STRUCTURED_BLOCK_TYPES = new Set([14, 18, 21, 23, 27, 30, 31, 32]);
-
-// ============ Actions ============
-
-async function readDoc(client: Lark.Client, docToken: string) {
-  const [contentRes, infoRes, blocksRes] = await Promise.all([
-    client.docx.document.rawContent({ path: { document_id: docToken } }),
-    client.docx.document.get({ path: { document_id: docToken } }),
-    client.docx.documentBlock.list({ path: { document_id: docToken } }),
-  ]);
-
-  if (contentRes.code !== 0) throw new Error(contentRes.msg);
-
-  const blocks = blocksRes.data?.items ?? [];
-  const blockCounts: Record<string, number> = {};
-  const structuredTypes: string[] = [];
-
-  for (const b of blocks) {
-    const type = b.block_type ?? 0;
-    const name = BLOCK_TYPE_NAMES[type] || `type_${type}`;
-    blockCounts[name] = (blockCounts[name] || 0) + 1;
-
-    if (STRUCTURED_BLOCK_TYPES.has(type) && !structuredTypes.includes(name)) {
-      structuredTypes.push(name);
-    }
-  }
-
-  let hint: string | undefined;
-  if (structuredTypes.length > 0) {
-    hint = `This document contains ${structuredTypes.join(", ")} which are NOT included in the plain text above. Use feishu_doc with action: "list_blocks" to get full content.`;
-  }
-
-  return {
-    title: infoRes.data?.document?.title,
-    content: contentRes.data?.content,
-    revision_id: infoRes.data?.document?.revision_id,
-    block_count: blocks.length,
-    block_types: blockCounts,
-    ...(hint && { hint }),
-  };
-}
-
-async function updateBlock(
-  client: Lark.Client,
-  docToken: string,
-  blockId: string,
-  content: string,
-) {
-  const blockInfo = await client.docx.documentBlock.get({
-    path: { document_id: docToken, block_id: blockId },
-  });
-  if (blockInfo.code !== 0) throw new Error(blockInfo.msg);
-
-  const res = await client.docx.documentBlock.patch({
-    path: { document_id: docToken, block_id: blockId },
-    data: {
-      update_text_elements: {
-        elements: [{ text_run: { content } }],
-      },
-    },
-  });
-  if (res.code !== 0) throw new Error(res.msg);
-
-  return { success: true, block_id: blockId };
-}
-
-async function deleteBlock(client: Lark.Client, docToken: string, blockId: string) {
-  const blockInfo = await client.docx.documentBlock.get({
-    path: { document_id: docToken, block_id: blockId },
-  });
-  if (blockInfo.code !== 0) throw new Error(blockInfo.msg);
-
-  const parentId = blockInfo.data?.block?.parent_id ?? docToken;
-
-  const children = await client.docx.documentBlockChildren.get({
-    path: { document_id: docToken, block_id: parentId },
-  });
-  if (children.code !== 0) throw new Error(children.msg);
-
-  const items = children.data?.items ?? [];
-  const index = items.findIndex((item: any) => item.block_id === blockId);
-  if (index === -1) throw new Error("Block not found");
-
-  const res = await client.docx.documentBlockChildren.batchDelete({
-    path: { document_id: docToken, block_id: parentId },
-    data: { start_index: index, end_index: index + 1 },
-  });
-  if (res.code !== 0) throw new Error(res.msg);
-
-  return { success: true, deleted_block_id: blockId };
-}
-
-async function listBlocks(client: Lark.Client, docToken: string) {
-  const res = await client.docx.documentBlock.list({
-    path: { document_id: docToken },
-  });
-  if (res.code !== 0) throw new Error(res.msg);
-
-  return {
-    blocks: res.data?.items ?? [],
-  };
-}
-
-async function getBlock(client: Lark.Client, docToken: string, blockId: string) {
-  const res = await client.docx.documentBlock.get({
-    path: { document_id: docToken, block_id: blockId },
-  });
-  if (res.code !== 0) throw new Error(res.msg);
-
-  return {
-    block: res.data?.block,
-  };
-}
-
-async function listAppScopes(client: Lark.Client) {
-  const res = await client.application.scope.list({});
-  if (res.code !== 0) throw new Error(res.msg);
-
-  const scopes = res.data?.scopes ?? [];
-  const granted = scopes.filter((s) => s.grant_status === 1);
-  const pending = scopes.filter((s) => s.grant_status !== 1);
-
-  return {
-    granted: granted.map((s) => ({ name: s.scope_name, type: s.scope_type })),
-    pending: pending.map((s) => ({ name: s.scope_name, type: s.scope_type })),
-    summary: `${granted.length} granted, ${pending.length} pending`,
-  };
-}
-
-// ============ Tool Registration ============
-
-export function registerFeishuDocTools(api: OpenClawPluginApi) {
-  if (!api.config) {
-    api.logger.debug?.("feishu_doc: No config available, skipping doc tools");
-    return;
-  }
-
-  if (!hasFeishuToolEnabledForAnyAccount(api.config)) {
-    api.logger.debug?.("feishu_doc: No Feishu accounts configured, skipping doc tools");
-    return;
-  }
-
-  // Registration happens once; account selection happens per execute() call.
-  const docEnabled = hasFeishuToolEnabledForAnyAccount(api.config, "doc");
-  const scopesEnabled = hasFeishuToolEnabledForAnyAccount(api.config, "scopes");
-  const registered: string[] = [];
-
-  // Main document tool with action-based dispatch
-  if (docEnabled) {
-    api.registerTool(
-      {
-        name: "feishu_doc",
-        label: "Feishu Doc",
-        description:
-          'Feishu document operations. Actions: read, write, append, create, create_and_write, list_blocks, get_block, update_block, delete_block. Use "create_and_write" for atomic create + content write.',
-        parameters: FeishuDocSchema,
-        async execute(_toolCallId, params) {
-          const p = params as FeishuDocParams;
-          try {
-            return await withFeishuToolClient({
-              api,
-              toolName: "feishu_doc",
-              requiredTool: "doc",
-              run: async ({ client, account }) => {
-                const mediaMaxBytes = (account.config?.mediaMaxMb ?? 30) * 1024 * 1024;
-                switch (p.action) {
-                  case "read":
-                    return json(await readDoc(client, p.doc_token));
-                  case "write":
-                    return json(await writeDoc(client, p.doc_token, p.content, mediaMaxBytes));
-                  case "append":
-                    return json(await appendDoc(client, p.doc_token, p.content, mediaMaxBytes));
-                  case "create":
-                    return json(await createDoc(client, p.title, p.folder_token));
-                  case "create_and_write":
-                    return json(
-                      await createAndWriteDoc(
-                        client,
-                        p.title,
-                        p.content,
-                        mediaMaxBytes,
-                        p.folder_token,
-                      ),
-                    );
-                  case "list_blocks":
-                    return json(await listBlocks(client, p.doc_token));
-                  case "get_block":
-                    return json(await getBlock(client, p.doc_token, p.block_id));
-                  case "update_block":
-                    return json(await updateBlock(client, p.doc_token, p.block_id, p.content));
-                  case "delete_block":
-                    return json(await deleteBlock(client, p.doc_token, p.block_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_doc" },
-    );
-    registered.push("feishu_doc");
-  }
-
-  // Keep feishu_app_scopes as independent tool
-  if (scopesEnabled) {
-    api.registerTool(
-      {
-        name: "feishu_app_scopes",
-        label: "Feishu App Scopes",
-        description:
-          "List current app permissions (scopes). Use to debug permission issues or check available capabilities.",
-        parameters: Type.Object({}),
-        async execute() {
-          try {
-            const result = await withFeishuToolClient({
-              api,
-              toolName: "feishu_app_scopes",
-              requiredTool: "scopes",
-              run: async ({ client }) => listAppScopes(client),
-            });
-            return json(result);
-          } catch (err) {
-            return json({ error: err instanceof Error ? err.message : String(err) });
-          }
-        },
-      },
-      { name: "feishu_app_scopes" },
-    );
-    registered.push("feishu_app_scopes");
-  }
-
-  if (registered.length > 0) {
-    api.logger.debug?.(`feishu_doc: Registered ${registered.join(", ")}`);
-  }
-}