@nextclaw/channel-plugin-feishu 0.2.16 → 0.2.17

package/src/task-comment.ts

@@ -0,0 +1,95 @@
+import { Type } from "@sinclair/typebox";
+import type { OpenClawPluginApi } from "./nextclaw-sdk/feishu.js";
+import { assertLarkOk, createToolContext, handleInvokeError, json, registerTool, StringEnum } from "./user-tool-helpers.js";
+
+const CommentSchema = Type.Union([
+  Type.Object({ action: Type.Literal("create"), task_guid: Type.String(), content: Type.String(), reply_to_comment_id: Type.Optional(Type.String()) }),
+  Type.Object({ action: Type.Literal("list"), resource_id: Type.String(), direction: Type.Optional(StringEnum(["asc", "desc"])), page_size: Type.Optional(Type.Number()), page_token: Type.Optional(Type.String()) }),
+  Type.Object({ action: Type.Literal("get"), comment_id: Type.String() }),
+]);
+
+export function registerFeishuTaskCommentTool(api: OpenClawPluginApi) {
+  const { toolClient } = createToolContext(api, "feishu_task_comment");
+  registerTool(api, {
+    name: "feishu_task_comment",
+    label: "Feishu Task Comment",
+    description: "按本人身份创建、获取、列出任务评论。",
+    parameters: CommentSchema,
+    async execute(_toolCallId, params) {
+      const payload = params as {
+        action: "create" | "get" | "list";
+        task_guid?: string;
+        content?: string;
+        reply_to_comment_id?: string;
+        resource_id?: string;
+        direction?: "asc" | "desc";
+        page_size?: number;
+        page_token?: string;
+        comment_id?: string;
+      };
+      try {
+        const client = toolClient();
+        if (payload.action === "create") {
+          const response = await client.invoke(
+            "feishu_task_comment.create",
+            (sdk, opts) =>
+              sdk.task.v2.comment.create(
+                {
+                  params: { user_id_type: "open_id" as never },
+                  data: {
+                    content: payload.content,
+                    resource_type: "task",
+                    resource_id: payload.task_guid,
+                    reply_to_comment_id: payload.reply_to_comment_id,
+                  },
+                },
+                opts,
+              ),
+            { as: "user" },
+          );
+          assertLarkOk(response);
+          return json({ comment: (response.data as { comment?: unknown } | undefined)?.comment });
+        }
+        if (payload.action === "get") {
+          const response = await client.invoke(
+            "feishu_task_comment.get",
+            (sdk, opts) =>
+              sdk.task.v2.comment.get(
+                { path: { comment_id: payload.comment_id! }, params: { user_id_type: "open_id" as never } },
+                opts,
+              ),
+            { as: "user" },
+          );
+          assertLarkOk(response);
+          return json({ comment: (response.data as { comment?: unknown } | undefined)?.comment });
+        }
+        const response = await client.invoke(
+          "feishu_task_comment.list",
+          (sdk, opts) =>
+            sdk.task.v2.comment.list(
+              {
+                params: {
+                  resource_type: "task",
+                  resource_id: payload.resource_id,
+                  direction: payload.direction,
+                  page_size: payload.page_size,
+                  page_token: payload.page_token,
+                  user_id_type: "open_id" as never,
+                },
+              },
+              opts,
+            ),
+          { as: "user" },
+        );
+        assertLarkOk(response);
+        return json({
+          comments: (response.data as { items?: unknown[] } | undefined)?.items ?? [],
+          has_more: (response.data as { has_more?: boolean } | undefined)?.has_more ?? false,
+          page_token: (response.data as { page_token?: string } | undefined)?.page_token,
+        });
+      } catch (error) {
+        return handleInvokeError(error, api);
+      }
+    },
+  }, { name: "feishu_task_comment" });
+}

package/src/task-shared.ts

@@ -0,0 +1,10 @@
+import { parseTimeToTimestampMs } from "./user-tool-helpers.js";
+
+export function normalizeTaskTime(input?: { timestamp?: string; is_all_day?: boolean }) {
+  if (!input) return undefined;
+  const ts = parseTimeToTimestampMs(input.timestamp);
+  if (!ts) {
+    throw new Error("任务时间字段必须是带时区的 ISO 8601 / RFC 3339 时间。");
+  }
+  return { timestamp: ts, is_all_day: input.is_all_day ?? false };
+}

package/src/task-subtask.ts

