@max1874/feishu 0.1.7 → 0.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@max1874/feishu",
-  "version": "0.1.7",
+  "version": "0.2.1",
   "type": "module",
   "description": "OpenClaw Feishu/Lark channel plugin",
   "license": "MIT",

package/src/docx.ts

@@ -232,6 +232,101 @@ async function processImages(
   return processed;
 }
 
+// ============ Wiki Functions ============
+
+type WikiNodeInfo = {
+  node_token: string;
+  obj_token: string;
+  obj_type: string;
+  space_id: string;
+  title?: string;
+  parent_node_token?: string;
+  node_type?: string;
+  origin_space_id?: string;
+};
+
+/** Get wiki node info by token (from /wiki/XXX URL) */
+async function getWikiNode(client: Lark.Client, wikiToken: string): Promise<WikiNodeInfo> {
+  const res = await client.wiki.space.getNode({
+    params: { token: wikiToken },
+  });
+  if (res.code !== 0) throw new Error(res.msg);
+  const node = res.data?.node;
+  if (!node) throw new Error("Wiki node not found");
+  return {
+    node_token: node.node_token ?? wikiToken,
+    obj_token: node.obj_token ?? "",
+    obj_type: node.obj_type ?? "",
+    space_id: node.space_id ?? "",
+    title: node.title,
+    parent_node_token: node.parent_node_token,
+    node_type: node.node_type,
+    origin_space_id: node.origin_space_id,
+  };
+}
+
+/** Read wiki page content (resolves to underlying docx) */
+async function readWiki(client: Lark.Client, wikiToken: string) {
+  // 1. Get wiki node info to find the underlying document
+  const node = await getWikiNode(client, wikiToken);
+
+  if (node.obj_type !== "docx") {
+    return {
+      node,
+      error: `Wiki node is of type '${node.obj_type}', only 'docx' is supported for reading content. Use the obj_token with the appropriate API.`,
+    };
+  }
+
+  // 2. Read the underlying docx content
+  const docContent = await readDoc(client, node.obj_token);
+
+  return {
+    wiki_token: wikiToken,
+    title: node.title,
+    obj_type: node.obj_type,
+    obj_token: node.obj_token,
+    space_id: node.space_id,
+    ...docContent,
+  };
+}
+
+/** List wiki spaces */
+async function listWikiSpaces(client: Lark.Client) {
+  const res = await client.wiki.space.list({});
+  if (res.code !== 0) throw new Error(res.msg);
+
+  return {
+    spaces:
+      res.data?.items?.map((s) => ({
+        space_id: s.space_id,
+        name: s.name,
+        description: s.description,
+        type: s.space_type === "team" ? "team" : "personal",
+        visibility: s.visibility,
+      })) ?? [],
+  };
+}
+
+/** List wiki nodes under a parent */
+async function listWikiNodes(client: Lark.Client, spaceId: string, parentNodeToken?: string) {
+  const res = await client.wiki.spaceNode.list({
+    path: { space_id: spaceId },
+    params: { parent_node_token: parentNodeToken },
+  });
+  if (res.code !== 0) throw new Error(res.msg);
+
+  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,
+      })) ?? [],
+  };
+}
+
 // ============ Actions ============
 
 // Block types that are NOT included in rawContent (plain text) output
@@ -278,16 +373,45 @@ async function readDoc(client: Lark.Client, docToken: string) {
   };
 }
 
