@fased/fased 0.1.36 → 0.1.37

package/extensions/feishu/src/onboarding.ts

@@ -1,430 +0,0 @@
-import type {
-  ChannelOnboardingAdapter,
-  ChannelOnboardingDmPolicy,
-  FasedAgentConfig,
-  DmPolicy,
-  WizardPrompter,
-} from "fased/plugin-sdk";
-import { addWildcardAllowFrom, DEFAULT_ACCOUNT_ID, formatDocsLink } from "fased/plugin-sdk";
-import { resolveFeishuCredentials } from "./accounts.js";
-import { probeFeishu } from "./probe.js";
-import type { FeishuConfig } from "./types.js";
-
-const channel = "feishu" as const;
-
-function setFeishuDmPolicy(cfg: FasedAgentConfig, dmPolicy: DmPolicy): FasedAgentConfig {
-  const allowFrom =
-    dmPolicy === "open"
-      ? addWildcardAllowFrom(cfg.channels?.feishu?.allowFrom)?.map((entry) => String(entry))
-      : undefined;
-  return {
-    ...cfg,
-    channels: {
-      ...cfg.channels,
-      feishu: {
-        ...cfg.channels?.feishu,
-        dmPolicy,
-        ...(allowFrom ? { allowFrom } : {}),
-      },
-    },
-  };
-}
-
-function setFeishuAllowFrom(cfg: FasedAgentConfig, allowFrom: string[]): FasedAgentConfig {
-  return {
-    ...cfg,
-    channels: {
-      ...cfg.channels,
-      feishu: {
-        ...cfg.channels?.feishu,
-        allowFrom,
-      },
-    },
-  };
-}
-
-function parseAllowFromInput(raw: string): string[] {
-  return raw
-    .split(/[\n,;]+/g)
-    .map((entry) => entry.trim())
-    .filter(Boolean);
-}
-
-async function promptFeishuAllowFrom(params: {
-  cfg: FasedAgentConfig;
-  prompter: WizardPrompter;
-}): Promise<FasedAgentConfig> {
-  const existing = params.cfg.channels?.feishu?.allowFrom ?? [];
-  await params.prompter.note(
-    [
-      "Allowlist Feishu DMs by open_id or user_id.",
-      "You can find user open_id in Feishu admin console or via API.",
-      "Examples:",
-      "- ou_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
-      "- on_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
-    ].join("\n"),
-    "Feishu allowlist",
-  );
-
-  while (true) {
-    const entry = await params.prompter.text({
-      message: "Feishu allowFrom (user open_ids)",
-      placeholder: "ou_xxxxx, ou_yyyyy",
-      initialValue: existing[0] ? String(existing[0]) : undefined,
-      validate: (value) => (String(value ?? "").trim() ? undefined : "Required"),
-    });
-    const parts = parseAllowFromInput(String(entry));
-    if (parts.length === 0) {
-      await params.prompter.note("Enter at least one user.", "Feishu allowlist");
-      continue;
-    }
-
-    const unique = [
-      ...new Set([
-        ...existing.map((v: string | number) => String(v).trim()).filter(Boolean),
-        ...parts,
-      ]),
-    ];
-    return setFeishuAllowFrom(params.cfg, unique);
-  }
-}
-
-async function noteFeishuCredentialHelp(prompter: WizardPrompter): Promise<void> {
-  await prompter.note(
-    [
-      "1) Go to Feishu Open Platform (open.feishu.cn)",
-      "2) Create a self-built app",
-      "3) Get App ID and App Secret from Credentials page",
-      "4) Enable required permissions: im:message, im:chat, contact:user.base:readonly",
-      "5) Publish the app or add it to a test group",
-      "Tip: you can also set FEISHU_APP_ID / FEISHU_APP_SECRET env vars.",
-      `Docs: ${formatDocsLink("/channels/feishu", "feishu")}`,
-    ].join("\n"),
-    "Feishu credentials",
-  );
-}
-
-async function promptFeishuCredentials(prompter: WizardPrompter): Promise<{
-  appId: string;
-  appSecret: string;
-}> {
-  const appId = String(
-    await prompter.text({
-      message: "Enter Feishu App ID",
-      validate: (value) => (value?.trim() ? undefined : "Required"),
-    }),
-  ).trim();
-  const appSecret = String(
-    await prompter.text({
-      message: "Enter Feishu App Secret",
-      validate: (value) => (value?.trim() ? undefined : "Required"),
-    }),
-  ).trim();
-  return { appId, appSecret };
-}
-
-function setFeishuGroupPolicy(
-  cfg: FasedAgentConfig,
-  groupPolicy: "open" | "allowlist" | "disabled",
-): FasedAgentConfig {
-  return {
-    ...cfg,
-    channels: {
-      ...cfg.channels,
-      feishu: {
-        ...cfg.channels?.feishu,
-        enabled: true,
-        groupPolicy,
-      },
-    },
-  };
-}
-
-function setFeishuGroupAllowFrom(
-  cfg: FasedAgentConfig,
-  groupAllowFrom: string[],
-): FasedAgentConfig {
-  return {
-    ...cfg,
-    channels: {
-      ...cfg.channels,
-      feishu: {
-        ...cfg.channels?.feishu,
-        groupAllowFrom,
-      },
-    },
-  };
-}
-
-const dmPolicy: ChannelOnboardingDmPolicy = {
-  label: "Feishu",
-  channel,
-  policyKey: "channels.feishu.dmPolicy",
-  allowFromKey: "channels.feishu.allowFrom",
-  getCurrent: (cfg) => (cfg.channels?.feishu as FeishuConfig | undefined)?.dmPolicy ?? "pairing",
-  setPolicy: (cfg, policy) => setFeishuDmPolicy(cfg, policy),
-  promptAllowFrom: promptFeishuAllowFrom,
-};
-
-export const feishuOnboardingAdapter: ChannelOnboardingAdapter = {
-  channel,
-  uiSetup: {
-    title: "Feishu",
-    detail: "App credentials.",
-    notes: [
-      "1) Go to Feishu Open Platform (open.feishu.cn)",
-      "2) Create a self-built app",
-      "3) Get App ID and App Secret from Credentials page",
-      "4) Enable required permissions: im:message, im:chat, contact:user.base:readonly",
-      "5) Publish the app or add it to a test group",
-      "Tip: you can also set FEISHU_APP_ID / FEISHU_APP_SECRET env vars.",
-    ],
-    fields: [
-      {
-        label: "App ID",
-        path: ["channels", "feishu", "appId"],
-        placeholder: "cli_xxxxx",
-      },
-      {
-        label: "App Secret",
-        path: ["channels", "feishu", "appSecret"],
-        placeholder: "App Secret",
-        kind: "password",
-      },
-      {
-        label: "Domain",
-        path: ["channels", "feishu", "domain"],
-        kind: "select",
-        options: [
-          { label: "Feishu (China)", value: "feishu" },
-          { label: "Lark (International)", value: "lark" },
-        ],
-      },
-      {
-        label: "Connection mode",
-        path: ["channels", "feishu", "connectionMode"],
-        kind: "select",
-        options: [
-          { label: "WebSocket", value: "websocket" },
-          { label: "Webhook", value: "webhook" },
-        ],
-      },
-      {
-        label: "Verification token",
-        path: ["channels", "feishu", "verificationToken"],
-        placeholder: "Required for webhook mode",
-        kind: "password",
-      },
-      {
-        label: "Encrypt key",
-        path: ["channels", "feishu", "encryptKey"],
-        placeholder: "Optional",
-        kind: "password",
-      },
-      {
-        label: "Webhook path",
-        path: ["channels", "feishu", "webhookPath"],
-        placeholder: "/feishu/events",
-      },
-      {
-        label: "Group policy",
-        path: ["channels", "feishu", "groupPolicy"],
-        kind: "select",
-        options: [
-          { label: "Allowlist", value: "allowlist" },
-          { label: "Open", value: "open" },
-          { label: "Disabled", value: "disabled" },
-        ],
-      },
-      {
-        label: "Group allowlist",
-        path: ["channels", "feishu", "groupAllowFrom"],
-        placeholder: "oc_xxxxx, oc_yyyyy",
-        kind: "list",
-      },
-    ],
-  },
-  getStatus: async ({ cfg }) => {
-    const feishuCfg = cfg.channels?.feishu as FeishuConfig | undefined;
-    const configured = Boolean(resolveFeishuCredentials(feishuCfg));
-
-    // Try to probe if configured
-    let probeResult = null;
-    if (configured && feishuCfg) {
-      try {
-        probeResult = await probeFeishu(feishuCfg);
-      } catch {
-        // Ignore probe errors
-      }
-    }
-
-    const statusLines: string[] = [];
-    if (!configured) {
-      statusLines.push("Feishu: needs app credentials");
-    } else if (probeResult?.ok) {
-      statusLines.push(
-        `Feishu: connected as ${probeResult.botName ?? probeResult.botOpenId ?? "bot"}`,
-      );
-    } else {
-      statusLines.push("Feishu: configured (connection not verified)");
-    }
-
-    return {
-      channel,
-      configured,
-      statusLines,
-      selectionHint: configured ? "configured" : "needs app creds",
-      quickstartScore: configured ? 2 : 0,
-    };
-  },
-
-  configure: async ({ cfg, prompter }) => {
-    const feishuCfg = cfg.channels?.feishu as FeishuConfig | undefined;
-    const resolved = resolveFeishuCredentials(feishuCfg);
-    const hasConfigCreds = Boolean(feishuCfg?.appId?.trim() && feishuCfg?.appSecret?.trim());
-    const canUseEnv = Boolean(
-      !hasConfigCreds && process.env.FEISHU_APP_ID?.trim() && process.env.FEISHU_APP_SECRET?.trim(),
-    );
-
-    let next = cfg;
-    let appId: string | null = null;
-    let appSecret: string | null = null;
-
-    if (!resolved) {
-      await noteFeishuCredentialHelp(prompter);
-    }
-
-    if (canUseEnv) {
-      const keepEnv = await prompter.confirm({
-        message: "FEISHU_APP_ID + FEISHU_APP_SECRET detected. Use env vars?",
-        initialValue: true,
-      });
-      if (keepEnv) {
-        next = {
-          ...next,
-          channels: {
-            ...next.channels,
-            feishu: { ...next.channels?.feishu, enabled: true },
-          },
-        };
-      } else {
-        const entered = await promptFeishuCredentials(prompter);
-        appId = entered.appId;
-        appSecret = entered.appSecret;
-      }
-    } else if (hasConfigCreds) {
-      const keep = await prompter.confirm({
-        message: "Feishu credentials already configured. Keep them?",
-        initialValue: true,
-      });
-      if (!keep) {
-        const entered = await promptFeishuCredentials(prompter);
-        appId = entered.appId;
-        appSecret = entered.appSecret;
-      }
-    } else {
-      const entered = await promptFeishuCredentials(prompter);
-      appId = entered.appId;
-      appSecret = entered.appSecret;
-    }
-
-    if (appId && appSecret) {
-      next = {
-        ...next,
-        channels: {
-          ...next.channels,
-          feishu: {
-            ...next.channels?.feishu,
-            enabled: true,
-            appId,
-            appSecret,
-          },
-        },
-      };
-
-      // Test connection
-      const testCfg = next.channels?.feishu as FeishuConfig;
-      try {
-        const probe = await probeFeishu(testCfg);
-        if (probe.ok) {
-          await prompter.note(
-            `Connected as ${probe.botName ?? probe.botOpenId ?? "bot"}`,
-            "Feishu connection test",
-          );
-        } else {
-          await prompter.note(
-            `Connection failed: ${probe.error ?? "unknown error"}`,
-            "Feishu connection test",
-          );
-        }
-      } catch (err) {
-        await prompter.note(`Connection test failed: ${String(err)}`, "Feishu connection test");
-      }
-    }
-
-    // Domain selection
-    const currentDomain = (next.channels?.feishu as FeishuConfig | undefined)?.domain ?? "feishu";
-    const domain = await prompter.select({
-      message: "Which Feishu domain?",
-      options: [
-        { value: "feishu", label: "Feishu (feishu.cn) - China" },
-        { value: "lark", label: "Lark (larksuite.com) - International" },
-      ],
-      initialValue: currentDomain,
-    });
-    if (domain) {
-      next = {
-        ...next,
-        channels: {
-          ...next.channels,
-          feishu: {
-            ...next.channels?.feishu,
-            domain: domain as "feishu" | "lark",
-          },
-        },
-      };
-    }
-
-    // Group policy
-    const groupPolicy = await prompter.select({
-      message: "Group chat policy",
-      options: [
-        { value: "allowlist", label: "Allowlist - only respond in specific groups" },
-        { value: "open", label: "Open - respond in all groups (requires mention)" },
-        { value: "disabled", label: "Disabled - don't respond in groups" },
-      ],
-      initialValue: (next.channels?.feishu as FeishuConfig | undefined)?.groupPolicy ?? "allowlist",
-    });
-    if (groupPolicy) {
-      next = setFeishuGroupPolicy(next, groupPolicy as "open" | "allowlist" | "disabled");
-    }
-
-    // Group allowlist if needed
-    if (groupPolicy === "allowlist") {
-      const existing = (next.channels?.feishu as FeishuConfig | undefined)?.groupAllowFrom ?? [];
-      const entry = await prompter.text({
-        message: "Group chat allowlist (chat_ids)",
-        placeholder: "oc_xxxxx, oc_yyyyy",
-        initialValue: existing.length > 0 ? existing.map(String).join(", ") : undefined,
-      });
-      if (entry) {
-        const parts = parseAllowFromInput(String(entry));
-        if (parts.length > 0) {
-          next = setFeishuGroupAllowFrom(next, parts);
-        }
-      }
-    }
-
-    return { cfg: next, accountId: DEFAULT_ACCOUNT_ID };
-  },
-
-  dmPolicy,
-
-  disable: (cfg) => ({
-    ...cfg,
-    channels: {
-      ...cfg.channels,
-      feishu: { ...cfg.channels?.feishu, enabled: false },
-    },
-  }),
-};

