@fased/fased 0.1.36 → 0.1.37

package/extensions/feishu/src/drive-schema.ts

@@ -1,46 +0,0 @@
-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/extensions/feishu/src/drive.ts

@@ -1,232 +0,0 @@
-import type * as Lark from "@larksuiteoapi/node-sdk";
-import type { FasedAgentPluginApi } from "fased/plugin-sdk";
-import { listEnabledFeishuAccounts } from "./accounts.js";
-import { FeishuDriveSchema, type FeishuDriveParams } from "./drive-schema.js";
-import { createFeishuToolClient, resolveAnyEnabledFeishuToolsConfig } from "./tool-account.js";
-
-// ============ Helpers ============
-
-function json(data: unknown) {
-  return {
-    content: [{ type: "text" as const, text: JSON.stringify(data, null, 2) }],
-    details: data,
-  };
-}
-
-// ============ 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: FasedAgentPluginApi) {
-  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 json(await listFolder(client, p.folder_token));
-              case "info":
-                return json(await getFileInfo(client, p.file_token));
-              case "create_folder":
-                return json(await createFolder(client, p.name, p.folder_token));
-              case "move":
-                return json(await moveFile(client, p.file_token, p.type, p.folder_token));
-              case "delete":
-                return json(await deleteFile(client, p.file_token, p.type));
-              default:
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any -- exhaustive check fallback
-                return json({ error: `Unknown action: ${(p as any).action}` });
-            }
-          } catch (err) {
-            return json({ error: err instanceof Error ? err.message : String(err) });
-          }
-        },
-      };
-    },
-    { name: "feishu_drive" },
-  );
-
-  api.logger.debug?.(`feishu_drive: Registered feishu_drive tool`);
-}

package/extensions/feishu/src/dynamic-agent.ts

@@ -1,131 +0,0 @@
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import type { FasedAgentConfig, PluginRuntime } from "fased/plugin-sdk";
-import type { DynamicAgentCreationConfig } from "./types.js";
-
-export type MaybeCreateDynamicAgentResult = {
-  created: boolean;
-  updatedCfg: FasedAgentConfig;
-  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: FasedAgentConfig;
-  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: FasedAgentConfig = {
-      ...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 ?? "~/.fased/workspace-{agentId}";
-  const agentDirTemplate = dynamicCfg.agentDirTemplate ?? "~/.fased/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: FasedAgentConfig = {
-    ...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/extensions/feishu/src/external-keys.ts

@@ -1,19 +0,0 @@
-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;
-}