-async function createDoc(client: Lark.Client, title: string, folderToken?: string) {
+/** Set document permission to allow tenant members to edit */
+async function setDocPermissionTenantEditable(client: Lark.Client, docToken: string) {
+  const res = await client.drive.permissionPublic.patch({
+    path: { token: docToken },
+    params: { type: "docx" },
+    data: {
+      link_share_entity: "tenant_editable",
+      share_entity: "same_tenant",
+    },
+  });
+  if (res.code !== 0) throw new Error(res.msg);
+  return res.data;
+}
+
+export type DocPermission = "private" | "tenant_editable";
+
+async function createDoc(
+  client: Lark.Client,
+  title: string,
+  folderToken?: string,
+  permission?: DocPermission,
+) {
   const res = await client.docx.document.create({
     data: { title, folder_token: folderToken },
   });
   if (res.code !== 0) throw new Error(res.msg);
   const doc = res.data?.document;
+  const docId = doc?.document_id;
+
+  // Set permission if requested
+  if (permission === "tenant_editable" && docId) {
+    await setDocPermissionTenantEditable(client, docId);
+  }
+
   return {
-    document_id: doc?.document_id,
+    document_id: docId,
     title: doc?.title,
-    url: `https://feishu.cn/docx/${doc?.document_id}`,
+    url: `https://feishu.cn/docx/${docId}`,
+    permission: permission ?? "private",
   };
 }
 
@@ -455,6 +579,12 @@ const DocTokenSchema = Type.Object({
 const CreateDocSchema = Type.Object({
   title: Type.String({ description: "Document title" }),
   folder_token: Type.Optional(Type.String({ description: "Target folder token (optional)" })),
+  permission: Type.Optional(
+    Type.Union([Type.Literal("private"), Type.Literal("tenant_editable")], {
+      description:
+        "Document permission: 'private' (default) or 'tenant_editable' (organization members can edit via link)",
+    }),
+  ),
 });
 
 const WriteDocSchema = Type.Object({
@@ -489,6 +619,25 @@ const FolderTokenSchema = Type.Object({
   folder_token: Type.String({ description: "Folder token" }),
 });
 
+const SetPermissionSchema = Type.Object({
+  doc_token: Type.String({ description: "Document token" }),
+  permission: Type.Union([Type.Literal("private"), Type.Literal("tenant_editable")], {
+    description: "'private' or 'tenant_editable' (organization members can edit via link)",
+  }),
+});
+
+// Wiki Schemas
+const WikiTokenSchema = Type.Object({
+  wiki_token: Type.String({ description: "Wiki token (extract from URL /wiki/XXX)" }),
+});
+
+const WikiSpaceIdSchema = Type.Object({
+  space_id: Type.String({ description: "Wiki space ID" }),
+  parent_node_token: Type.Optional(
+    Type.String({ description: "Parent node token (optional, for listing children)" }),
+  ),
+});
+
 // ============ Tool Registration ============
 
 export function registerFeishuDocTools(api: OpenClawPluginApi) {
@@ -525,12 +674,17 @@ export function registerFeishuDocTools(api: OpenClawPluginApi) {
     {
       name: "feishu_doc_create",
       label: "Feishu Doc Create",
-      description: "Create a new empty Feishu document",
+      description:
+        "Create a new empty Feishu document. Use permission='tenant_editable' to allow organization members to edit via link.",
       parameters: CreateDocSchema,
       async execute(_toolCallId, params) {
-        const { title, folder_token } = params as { title: string; folder_token?: string };
+        const { title, folder_token, permission } = params as {
+          title: string;
+          folder_token?: string;
+          permission?: DocPermission;
+        };
         try {
-          const result = await createDoc(getClient(), title, folder_token);
+          const result = await createDoc(getClient(), title, folder_token, permission);
           return json(result);
         } catch (err) {
           return json({ error: err instanceof Error ? err.message : String(err) });
@@ -687,7 +841,107 @@ export function registerFeishuDocTools(api: OpenClawPluginApi) {
     { name: "feishu_folder_list" },
   );
 
-  // Tool 10: feishu_app_scopes
+  // Tool 10: feishu_doc_set_permission
+  api.registerTool(
+    {
+      name: "feishu_doc_set_permission",
+      label: "Feishu Doc Set Permission",
+      description:
+        "Set document sharing permission. Use 'tenant_editable' to allow organization members to edit via link.",
+      parameters: SetPermissionSchema,
+      async execute(_toolCallId, params) {
+        const { doc_token, permission } = params as { doc_token: string; permission: DocPermission };
+        try {
+          if (permission === "tenant_editable") {
+            await setDocPermissionTenantEditable(getClient(), doc_token);
+            return json({ success: true, permission: "tenant_editable" });
+          } else {
+            // Reset to private (only owner can access)
+            const client = getClient();
+            const res = await client.drive.permissionPublic.patch({
+              path: { token: doc_token },
+              params: { type: "docx" },
+              data: {
+                link_share_entity: "closed",
+                share_entity: "only_full_access",
+              },
+            });
+            if (res.code !== 0) throw new Error(res.msg);
+            return json({ success: true, permission: "private" });
+          }
+        } catch (err) {
+          return json({ error: err instanceof Error ? err.message : String(err) });
+        }
+      },
+    },
+    { name: "feishu_doc_set_permission" },
+  );
+
+  // Tool 11: feishu_wiki_read
+  api.registerTool(
+    {
+      name: "feishu_wiki_read",
+      label: "Feishu Wiki Read",
+      description:
+        "Read content from a Feishu wiki page. Extract wiki_token from URL /wiki/XXX. Returns wiki metadata and document content if the underlying type is docx.",
+      parameters: WikiTokenSchema,
+      async execute(_toolCallId, params) {
+        const { wiki_token } = params as { wiki_token: string };
+        try {
+          const result = await readWiki(getClient(), wiki_token);
+          return json(result);
+        } catch (err) {
+          return json({ error: err instanceof Error ? err.message : String(err) });
+        }
+      },
+    },
+    { name: "feishu_wiki_read" },
+  );
+
+  // Tool 12: feishu_wiki_spaces
+  api.registerTool(
+    {
+      name: "feishu_wiki_spaces",
+      label: "Feishu Wiki Spaces",
+      description: "List available wiki spaces (knowledge bases) the app has access to.",
+      parameters: Type.Object({}),
+      async execute() {
+        try {
+          const result = await listWikiSpaces(getClient());
+          return json(result);
+        } catch (err) {
+          return json({ error: err instanceof Error ? err.message : String(err) });
+        }
+      },
+    },
+    { name: "feishu_wiki_spaces" },
+  );
+
+  // Tool 13: feishu_wiki_nodes
+  api.registerTool(
+    {
+      name: "feishu_wiki_nodes",
+      label: "Feishu Wiki Nodes",
+      description:
+        "List wiki nodes (pages) in a space. Use parent_node_token to list children of a specific node.",
+      parameters: WikiSpaceIdSchema,
+      async execute(_toolCallId, params) {
+        const { space_id, parent_node_token } = params as {
+          space_id: string;
+          parent_node_token?: string;
+        };
+        try {
+          const result = await listWikiNodes(getClient(), space_id, parent_node_token);
+          return json(result);
+        } catch (err) {
+          return json({ error: err instanceof Error ? err.message : String(err) });
+        }
+      },
+    },
+    { name: "feishu_wiki_nodes" },
+  );
+
+  // Tool 14: feishu_app_scopes
   api.registerTool(
     {
       name: "feishu_app_scopes",
@@ -707,5 +961,5 @@ export function registerFeishuDocTools(api: OpenClawPluginApi) {
     { name: "feishu_app_scopes" },
   );
 
-  api.logger.info?.(`feishu_doc: Registered 10 document tools`);
+  api.logger.info?.(`feishu_doc: Registered 14 document/wiki tools`);
 }