@bobotu/feishu-fork 0.1.0

package/skills/feishu-task/SKILL.md

@@ -0,0 +1,210 @@
+---
+name: feishu-task
+description: |
+  Feishu Task, tasklist, subtask, comment, and attachment management. Activate when user mentions tasks, tasklists, subtasks, task comments, task attachments, or task links.
+---
+
+# Feishu Task Tools
+
+Tools:
+- `feishu_task_create`
+- `feishu_task_subtask_create`
+- `feishu_task_get`
+- `feishu_task_update`
+- `feishu_task_delete`
+- `feishu_task_comment_create`
+- `feishu_task_comment_list`
+- `feishu_task_comment_get`
+- `feishu_task_comment_update`
+- `feishu_task_comment_delete`
+- `feishu_task_attachment_upload`
+- `feishu_task_attachment_list`
+- `feishu_task_attachment_get`
+- `feishu_task_attachment_delete`
+- `feishu_task_add_tasklist`
+- `feishu_task_remove_tasklist`
+- `feishu_tasklist_create`
+- `feishu_tasklist_get`
+- `feishu_tasklist_list`
+- `feishu_tasklist_update`
+- `feishu_tasklist_delete`
+- `feishu_tasklist_add_members`
+- `feishu_tasklist_remove_members`
+
+## Notes
+
+- `task_guid` can be taken from a task URL (guid query param) or from `feishu_task_get` output.
+- `comment_id` can be obtained from `feishu_task_comment_list` output.
+- `attachment_guid` can be obtained from `feishu_task_attachment_list` output.
+- `user_id_type` controls returned/accepted user identity type (`open_id`, `user_id`, `union_id`).
+- If no assignee is specified, set the assignee to the requesting user. Avoid creating unassigned tasks because the user may not be able to view them.
+- Task visibility: users can only view tasks when they are included as assignee.
+- Current limitation: the bot can only create subtasks for tasks created by itself.
+- Attachment upload supports local `file_path` and remote `file_url`. Remote URLs are fetched with runtime media safety checks and size limit (`mediaMaxMb`).
+- Keep tasklist owner as the bot. Add users as members to avoid losing bot access.
+- Use tasklist tools for tasklist membership changes; do not use `feishu_task_update` to move tasks between tasklists.
+
+## Create Task
+
+```json
+{
+  "summary": "Quarterly review",
+  "description": "Prepare review notes",
+  "due": { "timestamp": "1735689600000", "is_all_day": true },
+  "members": [
+    { "id": "ou_xxx", "role": "assignee", "type": "user" }
+  ],
+  "user_id_type": "open_id"
+}
+```
+
+## Create Subtask
+
+```json
+{
+  "task_guid": "e297ddff-06ca-4166-b917-4ce57cd3a7a0",
+  "summary": "Draft report outline",
+  "description": "Collect key metrics",
+  "due": { "timestamp": "1735689600000", "is_all_day": true },
+  "members": [
+    { "id": "ou_xxx", "role": "assignee", "type": "user" }
+  ],
+  "user_id_type": "open_id"
+}
+```
+
+## Create Comment
+
+```json
+{
+  "task_guid": "e297ddff-06ca-4166-b917-4ce57cd3a7a0",
+  "content": "Looks good to me",
+  "user_id_type": "open_id"
+}
+```
+
+## Upload Attachment (file_path)
+
+```json
+{
+  "task_guid": "e297ddff-06ca-4166-b917-4ce57cd3a7a0",
+  "file_path": "/path/to/report.pdf",
+  "user_id_type": "open_id"
+}
+```
+
+## Upload Attachment (file_url)
+
+```json
+{
+  "task_guid": "e297ddff-06ca-4166-b917-4ce57cd3a7a0",
+  "file_url": "https://oss-example.com/bucket/report.pdf",
+  "filename": "report.pdf",
+  "user_id_type": "open_id"
+}
+```
+
+## Tasklist Membership For Tasks
+
+### Add Task to Tasklist
+
+```json
+{
+  "task_guid": "e297ddff-06ca-4166-b917-4ce57cd3a7a0",
+  "tasklist_guid": "cc371766-6584-cf50-a222-c22cd9055004",
+  "section_guid": "6d0f9f48-2e06-4e3d-8a0f-acde196e8c61",
+  "user_id_type": "open_id"
+}
+```
+
+### Remove Task from Tasklist
+
+```json
+{
+  "task_guid": "e297ddff-06ca-4166-b917-4ce57cd3a7a0",
+  "tasklist_guid": "cc371766-6584-cf50-a222-c22cd9055004",
+  "user_id_type": "open_id"
+}
+```
+
+## Tasklists
+
+Tasklists support three roles: owner (read/edit/manage), editor (read/edit), viewer (read).
+
+### Create Tasklist
+
+```json
+{
+  "name": "Project Alpha Tasklist",
+  "members": [
+    { "id": "ou_xxx", "type": "user", "role": "editor" }
+  ],
+  "user_id_type": "open_id"
+}
+```
+
+### Get Tasklist
+
+```json
+{
+  "tasklist_guid": "cc371766-6584-cf50-a222-c22cd9055004",
+  "user_id_type": "open_id"
+}
+```
+
+### List Tasklists
+
+```json
+{
+  "page_size": 50,
+  "page_token": "aWQ9NzEwMjMzMjMxMDE=",
+  "user_id_type": "open_id"
+}
+```
+
+### Update Tasklist
+
+```json
+{
+  "tasklist_guid": "cc371766-6584-cf50-a222-c22cd9055004",
+  "tasklist": {
+    "name": "Renamed Tasklist",
+    "owner": { "id": "ou_xxx", "type": "user", "role": "owner" }
+  },
+  "update_fields": ["name", "owner"],
+  "origin_owner_to_role": "editor",
+  "user_id_type": "open_id"
+}
+```
+
+### Delete Tasklist
+
+```json
+{
+  "tasklist_guid": "cc371766-6584-cf50-a222-c22cd9055004"
+}
+```
+
+### Add Tasklist Members
+
+```json
+{
+  "tasklist_guid": "cc371766-6584-cf50-a222-c22cd9055004",
+  "members": [
+    { "id": "ou_xxx", "type": "user", "role": "editor" }
+  ],
+  "user_id_type": "open_id"
+}
+```
+
+### Remove Tasklist Members
+
+```json
+{
+  "tasklist_guid": "cc371766-6584-cf50-a222-c22cd9055004",
+  "members": [
+    { "id": "ou_xxx", "type": "user", "role": "viewer" }
+  ],
+  "user_id_type": "open_id"
+}
+```

