@nextclaw/channel-plugin-feishu 0.2.13 → 0.2.15

package/src/drive-schema.ts

@@ -0,0 +1,46 @@
+import { Type, type Static } from "@sinclair/typebox";
+
+const FileType = Type.Union([
+  Type.Literal("doc"),
+  Type.Literal("docx"),
+  Type.Literal("sheet"),
+  Type.Literal("bitable"),
+  Type.Literal("folder"),
+  Type.Literal("file"),
+  Type.Literal("mindnote"),
+  Type.Literal("shortcut"),
+]);
+
+export const FeishuDriveSchema = Type.Union([
+  Type.Object({
+    action: Type.Literal("list"),
+    folder_token: Type.Optional(
+      Type.String({ description: "Folder token (optional, omit for root directory)" }),
+    ),
+  }),
+  Type.Object({
+    action: Type.Literal("info"),
+    file_token: Type.String({ description: "File or folder token" }),
+    type: FileType,
+  }),
+  Type.Object({
+    action: Type.Literal("create_folder"),
+    name: Type.String({ description: "Folder name" }),
+    folder_token: Type.Optional(
+      Type.String({ description: "Parent folder token (optional, omit for root)" }),
+    ),
+  }),
+  Type.Object({
+    action: Type.Literal("move"),
+    file_token: Type.String({ description: "File token to move" }),
+    type: FileType,
+    folder_token: Type.String({ description: "Target folder token" }),
+  }),
+  Type.Object({
+    action: Type.Literal("delete"),
+    file_token: Type.String({ description: "File token to delete" }),
+    type: FileType,
+  }),
+]);
+
+export type FeishuDriveParams = Static<typeof FeishuDriveSchema>;

package/src/drive.ts

