@nextclaw/channel-plugin-feishu 0.2.15 → 0.2.17

package/src/calendar-event.ts

@@ -0,0 +1,236 @@
+import { Type } from "@sinclair/typebox";
+import type { OpenClawPluginApi } from "./nextclaw-sdk/feishu.js";
+import { normalizeEventTimes, resolveCalendarId } from "./calendar-shared.js";
+import { assertLarkOk, createToolContext, handleInvokeError, json, parseTimeToTimestamp, registerTool, StringEnum } from "./user-tool-helpers.js";
+
+const CalendarEventSchema = Type.Union([
+  Type.Object({
+    action: Type.Literal("create"),
+    start_time: Type.String(),
+    end_time: Type.String(),
+    summary: Type.Optional(Type.String()),
+    calendar_id: Type.Optional(Type.String()),
+    description: Type.Optional(Type.String()),
+    attendees: Type.Optional(Type.Array(Type.Object({ type: StringEnum(["user", "chat", "resource", "third_party"]), id: Type.String() }))),
+    user_open_id: Type.Optional(Type.String()),
+    need_notification: Type.Optional(Type.Boolean()),
+    location: Type.Optional(Type.String()),
+  }),
+  Type.Object({
+    action: Type.Literal("list"),
+    start_time: Type.String(),
+    end_time: Type.String(),
+    calendar_id: Type.Optional(Type.String()),
+    page_size: Type.Optional(Type.Number()),
+    page_token: Type.Optional(Type.String()),
+  }),
+  Type.Object({ action: Type.Literal("get"), event_id: Type.String(), calendar_id: Type.Optional(Type.String()) }),
+  Type.Object({
+    action: Type.Literal("patch"),
+    event_id: Type.String(),
+    calendar_id: Type.Optional(Type.String()),
+    summary: Type.Optional(Type.String()),
+    description: Type.Optional(Type.String()),
+    start_time: Type.Optional(Type.String()),
+    end_time: Type.Optional(Type.String()),
+    location: Type.Optional(Type.String()),
+  }),
+  Type.Object({ action: Type.Literal("delete"), event_id: Type.String(), calendar_id: Type.Optional(Type.String()), need_notification: Type.Optional(Type.Boolean()) }),
+]);
+
+function buildAttendees(payload: {
+  attendees?: Array<{ type: "user" | "chat" | "resource" | "third_party"; id: string }>;
+  user_open_id?: string;
+}) {
+  const attendees = [
+    ...(payload.user_open_id ? [{ type: "user" as const, id: payload.user_open_id }] : []),
+    ...(payload.attendees ?? []),
+  ];
+  return attendees.map((attendee) => {
+    if (attendee.type === "user") return { type: attendee.type, user_id: attendee.id };
+    if (attendee.type === "chat") return { type: attendee.type, chat_id: attendee.id };
+    if (attendee.type === "resource") return { type: attendee.type, room_id: attendee.id };
+    return { type: attendee.type, third_party_email: attendee.id };
+  });
+}
+
+export function registerFeishuCalendarEventTool(api: OpenClawPluginApi) {
+  const { toolClient } = createToolContext(api, "feishu_calendar_event");
+  registerTool(
+    api,
+    {
+      name: "feishu_calendar_event",
+      label: "Feishu Calendar Event",
+      description: "按本人身份创建、查询、修改、删除飞书日程。",
+      parameters: CalendarEventSchema,
+      async execute(_toolCallId, params) {
+        const payload = params as {
+          action: "create" | "list" | "get" | "patch" | "delete";
+          calendar_id?: string;
+          event_id?: string;
+          start_time?: string;
+          end_time?: string;
+          summary?: string;
+          description?: string;
+          attendees?: Array<{ type: "user" | "chat" | "resource" | "third_party"; id: string }>;
+          user_open_id?: string;
+          need_notification?: boolean;
+          location?: string;
+          page_size?: number;
+          page_token?: string;
+        };
+        try {
+          const client = toolClient();
+          const calendarId = await resolveCalendarId(client, payload.calendar_id);
+
+          if (payload.action === "create") {
+            const startTs = payload.start_time ? parseTimeToTimestamp(payload.start_time) : null;
+            const endTs = payload.end_time ? parseTimeToTimestamp(payload.end_time) : null;
+            if (!startTs || !endTs) {
+              return json({ error: "start_time 和 end_time 必须为带时区的 ISO 8601 / RFC 3339 时间。" });
+            }
+            const response = await client.invoke(
+              "feishu_calendar_event.create",
+              (sdk, opts) =>
+                sdk.calendar.calendarEvent.create(
+                  {
+                    path: { calendar_id: calendarId },
+                    data: {
+                      summary: payload.summary,
+                      description: payload.description,
+                      start_time: { timestamp: startTs },
+                      end_time: { timestamp: endTs },
+                      ...(payload.location ? { location: { name: payload.location } } : {}),
+                    },
+                  },
+                  opts,
+                ),
+              { as: "user" },
+            );
+            assertLarkOk(response);
+            const event = (response.data as { event?: { event_id?: string } } | undefined)?.event;
+            const attendeePayload = buildAttendees(payload);
+            if (event?.event_id && attendeePayload.length > 0) {
+              await client.invoke(
+                "feishu_calendar_event.create",
+                (sdk, opts) =>
+                  sdk.calendar.calendarEventAttendee.create(
+                    {
+                      path: { calendar_id: calendarId, event_id: event.event_id! },
+                      params: { user_id_type: "open_id" as never },
+                      data: {
+                        attendees: attendeePayload,
+                        need_notification: payload.need_notification ?? true,
+                      },
+                    },
+                    opts,
+                  ),
+                { as: "user" },
+              );
+            }
+            return json({ event: normalizeEventTimes((response.data as { event?: Record<string, unknown> } | undefined)?.event) });
+          }
+
+          if (payload.action === "list") {
+            const startTs = payload.start_time ? parseTimeToTimestamp(payload.start_time) : null;
+            const endTs = payload.end_time ? parseTimeToTimestamp(payload.end_time) : null;
+            if (!startTs || !endTs) {
+              return json({ error: "start_time 和 end_time 必须为带时区的 ISO 8601 / RFC 3339 时间。" });
+            }
+            const response = await client.invoke(
+              "feishu_calendar_event.instance_view",
+              (sdk, opts) =>
+                sdk.calendar.calendarEvent.instanceView(
+                  {
+                    path: { calendar_id: calendarId },
+                    params: {
+                      start_time: startTs,
+                      end_time: endTs,
+                      page_size: payload.page_size,
+                      page_token: payload.page_token,
+                      user_id_type: "open_id" as never,
+                    },
+                  },
+                  opts,
+                ),
+              { as: "user" },
+            );
+            assertLarkOk(response);
+            const items =
+              ((response.data as { items?: Array<Record<string, unknown>> } | undefined)?.items ?? []).map(
+                normalizeEventTimes,
+              );
+            return json({
+              events: 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 === "get") {
+            const response = await client.invoke(
+              "feishu_calendar_event.get",
+              (sdk, opts) =>
+                sdk.calendar.calendarEvent.get(
+                  { path: { calendar_id: calendarId, event_id: payload.event_id! } },
+                  opts,
+                ),
+              { as: "user" },
+            );
+            assertLarkOk(response);
+            return json({ event: normalizeEventTimes((response.data as { event?: Record<string, unknown> } | undefined)?.event) });
+          }
+
+          if (payload.action === "patch") {
+            const updateData: Record<string, unknown> = {};
+            if (payload.summary) updateData.summary = payload.summary;
+            if (payload.description) updateData.description = payload.description;
+            if (payload.location) updateData.location = { name: payload.location };
+            if (payload.start_time) {
+              const startTs = parseTimeToTimestamp(payload.start_time);
+              if (!startTs) return json({ error: "start_time 必须为带时区的 ISO 8601 / RFC 3339 时间。" });
+              updateData.start_time = { timestamp: startTs };
+            }
+            if (payload.end_time) {
+              const endTs = parseTimeToTimestamp(payload.end_time);
+              if (!endTs) return json({ error: "end_time 必须为带时区的 ISO 8601 / RFC 3339 时间。" });
+              updateData.end_time = { timestamp: endTs };
+            }
+            const response = await client.invoke(
+              "feishu_calendar_event.patch",
+              (sdk, opts) =>
+                sdk.calendar.calendarEvent.patch(
+                  {
+                    path: { calendar_id: calendarId, event_id: payload.event_id! },
+                    data: updateData,
+                  },
+                  opts,
+                ),
+              { as: "user" },
+            );
+            assertLarkOk(response);
+            return json({ event: normalizeEventTimes((response.data as { event?: Record<string, unknown> } | undefined)?.event) });
+          }
+
+          const response = await client.invoke(
+            "feishu_calendar_event.delete",
+            (sdk, opts) =>
+              sdk.calendar.calendarEvent.delete(
+                {
+                  path: { calendar_id: calendarId, event_id: payload.event_id! },
+                  params: { need_notification: payload.need_notification ?? true },
+                },
+                opts,
+              ),
+            { as: "user" },
+          );
+          assertLarkOk(response);
+          return json({ success: true, event_id: payload.event_id });
+        } catch (error) {
+          return handleInvokeError(error, api);
+        }
+      },
+    },
+    { name: "feishu_calendar_event" },
+  );
+}

package/src/calendar-freebusy.ts

@@ -0,0 +1,58 @@
+import { Type } from "@sinclair/typebox";
+import type { OpenClawPluginApi } from "./nextclaw-sdk/feishu.js";
+import { assertLarkOk, createToolContext, handleInvokeError, json, parseTimeToRFC3339, registerTool } from "./user-tool-helpers.js";
+
+const CalendarFreebusySchema = Type.Object({
+  action: Type.Literal("list"),
+  user_ids: Type.Array(Type.String()),
+  time_min: Type.String(),
+  time_max: Type.String(),
+});
+
+export function registerFeishuCalendarFreebusyTool(api: OpenClawPluginApi) {
+  const { toolClient } = createToolContext(api, "feishu_calendar_freebusy");
+  registerTool(api, {
+    name: "feishu_calendar_freebusy",
+    label: "Feishu Calendar Freebusy",
+    description: "按本人身份查询 1-10 位用户在一段时间内的忙闲状态。",
+    parameters: CalendarFreebusySchema,
+    async execute(_toolCallId, params) {
+      const payload = params as { action: "list"; user_ids: string[]; time_min: string; time_max: string };
+      try {
+        if (!payload.user_ids?.length || payload.user_ids.length > 10) {
+          return json({ error: "user_ids 必须是 1-10 个用户 open_id。" });
+        }
+        const timeMin = parseTimeToRFC3339(payload.time_min);
+        const timeMax = parseTimeToRFC3339(payload.time_max);
+        if (!timeMin || !timeMax) {
+          return json({ error: "time_min 和 time_max 必须是带时区的 RFC 3339 时间。" });
+        }
+        const client = toolClient();
+        const response = await client.invoke(
+          "feishu_calendar_freebusy.list",
+          (sdk, opts) =>
+            sdk.calendar.freebusy.batch(
+              {
+                data: {
+                  time_min: timeMin,
+                  time_max: timeMax,
+                  user_ids: payload.user_ids,
+                  include_external_calendar: true,
+                  only_busy: true,
+                } as never,
+              },
+              opts,
+            ),
+          { as: "user" },
+        );
+        assertLarkOk(response);
+        return json({
+          freebusy_lists:
+            (response.data as { freebusy_lists?: unknown[] } | undefined)?.freebusy_lists ?? [],
+        });
+      } catch (error) {
+        return handleInvokeError(error, api);
+      }
+    },
+  }, { name: "feishu_calendar_freebusy" });
+}

package/src/calendar-shared.ts

@@ -0,0 +1,32 @@
+import { createToolContext, assertLarkOk, unixTimestampToISO8601 } from "./user-tool-helpers.js";
+
+export function normalizeEventTimes<T extends Record<string, unknown> | undefined>(event: T): T {
+  if (!event) return event;
+  const typed = event as Record<string, unknown>;
+  const start = typed.start_time as { timestamp?: string | number } | undefined;
+  const end = typed.end_time as { timestamp?: string | number } | undefined;
+  return {
+    ...typed,
+    start_time_iso8601: unixTimestampToISO8601(start?.timestamp),
+    end_time_iso8601: unixTimestampToISO8601(end?.timestamp),
+  } as T;
+}
+
+export async function resolveCalendarId(
+  client: ReturnType<typeof createToolContext>["toolClient"] extends () => infer T ? T : never,
+  calendarId?: string,
+) {
+  if (calendarId) return calendarId;
+  const response = await client.invoke(
+    "feishu_calendar_calendar.primary",
+    (sdk, opts) => sdk.calendar.calendar.primary({}, opts),
+    { as: "user" },
+  );
+  assertLarkOk(response);
+  const calendars = (response.data as { calendars?: Array<{ calendar_id?: string }> } | undefined)?.calendars;
+  const primaryId = calendars?.[0]?.calendar_id;
+  if (!primaryId) {
+    throw new Error("No primary calendar found for current user.");
+  }
+  return primaryId;
+}

package/src/calendar.ts

@@ -0,0 +1,18 @@
+import type { OpenClawPluginApi } from "./nextclaw-sdk/feishu.js";
+import { listEnabledFeishuAccounts } from "./accounts.js";
+import { registerFeishuCalendarCalendarTool } from "./calendar-calendar.js";
+import { registerFeishuCalendarEventTool } from "./calendar-event.js";
+import { registerFeishuCalendarEventAttendeeTool } from "./calendar-event-attendee.js";
+import { registerFeishuCalendarFreebusyTool } from "./calendar-freebusy.js";
+import { resolveAnyEnabledFeishuToolsConfig } from "./tool-account.js";
+
+export function registerFeishuCalendarTools(api: OpenClawPluginApi) {
+  if (!api.config) return;
+  const accounts = listEnabledFeishuAccounts(api.config);
+  if (accounts.length === 0) return;
+  if (!resolveAnyEnabledFeishuToolsConfig(accounts).calendar) return;
+  registerFeishuCalendarCalendarTool(api);
+  registerFeishuCalendarEventTool(api);
+  registerFeishuCalendarEventAttendeeTool(api);
+  registerFeishuCalendarFreebusyTool(api);
+}

package/src/card-action.ts

@@ -1,6 +1,7 @@
 import type { ClawdbotConfig, RuntimeEnv } from "./nextclaw-sdk/feishu.js";
 import { resolveFeishuAccount } from "./accounts.js";
 import { handleFeishuMessage, type FeishuMessageEvent } from "./bot.js";
+import { withTicket } from "./lark-ticket.js";
 
 export type FeishuCardActionEvent = {
   operator: {
@@ -69,11 +70,22 @@ export async function handleFeishuCardAction(params: {
   );
 
   // Dispatch as normal message
-  await handleFeishuMessage({
-    cfg,
-    event: messageEvent,
-    botOpenId: params.botOpenId,
-    runtime,
-    accountId,
-  });
+  await withTicket(
+    {
+      accountId: account.accountId,
+      messageId: messageEvent.message.message_id,
+      chatId: messageEvent.message.chat_id,
+      senderOpenId: event.operator.open_id,
+      chatType: messageEvent.message.chat_type,
+      startTime: Date.now(),
+    },
+    () =>
+      handleFeishuMessage({
+        cfg,
+        event: messageEvent,
+        botOpenId: params.botOpenId,
+        runtime,
+        accountId,
+      }),
+  );
 }

package/src/config-schema.ts

@@ -92,6 +92,11 @@ const FeishuToolsConfigSchema = z
     drive: z.boolean().optional(), // Cloud storage operations (default: true)
     perm: z.boolean().optional(), // Permission management (default: false, sensitive)
     scopes: z.boolean().optional(), // App scopes diagnostic (default: true)
+    calendar: z.boolean().optional(), // Calendar operations (default: true)
+    task: z.boolean().optional(), // Task operations (default: true)
+    sheets: z.boolean().optional(), // Sheets operations (default: true)
+    oauth: z.boolean().optional(), // OAuth operations (default: true)
+    identity: z.boolean().optional(), // Identity lookup operations (default: true)
   })
   .strict()
   .optional();

package/src/device-flow.ts

@@ -0,0 +1,188 @@
+import { feishuFetch } from "./feishu-fetch.js";
+import type { FeishuDomain } from "./types.js";
+
+export type DeviceAuthResponse = {
+  deviceCode: string;
+  userCode: string;
+  verificationUri: string;
+  verificationUriComplete: string;
+  expiresIn: number;
+  interval: number;
+};
+
+export type DeviceFlowTokenData = {
+  accessToken: string;
+  refreshToken: string;
+  expiresIn: number;
+  refreshExpiresIn: number;
+  scope: string;
+};
+
+export type DeviceFlowResult =
+  | { ok: true; token: DeviceFlowTokenData }
+  | {
+      ok: false;
+      error: "authorization_pending" | "slow_down" | "access_denied" | "expired_token";
+      message: string;
+    };
+
+export function resolveOAuthEndpoints(domain: FeishuDomain): {
+  deviceAuthorization: string;
+  token: string;
+} {
+  if (!domain || domain === "feishu") {
+    return {
+      deviceAuthorization: "https://accounts.feishu.cn/oauth/v1/device_authorization",
+      token: "https://open.feishu.cn/open-apis/authen/v2/oauth/token",
+    };
+  }
+  if (domain === "lark") {
+    return {
+      deviceAuthorization: "https://accounts.larksuite.com/oauth/v1/device_authorization",
+      token: "https://open.larksuite.com/open-apis/authen/v2/oauth/token",
+    };
+  }
+
+  const base = domain.replace(/\/+$/, "");
+  let accountsBase = base;
+  try {
+    const parsed = new URL(base);
+    if (parsed.hostname.startsWith("open.")) {
+      accountsBase = `${parsed.protocol}//${parsed.hostname.replace(/^open\./, "accounts.")}`;
+    }
+  } catch {
+    // ignore
+  }
+
+  return {
+    deviceAuthorization: `${accountsBase}/oauth/v1/device_authorization`,
+    token: `${base}/open-apis/authen/v2/oauth/token`,
+  };
+}
+
+export async function requestDeviceAuthorization(params: {
+  appId: string;
+  appSecret: string;
+  domain: FeishuDomain;
+  scope?: string;
+}): Promise<DeviceAuthResponse> {
+  const endpoints = resolveOAuthEndpoints(params.domain);
+  let scope = params.scope?.trim() ?? "";
+  if (!scope.includes("offline_access")) {
+    scope = scope ? `${scope} offline_access` : "offline_access";
+  }
+
+  const basicAuth = Buffer.from(`${params.appId}:${params.appSecret}`).toString("base64");
+  const body = new URLSearchParams();
+  body.set("client_id", params.appId);
+  body.set("scope", scope);
+
+  const response = await feishuFetch(endpoints.deviceAuthorization, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded",
+      Authorization: `Basic ${basicAuth}`,
+    },
+    body: body.toString(),
+  });
+
+  const data = (await response.json()) as Record<string, unknown>;
+  if (!response.ok || data.error) {
+    throw new Error(
+      String(data.error_description ?? data.error ?? `HTTP ${response.status}`),
+    );
+  }
+
+  return {
+    deviceCode: String(data.device_code ?? ""),
+    userCode: String(data.user_code ?? ""),
+    verificationUri: String(data.verification_uri ?? ""),
+    verificationUriComplete: String(data.verification_uri_complete ?? data.verification_uri ?? ""),
+    expiresIn: Number(data.expires_in ?? 240),
+    interval: Number(data.interval ?? 5),
+  };
+}
+
+function sleep(ms: number, signal?: AbortSignal): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(resolve, ms);
+    signal?.addEventListener(
+      "abort",
+      () => {
+        clearTimeout(timer);
+        reject(new DOMException("Aborted", "AbortError"));
+      },
+      { once: true },
+    );
+  });
+}
+
+export async function pollDeviceToken(params: {
+  appId: string;
+  appSecret: string;
+  domain: FeishuDomain;
+  deviceCode: string;
+  interval: number;
+  expiresIn: number;
+  signal?: AbortSignal;
+}): Promise<DeviceFlowResult> {
+  const endpoints = resolveOAuthEndpoints(params.domain);
+  const deadline = Date.now() + params.expiresIn * 1000;
+  let interval = params.interval;
+
+  while (Date.now() < deadline) {
+    if (params.signal?.aborted) {
+      return { ok: false, error: "expired_token", message: "Polling was cancelled" };
+    }
+
+    await sleep(interval * 1000, params.signal);
+
+    const response = await feishuFetch(endpoints.token, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: new URLSearchParams({
+        grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+        device_code: params.deviceCode,
+        client_id: params.appId,
+        client_secret: params.appSecret,
+      }).toString(),
+    });
+
+    const data = (await response.json()) as Record<string, unknown>;
+    const error = typeof data.error === "string" ? data.error : undefined;
+
+    if (!error && data.access_token) {
+      return {
+        ok: true,
+        token: {
+          accessToken: String(data.access_token),
+          refreshToken: String(data.refresh_token ?? ""),
+          expiresIn: Number(data.expires_in ?? 7200),
+          refreshExpiresIn: Number(data.refresh_token_expires_in ?? data.expires_in ?? 7200),
+          scope: String(data.scope ?? ""),
+        },
+      };
+    }
+
+    if (error === "authorization_pending") {
+      continue;
+    }
+    if (error === "slow_down") {
+      interval = Math.min(interval + 5, 60);
+      continue;
+    }
+    if (error === "access_denied" || error === "expired_token") {
+      return {
+        ok: false,
+        error,
+        message: String(data.error_description ?? error),
+      };
+    }
+  }
+
+  return {
+    ok: false,
+    error: "expired_token",
+    message: "Device authorization expired before approval finished.",
+  };
+}

package/src/domains.ts

@@ -0,0 +1,19 @@
+import type { FeishuDomain } from "./types.js";
+
+export function openPlatformDomain(domain?: FeishuDomain): string {
+  return domain === "lark" ? "https://open.larksuite.com" : "https://open.feishu.cn";
+}
+
+export function wwwDomain(domain?: FeishuDomain): string {
+  return domain === "lark" ? "https://www.larksuite.com" : "https://www.feishu.cn";
+}
+
+export function resolveDomainUrl(domain: FeishuDomain): string {
+  if (domain === "feishu") {
+    return "https://open.feishu.cn";
+  }
+  if (domain === "lark") {
+    return "https://open.larksuite.com";
+  }
+  return domain.replace(/\/+$/, "");
+}

package/src/feishu-fetch.ts

@@ -0,0 +1,9 @@
+const FEISHU_USER_AGENT = "nextclaw-feishu-plugin/0.2";
+
+export function feishuFetch(url: string | URL | Request, init?: RequestInit): Promise<Response> {
+  const headers = new Headers(init?.headers);
+  if (!headers.has("User-Agent")) {
+    headers.set("User-Agent", FEISHU_USER_AGENT);
+  }
+  return fetch(url, { ...init, headers });
+}