package/skills/feishu-wiki/SKILL.md

@@ -0,0 +1,96 @@
+---
+name: feishu-wiki
+description: |
+  Feishu knowledge base navigation. Activate when user mentions knowledge base, wiki, or wiki links.
+---
+
+# Feishu Wiki Tool
+
+Single tool `feishu_wiki` for knowledge base operations.
+
+## Token Extraction
+
+From URL `https://xxx.feishu.cn/wiki/ABC123def` → `token` = `ABC123def`
+
+## Actions
+
+### List Knowledge Spaces
+
+```json
+{ "action": "spaces" }
+```
+
+Returns all accessible wiki spaces.
+
+### List Nodes
+
+```json
+{ "action": "nodes", "space_id": "7xxx" }
+```
+
+With parent:
+```json
+{ "action": "nodes", "space_id": "7xxx", "parent_node_token": "wikcnXXX" }
+```
+
+### Get Node Details
+
+```json
+{ "action": "get", "token": "ABC123def" }
+```
+
+Returns: `node_token`, `obj_token`, `obj_type`, etc. Use `obj_token` with `feishu_doc` to read/write the document.
+
+### Create Node
+
+```json
+{ "action": "create", "space_id": "7xxx", "title": "New Page" }
+```
+
+With type and parent:
+```json
+{ "action": "create", "space_id": "7xxx", "title": "Sheet", "obj_type": "sheet", "parent_node_token": "wikcnXXX" }
+```
+
+`obj_type`: `docx` (default), `sheet`, `bitable`, `mindnote`, `file`, `doc`, `slides`
+
+### Move Node
+
+```json
+{ "action": "move", "space_id": "7xxx", "node_token": "wikcnXXX" }
+```
+
+To different location:
+```json
+{ "action": "move", "space_id": "7xxx", "node_token": "wikcnXXX", "target_space_id": "7yyy", "target_parent_token": "wikcnYYY" }
+```
+
+### Rename Node
+
+```json
+{ "action": "rename", "space_id": "7xxx", "node_token": "wikcnXXX", "title": "New Title" }
+```
+
+## Wiki-Doc Workflow
+
+To edit a wiki page:
+
+1. Get node: `{ "action": "get", "token": "wiki_token" }` → returns `obj_token`
+2. Read doc: `feishu_doc { "action": "read", "doc_token": "obj_token" }`
+3. Write doc: `feishu_doc { "action": "write", "doc_token": "obj_token", "content": "..." }`
+
+## Configuration
+
+```yaml
+channels:
+  feishu:
+    tools:
+      wiki: true  # default: true
+      doc: true   # required - wiki content uses feishu_doc
+```
+
+**Dependency:** This tool requires `feishu_doc` to be enabled. Wiki pages are documents - use `feishu_wiki` to navigate, then `feishu_doc` to read/edit content.
+
+## Permissions
+
+Required: `wiki:wiki` or `wiki:wiki:readonly`