package/extensions/feishu/src/outbound.ts

@@ -1,56 +0,0 @@
-import type { ChannelOutboundAdapter } from "fased/plugin-sdk";
-import { sendMediaFeishu } from "./media.js";
-import { getFeishuRuntime } from "./runtime.js";
-import { sendMessageFeishu } from "./send.js";
-
-export const feishuOutbound: ChannelOutboundAdapter = {
-  deliveryMode: "direct",
-  chunker: (text, limit) => getFeishuRuntime().channel.text.chunkMarkdownText(text, limit),
-  chunkerMode: "markdown",
-  textChunkLimit: 4000,
-  sendText: async ({ cfg, to, text, accountId }) => {
-    const result = await sendMessageFeishu({ cfg, to, text, accountId: accountId ?? undefined });
-    return { channel: "feishu", ...result };
-  },
-  sendMedia: async ({ cfg, to, text, mediaUrl, accountId, mediaLocalRoots }) => {
-    // Send text first if provided
-    if (text?.trim()) {
-      await sendMessageFeishu({ cfg, to, text, accountId: accountId ?? undefined });
-    }
-
-    // Upload and send media if URL or local path provided
-    if (mediaUrl) {
-      try {
-        const result = await sendMediaFeishu({
-          cfg,
-          to,
-          mediaUrl,
-          accountId: accountId ?? undefined,
-          mediaLocalRoots,
-        });
-        return { channel: "feishu", ...result };
-      } catch (err) {
-        // Log the error for debugging
-        console.error(`[feishu] sendMediaFeishu failed:`, err);
-        // Fallback to URL link if upload fails
-        const fallbackText = `📎 ${mediaUrl}`;
-        const result = await sendMessageFeishu({
-          cfg,
-          to,
-          text: fallbackText,
-          accountId: accountId ?? undefined,
-        });
-        return { channel: "feishu", ...result };
-      }
-    }
-
-    // No media URL, just return text result
-    const result = await sendMessageFeishu({
-      cfg,
-      to,
-      text: text ?? "",
-      accountId: accountId ?? undefined,
-    });
-    return { channel: "feishu", ...result };
-  },
-};

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