@@ -0,0 +1,228 @@
+import type * as Lark from "@larksuiteoapi/node-sdk";
+import type { OpenClawPluginApi } from "./nextclaw-sdk/feishu.js";
+import { listEnabledFeishuAccounts } from "./accounts.js";
+import { FeishuDriveSchema, type FeishuDriveParams } from "./drive-schema.js";
+import { createFeishuToolClient, resolveAnyEnabledFeishuToolsConfig } from "./tool-account.js";
+import {
+  jsonToolResult,
+  toolExecutionErrorResult,
+  unknownToolActionResult,
+} from "./tool-result.js";
+
+// ============ Actions ============
+
+async function getRootFolderToken(client: Lark.Client): Promise<string> {
+  // Use generic HTTP client to call the root folder meta API
+  // as it's not directly exposed in the SDK
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- accessing internal SDK property
+  const domain = (client as any).domain ?? "https://open.feishu.cn";
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- accessing internal SDK property
+  const res = (await (client as any).httpInstance.get(
+    `${domain}/open-apis/drive/explorer/v2/root_folder/meta`,
+  )) as { code: number; msg?: string; data?: { token?: string } };
+  if (res.code !== 0) {
+    throw new Error(res.msg ?? "Failed to get root folder");
+  }
+  const token = res.data?.token;
+  if (!token) {
+    throw new Error("Root folder token not found");
+  }
+  return token;
+}
+
+async function listFolder(client: Lark.Client, folderToken?: string) {
+  // Filter out invalid folder_token values (empty, "0", etc.)
+  const validFolderToken = folderToken && folderToken !== "0" ? folderToken : undefined;
+  const res = await client.drive.file.list({
+    params: validFolderToken ? { folder_token: validFolderToken } : {},
+  });
+  if (res.code !== 0) {
+    throw new Error(res.msg);
+  }
+
+  return {
+    files:
+      res.data?.files?.map((f) => ({
+        token: f.token,
+        name: f.name,
+        type: f.type,
+        url: f.url,
+        created_time: f.created_time,
+        modified_time: f.modified_time,
+        owner_id: f.owner_id,
+      })) ?? [],
+    next_page_token: res.data?.next_page_token,
+  };
+}
+
+async function getFileInfo(client: Lark.Client, fileToken: string, folderToken?: string) {
+  // Use list with folder_token to find file info
+  const res = await client.drive.file.list({
+    params: folderToken ? { folder_token: folderToken } : {},
+  });
+  if (res.code !== 0) {
+    throw new Error(res.msg);
+  }
+
+  const file = res.data?.files?.find((f) => f.token === fileToken);
+  if (!file) {
+    throw new Error(`File not found: ${fileToken}`);
+  }
+
+  return {
+    token: file.token,
+    name: file.name,
+    type: file.type,
+    url: file.url,
+    created_time: file.created_time,
+    modified_time: file.modified_time,
+    owner_id: file.owner_id,
+  };
+}
+
+async function createFolder(client: Lark.Client, name: string, folderToken?: string) {
+  // Feishu supports using folder_token="0" as the root folder.
+  // We *try* to resolve the real root token (explorer API), but fall back to "0"
+  // because some tenants/apps return 400 for that explorer endpoint.
+  let effectiveToken = folderToken && folderToken !== "0" ? folderToken : "0";
+  if (effectiveToken === "0") {
+    try {
+      effectiveToken = await getRootFolderToken(client);
+    } catch {
+      // ignore and keep "0"
+    }
+  }
+
+  const res = await client.drive.file.createFolder({
+    data: {
+      name,
+      folder_token: effectiveToken,
+    },
+  });
+  if (res.code !== 0) {
+    throw new Error(res.msg);
+  }
+
+  return {
+    token: res.data?.token,
+    url: res.data?.url,
+  };
+}
+
+async function moveFile(client: Lark.Client, fileToken: string, type: string, folderToken: string) {
+  const res = await client.drive.file.move({
+    path: { file_token: fileToken },
+    data: {
+      type: type as
+        | "doc"
+        | "docx"
+        | "sheet"
+        | "bitable"
+        | "folder"
+        | "file"
+        | "mindnote"
+        | "slides",
+      folder_token: folderToken,
+    },
+  });
+  if (res.code !== 0) {
+    throw new Error(res.msg);
+  }
+
+  return {
+    success: true,
+    task_id: res.data?.task_id,
+  };
+}
+
+async function deleteFile(client: Lark.Client, fileToken: string, type: string) {
+  const res = await client.drive.file.delete({
+    path: { file_token: fileToken },
+    params: {
+      type: type as
+        | "doc"
+        | "docx"
+        | "sheet"
+        | "bitable"
+        | "folder"
+        | "file"
+        | "mindnote"
+        | "slides"
+        | "shortcut",
+    },
+  });
+  if (res.code !== 0) {
+    throw new Error(res.msg);
+  }
+
+  return {
+    success: true,
+    task_id: res.data?.task_id,
+  };
+}
+
+// ============ Tool Registration ============
+
+export function registerFeishuDriveTools(api: OpenClawPluginApi) {
+  if (!api.config) {
+    api.logger.debug?.("feishu_drive: No config available, skipping drive tools");
+    return;
+  }
+
+  const accounts = listEnabledFeishuAccounts(api.config);
+  if (accounts.length === 0) {
+    api.logger.debug?.("feishu_drive: No Feishu accounts configured, skipping drive tools");
+    return;
+  }
+
+  const toolsCfg = resolveAnyEnabledFeishuToolsConfig(accounts);
+  if (!toolsCfg.drive) {
+    api.logger.debug?.("feishu_drive: drive tool disabled in config");
+    return;
+  }
+
+  type FeishuDriveExecuteParams = FeishuDriveParams & { accountId?: string };
+
+  api.registerTool(
+    (ctx) => {
+      const defaultAccountId = ctx.agentAccountId;
+      return {
+        name: "feishu_drive",
+        label: "Feishu Drive",
+        description:
+          "Feishu cloud storage operations. Actions: list, info, create_folder, move, delete",
+        parameters: FeishuDriveSchema,
+        async execute(_toolCallId, params) {
+          const p = params as FeishuDriveExecuteParams;
+          try {
+            const client = createFeishuToolClient({
+              api,
+              executeParams: p,
+              defaultAccountId,
+            });
+            switch (p.action) {
+              case "list":
+                return jsonToolResult(await listFolder(client, p.folder_token));
+              case "info":
+                return jsonToolResult(await getFileInfo(client, p.file_token));
+              case "create_folder":
+                return jsonToolResult(await createFolder(client, p.name, p.folder_token));
+              case "move":
+                return jsonToolResult(await moveFile(client, p.file_token, p.type, p.folder_token));
+              case "delete":
+                return jsonToolResult(await deleteFile(client, p.file_token, p.type));
+              default:
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any -- exhaustive check fallback
+                return unknownToolActionResult((p as { action?: unknown }).action);
+            }
+          } catch (err) {
+            return toolExecutionErrorResult(err);
+          }
+        },
+      };
+    },
+    { name: "feishu_drive" },
+  );
+
+  api.logger.info?.(`feishu_drive: Registered feishu_drive tool`);
+}