package/src/accounts.ts

@@ -0,0 +1,140 @@
+import type { ClawdbotConfig } from "openclaw/plugin-sdk";
+import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "openclaw/plugin-sdk";
+import type { FeishuConfig, FeishuAccountConfig, FeishuDomain, ResolvedFeishuAccount } from "./types.js";
+
+/**
+ * List all configured account IDs from the accounts field.
+ */
+function listConfiguredAccountIds(cfg: ClawdbotConfig): string[] {
+  const accounts = (cfg.channels?.feishu as FeishuConfig)?.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: ClawdbotConfig): string[] {
+  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: ClawdbotConfig): string {
+  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: ClawdbotConfig,
+  accountId: string,
+): FeishuAccountConfig | undefined {
+  const accounts = (cfg.channels?.feishu as FeishuConfig)?.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: ClawdbotConfig,
+  accountId: string,
+): FeishuConfig {
+  const feishuCfg = cfg.channels?.feishu as FeishuConfig | undefined;
+
+  // 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 } as FeishuConfig;
+}
+
+/**
+ * Resolve Feishu credentials from a config.
+ */
+export function resolveFeishuCredentials(cfg?: FeishuConfig): {
+  appId: string;
+  appSecret: string;
+  encryptKey?: string;
+  verificationToken?: string;
+  domain: FeishuDomain;
+} | null {
+  const appId = cfg?.appId?.trim();
+  const appSecret = cfg?.appSecret?.trim();
+  if (!appId || !appSecret) return null;
+  return {
+    appId,
+    appSecret,
+    encryptKey: cfg?.encryptKey?.trim() || undefined,
+    verificationToken: cfg?.verificationToken?.trim() || undefined,
+    domain: cfg?.domain ?? "feishu",
+  };
+}
+
+/**
+ * Resolve a complete Feishu account with merged config.
+ */
+export function resolveFeishuAccount(params: {
+  cfg: ClawdbotConfig;
+  accountId?: string | null;
+}): ResolvedFeishuAccount {
+  const accountId = normalizeAccountId(params.accountId);
+  const feishuCfg = params.cfg.channels?.feishu as FeishuConfig | undefined;
+
+  // Base enabled state (top-level)
+  const baseEnabled = feishuCfg?.enabled !== false;
+
+  // Merge configs
+  const merged = mergeFeishuAccountConfig(params.cfg, accountId);
+
+  // Account-level enabled state
+  const accountEnabled = merged.enabled !== false;
+  const enabled = baseEnabled && accountEnabled;
+
+  // Resolve credentials from merged config
+  const creds = resolveFeishuCredentials(merged);
+
+  return {
+    accountId,
+    enabled,
+    configured: Boolean(creds),
+    name: (merged as FeishuAccountConfig).name?.trim() || undefined,
+    appId: creds?.appId,
+    appSecret: creds?.appSecret,
+    encryptKey: creds?.encryptKey,
+    verificationToken: creds?.verificationToken,
+    domain: creds?.domain ?? "feishu",
+    config: merged,
+  };
+}
+
+/**
+ * List all enabled and configured accounts.
+ */
+export function listEnabledFeishuAccounts(cfg: ClawdbotConfig): ResolvedFeishuAccount[] {
+  return listFeishuAccountIds(cfg)
+    .map((accountId) => resolveFeishuAccount({ cfg, accountId }))
+    .filter((account) => account.enabled && account.configured);
+}

package/src/bitable-tools/actions.ts