@@ -1,52 +0,0 @@
-import { Type, type Static } from "@sinclair/typebox";
-
-const TokenType = Type.Union([
-  Type.Literal("doc"),
-  Type.Literal("docx"),
-  Type.Literal("sheet"),
-  Type.Literal("bitable"),
-  Type.Literal("folder"),
-  Type.Literal("file"),
-  Type.Literal("wiki"),
-  Type.Literal("mindnote"),
-]);
-
-const MemberType = Type.Union([
-  Type.Literal("email"),
-  Type.Literal("openid"),
-  Type.Literal("userid"),
-  Type.Literal("unionid"),
-  Type.Literal("openchat"),
-  Type.Literal("opendepartmentid"),
-]);
-
-const Permission = Type.Union([
-  Type.Literal("view"),
-  Type.Literal("edit"),
-  Type.Literal("full_access"),
-]);
-
-export const FeishuPermSchema = Type.Union([
-  Type.Object({
-    action: Type.Literal("list"),
-    token: Type.String({ description: "File token" }),
-    type: TokenType,
-  }),
-  Type.Object({
-    action: Type.Literal("add"),
-    token: Type.String({ description: "File token" }),
-    type: TokenType,
-    member_type: MemberType,
-    member_id: Type.String({ description: "Member ID (email, open_id, user_id, etc.)" }),
-    perm: Permission,
-  }),
-  Type.Object({
-    action: Type.Literal("remove"),
-    token: Type.String({ description: "File token" }),
-    type: TokenType,
-    member_type: MemberType,
-    member_id: Type.String({ description: "Member ID to remove" }),
-  }),
-]);
-
-export type FeishuPermParams = Static<typeof FeishuPermSchema>;