package/src/dynamic-agent.ts

@@ -0,0 +1,131 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import type { OpenClawConfig, PluginRuntime } from "./nextclaw-sdk/feishu.js";
+import type { DynamicAgentCreationConfig } from "./types.js";
+
+export type MaybeCreateDynamicAgentResult = {
+  created: boolean;
+  updatedCfg: OpenClawConfig;
+  agentId?: string;
+};
+
+/**
+ * Check if a dynamic agent should be created for a DM user and create it if needed.
+ * This creates a unique agent instance with its own workspace for each DM user.
+ */
+export async function maybeCreateDynamicAgent(params: {
+  cfg: OpenClawConfig;
+  runtime: PluginRuntime;
+  senderOpenId: string;
+  dynamicCfg: DynamicAgentCreationConfig;
+  log: (msg: string) => void;
+}): Promise<MaybeCreateDynamicAgentResult> {
+  const { cfg, runtime, senderOpenId, dynamicCfg, log } = params;
+
+  // Check if there's already a binding for this user
+  const existingBindings = cfg.bindings ?? [];
+  const hasBinding = existingBindings.some(
+    (b) =>
+      b.match?.channel === "feishu" &&
+      b.match?.peer?.kind === "direct" &&
+      b.match?.peer?.id === senderOpenId,
+  );
+
+  if (hasBinding) {
+    return { created: false, updatedCfg: cfg };
+  }
+
+  // Check maxAgents limit if configured
+  if (dynamicCfg.maxAgents !== undefined) {
+    const feishuAgentCount = (cfg.agents?.list ?? []).filter((a) =>
+      a.id.startsWith("feishu-"),
+    ).length;
+    if (feishuAgentCount >= dynamicCfg.maxAgents) {
+      log(
+        `feishu: maxAgents limit (${dynamicCfg.maxAgents}) reached, not creating agent for ${senderOpenId}`,
+      );
+      return { created: false, updatedCfg: cfg };
+    }
+  }
+
+  // Use full OpenID as agent ID suffix (OpenID format: ou_xxx is already filesystem-safe)
+  const agentId = `feishu-${senderOpenId}`;
+
+  // Check if agent already exists (but binding was missing)
+  const existingAgent = (cfg.agents?.list ?? []).find((a) => a.id === agentId);
+  if (existingAgent) {
+    // Agent exists but binding doesn't - just add the binding
+    log(`feishu: agent "${agentId}" exists, adding missing binding for ${senderOpenId}`);
+
+    const updatedCfg: OpenClawConfig = {
+      ...cfg,
+      bindings: [
+        ...existingBindings,
+        {
+          agentId,
+          match: {
+            channel: "feishu",
+            peer: { kind: "direct", id: senderOpenId },
+          },
+        },
+      ],
+    };
+
+    await runtime.config.writeConfigFile(updatedCfg);
+    return { created: true, updatedCfg, agentId };
+  }
+
+  // Resolve path templates with substitutions
+  const workspaceTemplate = dynamicCfg.workspaceTemplate ?? "~/.openclaw/workspace-{agentId}";
+  const agentDirTemplate = dynamicCfg.agentDirTemplate ?? "~/.openclaw/agents/{agentId}/agent";
+
+  const workspace = resolveUserPath(
+    workspaceTemplate.replace("{userId}", senderOpenId).replace("{agentId}", agentId),
+  );
+  const agentDir = resolveUserPath(
+    agentDirTemplate.replace("{userId}", senderOpenId).replace("{agentId}", agentId),
+  );
+
+  log(`feishu: creating dynamic agent "${agentId}" for user ${senderOpenId}`);
+  log(`  workspace: ${workspace}`);
+  log(`  agentDir: ${agentDir}`);
+
+  // Create directories
+  await fs.promises.mkdir(workspace, { recursive: true });
+  await fs.promises.mkdir(agentDir, { recursive: true });
+
+  // Update configuration with new agent and binding
+  const updatedCfg: OpenClawConfig = {
+    ...cfg,
+    agents: {
+      ...cfg.agents,
+      list: [...(cfg.agents?.list ?? []), { id: agentId, workspace, agentDir }],
+    },
+    bindings: [
+      ...existingBindings,
+      {
+        agentId,
+        match: {
+          channel: "feishu",
+          peer: { kind: "direct", id: senderOpenId },
+        },
+      },
+    ],
+  };
+
+  // Write updated config using PluginRuntime API
+  await runtime.config.writeConfigFile(updatedCfg);
+
+  return { created: true, updatedCfg, agentId };
+}
+
+/**
+ * Resolve a path that may start with ~ to the user's home directory.
+ */
+function resolveUserPath(p: string): string {
+  if (p.startsWith("~/")) {
+    return path.join(os.homedir(), p.slice(2));
+  }
+  return p;
+}