@@ -0,0 +1,94 @@
+import { Type } from "@sinclair/typebox";
+import type { OpenClawPluginApi } from "./nextclaw-sdk/feishu.js";
+import { normalizeTaskTime } from "./task-shared.js";
+import { assertLarkOk, createToolContext, handleInvokeError, json, registerTool, StringEnum } from "./user-tool-helpers.js";
+
+const SubtaskSchema = Type.Union([
+  Type.Object({
+    action: Type.Literal("create"),
+    task_guid: Type.String(),
+    summary: Type.String(),
+    description: Type.Optional(Type.String()),
+    due: Type.Optional(Type.Object({ timestamp: Type.String(), is_all_day: Type.Optional(Type.Boolean()) })),
+    start: Type.Optional(Type.Object({ timestamp: Type.String(), is_all_day: Type.Optional(Type.Boolean()) })),
+    members: Type.Optional(Type.Array(Type.Object({ id: Type.String(), role: Type.Optional(StringEnum(["assignee", "follower"])) }))),
+  }),
+  Type.Object({ action: Type.Literal("list"), task_guid: Type.String(), page_size: Type.Optional(Type.Number()), page_token: Type.Optional(Type.String()) }),
+]);
+
+export function registerFeishuTaskSubtaskTool(api: OpenClawPluginApi) {
+  const { toolClient } = createToolContext(api, "feishu_task_subtask");
+  registerTool(api, {
+    name: "feishu_task_subtask",
+    label: "Feishu Task Subtask",
+    description: "按本人身份创建、列出任务的子任务。",
+    parameters: SubtaskSchema,
+    async execute(_toolCallId, params) {
+      const payload = params as {
+        action: "create" | "list";
+        task_guid: string;
+        summary?: string;
+        description?: string;
+        due?: { timestamp?: string; is_all_day?: boolean };
+        start?: { timestamp?: string; is_all_day?: boolean };
+        members?: Array<{ id: string; role?: string }>;
+        page_size?: number;
+        page_token?: string;
+      };
+      try {
+        const client = toolClient();
+        if (payload.action === "create") {
+          const response = await client.invoke(
+            "feishu_task_subtask.create",
+            (sdk, opts) =>
+              sdk.task.v2.taskSubtask.create(
+                {
+                  path: { task_guid: payload.task_guid },
+                  params: { user_id_type: "open_id" as never },
+                  data: {
+                    summary: payload.summary,
+                    description: payload.description,
+                    due: normalizeTaskTime(payload.due),
+                    start: normalizeTaskTime(payload.start),
+                    members: payload.members?.map((member) => ({
+                      id: member.id,
+                      type: "user",
+                      role: member.role ?? "assignee",
+                    })),
+                  },
+                },
+                opts,
+              ),
+            { as: "user" },
+          );
+          assertLarkOk(response);
+          return json({ subtask: (response.data as { subtask?: unknown } | undefined)?.subtask });
+        }
+        const response = await client.invoke(
+          "feishu_task_subtask.list",
+          (sdk, opts) =>
+            sdk.task.v2.taskSubtask.list(
+              {
+                path: { task_guid: payload.task_guid },
+                params: {
+                  page_size: payload.page_size,
+                  page_token: payload.page_token,
+                  user_id_type: "open_id" as never,
+                },
+              },
+              opts,
+            ),
+          { as: "user" },
+        );
+        assertLarkOk(response);
+        return json({
+          subtasks: (response.data as { items?: unknown[] } | undefined)?.items ?? [],
+          has_more: (response.data as { has_more?: boolean } | undefined)?.has_more ?? false,
+          page_token: (response.data as { page_token?: string } | undefined)?.page_token,
+        });
+      } catch (error) {
+        return handleInvokeError(error, api);
+      }
+    },
+  }, { name: "feishu_task_subtask" });
+}

package/src/task-task.ts