@@ -0,0 +1,199 @@
+import type {
+  BitableClient,
+  BitableFieldCreateData,
+  BitableFieldUpdateData,
+} from "./common.js";
+import { formatField, runBitableApiCall } from "./common.js";
+
+// -------- Field operations --------
+
+export async function listFields(client: BitableClient, appToken: string, tableId: string) {
+  const res = await runBitableApiCall("bitable.appTableField.list", () =>
+    client.bitable.appTableField.list({
+      path: { app_token: appToken, table_id: tableId },
+    }),
+  );
+
+  const fields = res.data?.items ?? [];
+  return {
+    fields: fields.map((f) => formatField(f)),
+    total: fields.length,
+  };
+}
+
+export async function createField(
+  client: BitableClient,
+  appToken: string,
+  tableId: string,
+  field: BitableFieldCreateData,
+) {
+  const res = await runBitableApiCall("bitable.appTableField.create", () =>
+    client.bitable.appTableField.create({
+      path: { app_token: appToken, table_id: tableId },
+      data: field,
+    }),
+  );
+
+  return {
+    field: res.data?.field ? formatField(res.data.field) : undefined,
+  };
+}
+
+export async function updateField(
+  client: BitableClient,
+  appToken: string,
+  tableId: string,
+  fieldId: string,
+  field: BitableFieldUpdateData,
+) {
+  const res = await runBitableApiCall("bitable.appTableField.update", () =>
+    client.bitable.appTableField.update({
+      path: { app_token: appToken, table_id: tableId, field_id: fieldId },
+      data: field,
+    }),
+  );
+
+  return {
+    field: res.data?.field ? formatField(res.data.field) : undefined,
+  };
+}
+
+export async function deleteField(
+  client: BitableClient,
+  appToken: string,
+  tableId: string,
+  fieldId: string,
+) {
+  const res = await runBitableApiCall("bitable.appTableField.delete", () =>
+    client.bitable.appTableField.delete({
+      path: { app_token: appToken, table_id: tableId, field_id: fieldId },
+    }),
+  );
+
+  return {
+    success: res.data?.deleted ?? true,
+    field_id: res.data?.field_id ?? fieldId,
+    deleted: res.data?.deleted ?? true,
+  };
+}
+
+// -------- Record operations --------
+
+export async function listRecords(
+  client: BitableClient,
+  appToken: string,
+  tableId: string,
+  pageSize?: number,
+  pageToken?: string,
+) {
+  const res = await runBitableApiCall("bitable.appTableRecord.list", () =>
+    client.bitable.appTableRecord.list({
+      path: { app_token: appToken, table_id: tableId },
+      params: {
+        page_size: pageSize ?? 100,
+        ...(pageToken && { page_token: pageToken }),
+      },
+    }),
+  );
+
+  return {
+    records: res.data?.items ?? [],
+    has_more: res.data?.has_more ?? false,
+    page_token: res.data?.page_token,
+    total: res.data?.total,
+  };
+}
+
+export async function getRecord(
+  client: BitableClient,
+  appToken: string,
+  tableId: string,
+  recordId: string,
+) {
+  const res = await runBitableApiCall("bitable.appTableRecord.get", () =>
+    client.bitable.appTableRecord.get({
+      path: { app_token: appToken, table_id: tableId, record_id: recordId },
+    }),
+  );
+
+  return {
+    record: res.data?.record,
+  };
+}
+
+export async function createRecord(
+  client: BitableClient,
+  appToken: string,
+  tableId: string,
+  fields: Record<string, unknown>,
+) {
+  const res = await runBitableApiCall("bitable.appTableRecord.create", () =>
+    client.bitable.appTableRecord.create({
+      path: { app_token: appToken, table_id: tableId },
+      data: { fields },
+    }),
+  );
+
+  return {
+    record: res.data?.record,
+  };
+}
+
+export async function updateRecord(
+  client: BitableClient,
+  appToken: string,
+  tableId: string,
+  recordId: string,
+  fields: Record<string, unknown>,
+) {
+  const res = await runBitableApiCall("bitable.appTableRecord.update", () =>
+    client.bitable.appTableRecord.update({
+      path: { app_token: appToken, table_id: tableId, record_id: recordId },
+      data: { fields },
+    }),
+  );
+
+  return {
+    record: res.data?.record,
+  };
+}
+
+export async function deleteRecord(
+  client: BitableClient,
+  appToken: string,
+  tableId: string,
+  recordId: string,
+) {
+  const res = await runBitableApiCall("bitable.appTableRecord.delete", () =>
+    client.bitable.appTableRecord.delete({
+      path: { app_token: appToken, table_id: tableId, record_id: recordId },
+    }),
+  );
+
+  return {
+    success: res.data?.deleted ?? true,
+    record_id: res.data?.record_id ?? recordId,
+    deleted: res.data?.deleted ?? true,
+  };
+}
+
+export async function batchDeleteRecords(
+  client: BitableClient,
+  appToken: string,
+  tableId: string,
+  recordIds: string[],
+) {
+  const res = await runBitableApiCall("bitable.appTableRecord.batchDelete", () =>
+    client.bitable.appTableRecord.batchDelete({
+      path: { app_token: appToken, table_id: tableId },
+      data: { records: recordIds },
+    }),
+  );
+
+  const results = res.data?.records ?? [];
+  return {
+    results,
+    requested: recordIds.length,
+    deleted: results.filter((r) => r.deleted).length,
+  };
+}