package/src/external-keys.test.ts

@@ -0,0 +1,20 @@
+import { describe, expect, it } from "vitest";
+import { normalizeFeishuExternalKey } from "./external-keys.js";
+
+describe("normalizeFeishuExternalKey", () => {
+  it("accepts a normal feishu key and trims surrounding spaces", () => {
+    expect(normalizeFeishuExternalKey("  img_v3_01abcDEF123  ")).toBe("img_v3_01abcDEF123");
+  });
+
+  it("rejects traversal and path separator patterns", () => {
+    expect(normalizeFeishuExternalKey("../etc/passwd")).toBeUndefined();
+    expect(normalizeFeishuExternalKey("a/../../b")).toBeUndefined();
+    expect(normalizeFeishuExternalKey("a\\..\\b")).toBeUndefined();
+  });
+
+  it("rejects empty, non-string, and control-char values", () => {
+    expect(normalizeFeishuExternalKey("   ")).toBeUndefined();
+    expect(normalizeFeishuExternalKey(123)).toBeUndefined();
+    expect(normalizeFeishuExternalKey("abc\u0000def")).toBeUndefined();
+  });
+});

package/src/external-keys.ts

@@ -0,0 +1,19 @@
+const CONTROL_CHARS_RE = /[\u0000-\u001f\u007f]/;
+const MAX_EXTERNAL_KEY_LENGTH = 512;
+
+export function normalizeFeishuExternalKey(value: unknown): string | undefined {
+  if (typeof value !== "string") {
+    return undefined;
+  }
+  const normalized = value.trim();
+  if (!normalized || normalized.length > MAX_EXTERNAL_KEY_LENGTH) {
+    return undefined;
+  }
+  if (CONTROL_CHARS_RE.test(normalized)) {
+    return undefined;
+  }
+  if (normalized.includes("/") || normalized.includes("\\") || normalized.includes("..")) {
+    return undefined;
+  }
+  return normalized;
+}

package/src/feishu-command-handler.ts

@@ -0,0 +1,59 @@
+const DEFAULT_RESET_TRIGGERS = ["/new", "/reset"] as const;
+
+type FeishuBeforeResetContext = {
+  cfg: Record<string, unknown>;
+  sessionEntry: Record<string, unknown>;
+  previousSessionEntry?: Record<string, unknown>;
+  commandSource: string;
+  timestamp: number;
+};
+
+type FeishuBeforeResetEvent = {
+  type: "command";
+  action: "new" | "reset";
+  context: FeishuBeforeResetContext;
+};
+
+type FeishuBeforeResetRunner = {
+  runBeforeReset: (
+    event: FeishuBeforeResetEvent,
+    ctx: { agentId: string; sessionKey: string },
+  ) => Promise<void>;
+};
+
+/**
+ * Handle Feishu command messages and trigger reset hooks.
+ */
+export async function handleFeishuCommand(
+  messageText: string,
+  sessionKey: string,
+  hookRunner: FeishuBeforeResetRunner,
+  context: FeishuBeforeResetContext,
+): Promise<boolean> {
+  const trimmed = messageText.trim().toLowerCase();
+  const isResetCommand = DEFAULT_RESET_TRIGGERS.some(
+    (trigger) => trimmed === trigger || trimmed.startsWith(`${trigger} `),
+  );
+  if (!isResetCommand) {
+    return false;
+  }
+
+  const command = trimmed.split(" ")[0];
+  const action: "new" | "reset" = command === "/new" ? "new" : "reset";
+  await hookRunner.runBeforeReset(
+    {
+      type: "command",
+      action,
+      context: {
+        ...context,
+        commandSource: "feishu",
+      },
+    },
+    {
+      agentId: "main",
+      sessionKey,
+    },
+  );
+
+  return true;
+}