@@ -0,0 +1,172 @@
+import { Type } from "@sinclair/typebox";
+import type { OpenClawPluginApi } from "./nextclaw-sdk/feishu.js";
+import { normalizeTaskTime } from "./task-shared.js";
+import { assertLarkOk, createToolContext, handleInvokeError, json, parseTimeToTimestampMs, registerTool, StringEnum } from "./user-tool-helpers.js";
+
+const TaskSchema = Type.Union([
+  Type.Object({
+    action: Type.Literal("create"),
+    summary: Type.String(),
+    current_user_id: Type.Optional(Type.String()),
+    description: Type.Optional(Type.String()),
+    due: Type.Optional(Type.Object({ timestamp: Type.String(), is_all_day: Type.Optional(Type.Boolean()) })),
+    start: Type.Optional(Type.Object({ timestamp: Type.String(), is_all_day: Type.Optional(Type.Boolean()) })),
+    members: Type.Optional(Type.Array(Type.Object({ id: Type.String(), role: Type.Optional(StringEnum(["assignee", "follower"])) }))),
+    tasklists: Type.Optional(Type.Array(Type.Object({ tasklist_guid: Type.String(), section_guid: Type.Optional(Type.String()) }))),
+    repeat_rule: Type.Optional(Type.String()),
+  }),
+  Type.Object({ action: Type.Literal("get"), task_guid: Type.String() }),
+  Type.Object({ action: Type.Literal("list"), page_size: Type.Optional(Type.Number()), page_token: Type.Optional(Type.String()), completed: Type.Optional(Type.Boolean()) }),
+  Type.Object({
+    action: Type.Literal("patch"),
+    task_guid: Type.String(),
+    summary: Type.Optional(Type.String()),
+    description: Type.Optional(Type.String()),
+    due: Type.Optional(Type.Object({ timestamp: Type.String(), is_all_day: Type.Optional(Type.Boolean()) })),
+    start: Type.Optional(Type.Object({ timestamp: Type.String(), is_all_day: Type.Optional(Type.Boolean()) })),
+    completed_at: Type.Optional(Type.String()),
+    members: Type.Optional(Type.Array(Type.Object({ id: Type.String(), role: Type.Optional(StringEnum(["assignee", "follower"])) }))),
+    repeat_rule: Type.Optional(Type.String()),
+  }),
+]);
+
+export function registerFeishuTaskTaskTool(api: OpenClawPluginApi) {
+  const { toolClient } = createToolContext(api, "feishu_task_task");
+  registerTool(api, {
+    name: "feishu_task_task",
+    label: "Feishu Task",
+    description: "按本人身份创建、查询、列出、更新飞书任务。",
+    parameters: TaskSchema,
+    async execute(_toolCallId, params) {
+      const payload = params as {
+        action: "create" | "get" | "list" | "patch";
+        task_guid?: string;
+        summary?: string;
+        current_user_id?: string;
+        description?: string;
+        due?: { timestamp?: string; is_all_day?: boolean };
+        start?: { timestamp?: string; is_all_day?: boolean };
+        members?: Array<{ id: string; role?: string }>;
+        tasklists?: Array<{ tasklist_guid: string; section_guid?: string }>;
+        repeat_rule?: string;
+        page_size?: number;
+        page_token?: string;
+        completed?: boolean;
+        completed_at?: string;
+      };
+      try {
+        const client = toolClient();
+        if (payload.action === "create") {
+          const members = [...(payload.members ?? [])];
+          if (payload.current_user_id && !members.some((member) => member.id === payload.current_user_id)) {
+            members.push({ id: payload.current_user_id, role: "follower" });
+          }
+          const response = await client.invoke(
+            "feishu_task_task.create",
+            (sdk, opts) =>
+              sdk.task.v2.task.create(
+                {
+                  params: { user_id_type: "open_id" as never },
+                  data: {
+                    summary: payload.summary,
+                    description: payload.description,
+                    due: normalizeTaskTime(payload.due),
+                    start: normalizeTaskTime(payload.start),
+                    repeat_rule: payload.repeat_rule,
+                    members: members.length
+                      ? members.map((member) => ({
+                          id: member.id,
+                          type: "user",
+                          role: member.role ?? "assignee",
+                        }))
+                      : undefined,
+                    tasklists: payload.tasklists,
+                  },
+                },
+                opts,
+              ),
+            { as: "user" },
+          );
+          assertLarkOk(response);
+          return json({ task: (response.data as { task?: unknown } | undefined)?.task });
+        }
+        if (payload.action === "get") {
+          const response = await client.invoke(
+            "feishu_task_task.get",
+            (sdk, opts) =>
+              sdk.task.v2.task.get(
+                { path: { task_guid: payload.task_guid! }, params: { user_id_type: "open_id" as never } },
+                opts,
+              ),
+            { as: "user" },
+          );
+          assertLarkOk(response);
+          return json({ task: (response.data as { task?: unknown } | undefined)?.task });
+        }
+        if (payload.action === "list") {
+          const response = await client.invoke(
+            "feishu_task_task.list",
+            (sdk, opts) =>
+              sdk.task.v2.task.list(
+                {
+                  params: {
+                    page_size: payload.page_size,
+                    page_token: payload.page_token,
+                    completed: payload.completed,
+                    user_id_type: "open_id" as never,
+                  },
+                },
+                opts,
+              ),
+            { as: "user" },
+          );
+          assertLarkOk(response);
+          return json({
+            tasks: (response.data as { items?: unknown[] } | undefined)?.items ?? [],
+            has_more: (response.data as { has_more?: boolean } | undefined)?.has_more ?? false,
+            page_token: (response.data as { page_token?: string } | undefined)?.page_token,
+          });
+        }
+
+        const patchData: Record<string, unknown> = {};
+        if (payload.summary) patchData.summary = payload.summary;
+        if (payload.description) patchData.description = payload.description;
+        if (payload.due) patchData.due = normalizeTaskTime(payload.due);
+        if (payload.start) patchData.start = normalizeTaskTime(payload.start);
+        if (payload.repeat_rule) patchData.repeat_rule = payload.repeat_rule;
+        if (payload.completed_at !== undefined) {
+          patchData.completed_at =
+            payload.completed_at === "0"
+              ? "0"
+              : /^\d+$/.test(payload.completed_at)
+                ? payload.completed_at
+                : parseTimeToTimestampMs(payload.completed_at);
+        }
+        if (payload.members) {
+          patchData.members = payload.members.map((member) => ({
+            id: member.id,
+            type: "user",
+            role: member.role ?? "assignee",
+          }));
+        }
+        const response = await client.invoke(
+          "feishu_task_task.patch",
+          (sdk, opts) =>
+            sdk.task.v2.task.patch(
+              {
+                path: { task_guid: payload.task_guid! },
+                params: { user_id_type: "open_id" as never },
+                data: patchData,
+              },
+              opts,
+            ),
+          { as: "user" },
+        );
+        assertLarkOk(response);
+        return json({ task: (response.data as { task?: unknown } | undefined)?.task });
+      } catch (error) {
+        return handleInvokeError(error, api);
+      }
+    },
+  }, { name: "feishu_task_task" });
+}

package/src/task-tasklist.ts

@@ -0,0 +1,154 @@
+import { Type } from "@sinclair/typebox";
+import type { OpenClawPluginApi } from "./nextclaw-sdk/feishu.js";
+import { assertLarkOk, createToolContext, handleInvokeError, json, registerTool, StringEnum } from "./user-tool-helpers.js";
+
+const TasklistSchema = Type.Union([
+  Type.Object({ action: Type.Literal("create"), name: Type.String(), members: Type.Optional(Type.Array(Type.Object({ id: Type.String(), role: Type.Optional(StringEnum(["editor", "viewer"])) }))) }),
+  Type.Object({ action: Type.Literal("get"), tasklist_guid: Type.String() }),
+  Type.Object({ action: Type.Literal("list"), page_size: Type.Optional(Type.Number()), page_token: Type.Optional(Type.String()) }),
+  Type.Object({ action: Type.Literal("tasks"), tasklist_guid: Type.String(), page_size: Type.Optional(Type.Number()), page_token: Type.Optional(Type.String()), completed: Type.Optional(Type.Boolean()) }),
+  Type.Object({ action: Type.Literal("patch"), tasklist_guid: Type.String(), name: Type.Optional(Type.String()) }),
+  Type.Object({ action: Type.Literal("add_members"), tasklist_guid: Type.String(), members: Type.Array(Type.Object({ id: Type.String(), role: Type.Optional(StringEnum(["editor", "viewer"])) }))) }),
+]);
+
+export function registerFeishuTaskTasklistTool(api: OpenClawPluginApi) {
+  const { toolClient } = createToolContext(api, "feishu_task_tasklist");
+  registerTool(api, {
+    name: "feishu_task_tasklist",
+    label: "Feishu Tasklist",
+    description: "按本人身份创建、查询和管理飞书任务清单。",
+    parameters: TasklistSchema,
+    async execute(_toolCallId, params) {
+      const payload = params as {
+        action: "create" | "get" | "list" | "tasks" | "patch" | "add_members";
+        tasklist_guid?: string;
+        name?: string;
+        members?: Array<{ id: string; role?: string }>;
+        page_size?: number;
+        page_token?: string;
+        completed?: boolean;
+      };
+      try {
+        const client = toolClient();
+        if (payload.action === "create") {
+          const response = await client.invoke(
+            "feishu_task_tasklist.create",
+            (sdk, opts) =>
+              sdk.task.v2.tasklist.create(
+                {
+                  params: { user_id_type: "open_id" as never },
+                  data: {
+                    name: payload.name,
+                    members: payload.members?.map((member) => ({
+                      id: member.id,
+                      type: "user",
+                      role: member.role ?? "editor",
+                    })),
+                  },
+                },
+                opts,
+              ),
+            { as: "user" },
+          );
+          assertLarkOk(response);
+          return json({ tasklist: (response.data as { tasklist?: unknown } | undefined)?.tasklist });
+        }
+        if (payload.action === "get") {
+          const response = await client.invoke(
+            "feishu_task_tasklist.get",
+            (sdk, opts) =>
+              sdk.task.v2.tasklist.get(
+                { path: { tasklist_guid: payload.tasklist_guid! }, params: { user_id_type: "open_id" as never } },
+                opts,
+              ),
+            { as: "user" },
+          );
+          assertLarkOk(response);
+          return json({ tasklist: (response.data as { tasklist?: unknown } | undefined)?.tasklist });
+        }
+        if (payload.action === "list") {
+          const response = await client.invoke(
+            "feishu_task_tasklist.list",
+            (sdk, opts) =>
+              sdk.task.v2.tasklist.list(
+                { params: { page_size: payload.page_size, page_token: payload.page_token, user_id_type: "open_id" as never } },
+                opts,
+              ),
+            { as: "user" },
+          );
+          assertLarkOk(response);
+          return json({
+            tasklists: (response.data as { items?: unknown[] } | undefined)?.items ?? [],
+            has_more: (response.data as { has_more?: boolean } | undefined)?.has_more ?? false,
+            page_token: (response.data as { page_token?: string } | undefined)?.page_token,
+          });
+        }
+        if (payload.action === "tasks") {
+          const response = await client.invoke(
+            "feishu_task_tasklist.tasks",
+            (sdk, opts) =>
+              sdk.task.v2.tasklist.tasks(
+                {
+                  path: { tasklist_guid: payload.tasklist_guid! },
+                  params: {
+                    page_size: payload.page_size,
+                    page_token: payload.page_token,
+                    completed: payload.completed,
+                    user_id_type: "open_id" as never,
+                  },
+                },
+                opts,
+              ),
+            { as: "user" },
+          );
+          assertLarkOk(response);
+          return json({
+            tasks: (response.data as { items?: unknown[] } | undefined)?.items ?? [],
+            has_more: (response.data as { has_more?: boolean } | undefined)?.has_more ?? false,
+            page_token: (response.data as { page_token?: string } | undefined)?.page_token,
+          });
+        }
+        if (payload.action === "patch") {
+          const response = await client.invoke(
+            "feishu_task_tasklist.patch",
+            (sdk, opts) =>
+              sdk.task.v2.tasklist.patch(
+                {
+                  path: { tasklist_guid: payload.tasklist_guid! },
+                  params: { user_id_type: "open_id" as never },
+                  data: { name: payload.name },
+                },
+                opts,
+              ),
+            { as: "user" },
+          );
+          assertLarkOk(response);
+          return json({ tasklist: (response.data as { tasklist?: unknown } | undefined)?.tasklist });
+        }
+        const response = await client.invoke(
+          "feishu_task_tasklist.add_members",
+          (sdk, opts) =>
+            sdk.task.v2.tasklist.addMembers(
+              {
+                path: { tasklist_guid: payload.tasklist_guid! },
+                params: { user_id_type: "open_id" as never },
+                data: {
+                  members: (payload.members ?? []).map((member) => ({
+                    id: member.id,
+                    type: "user",
+                    role: member.role ?? "editor",
+                  })),
+                },
+              },
+              opts,
+            ),
+          { as: "user" },
+        );
+        assertLarkOk(response);
+        return json({ success: true, tasklist_guid: payload.tasklist_guid });
+      } catch (error) {
+        return handleInvokeError(error, api);
+      }
+    },
+  }, { name: "feishu_task_tasklist" });
+}

package/src/task.ts

@@ -0,0 +1,18 @@
+import type { OpenClawPluginApi } from "./nextclaw-sdk/feishu.js";
+import { listEnabledFeishuAccounts } from "./accounts.js";
+import { resolveAnyEnabledFeishuToolsConfig } from "./tool-account.js";
+import { registerFeishuTaskCommentTool } from "./task-comment.js";
+import { registerFeishuTaskSubtaskTool } from "./task-subtask.js";
+import { registerFeishuTaskTaskTool } from "./task-task.js";
+import { registerFeishuTaskTasklistTool } from "./task-tasklist.js";
+
+export function registerFeishuTaskTools(api: OpenClawPluginApi) {
+  if (!api.config) return;
+  const accounts = listEnabledFeishuAccounts(api.config);
+  if (accounts.length === 0) return;
+  if (!resolveAnyEnabledFeishuToolsConfig(accounts).task) return;
+  registerFeishuTaskTaskTool(api);
+  registerFeishuTaskTasklistTool(api);
+  registerFeishuTaskCommentTool(api);
+  registerFeishuTaskSubtaskTool(api);
+}