@fased/fased 0.1.36 → 0.1.37

package/extensions/feishu/src/streaming-card.ts

@@ -1,218 +0,0 @@
-/**
- * Feishu Streaming Card - Card Kit streaming API for real-time text output
- */
-
-import type { Client } from "@larksuiteoapi/node-sdk";
-import type { FeishuDomain } from "./types.js";
-
-type Credentials = { appId: string; appSecret: string; domain?: FeishuDomain };
-type CardState = { cardId: string; messageId: string; sequence: number; currentText: string };
-
-// Token cache (keyed by domain + appId)
-const tokenCache = new Map<string, { token: string; expiresAt: number }>();
-
-function resolveApiBase(domain?: FeishuDomain): string {
-  if (domain === "lark") {
-    return "https://open.larksuite.com/open-apis";
-  }
-  if (domain && domain !== "feishu" && domain.startsWith("http")) {
-    return `${domain.replace(/\/+$/, "")}/open-apis`;
-  }
-  return "https://open.feishu.cn/open-apis";
-}
-
-async function getToken(creds: Credentials): Promise<string> {
-  const key = `${creds.domain ?? "feishu"}|${creds.appId}`;
-  const cached = tokenCache.get(key);
-  if (cached && cached.expiresAt > Date.now() + 60000) {
-    return cached.token;
-  }
-
-  const res = await fetch(`${resolveApiBase(creds.domain)}/auth/v3/tenant_access_token/internal`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ app_id: creds.appId, app_secret: creds.appSecret }),
-  });
-  const data = (await res.json()) as {
-    code: number;
-    msg: string;
-    tenant_access_token?: string;
-    expire?: number;
-  };
-  if (data.code !== 0 || !data.tenant_access_token) {
-    throw new Error(`Token error: ${data.msg}`);
-  }
-  tokenCache.set(key, {
-    token: data.tenant_access_token,
-    expiresAt: Date.now() + (data.expire ?? 7200) * 1000,
-  });
-  return data.tenant_access_token;
-}
-
-function truncateSummary(text: string, max = 50): string {
-  if (!text) {
-    return "";
-  }
-  const clean = text.replace(/\n/g, " ").trim();
-  return clean.length <= max ? clean : clean.slice(0, max - 3) + "...";
-}
-
-/** Streaming card session manager */
-export class FeishuStreamingSession {
-  private client: Client;
-  private creds: Credentials;
-  private state: CardState | null = null;
-  private queue: Promise<void> = Promise.resolve();
-  private closed = false;
-  private log?: (msg: string) => void;
-  private lastUpdateTime = 0;
-  private pendingText: string | null = null;
-  private updateThrottleMs = 100; // Throttle updates to max 10/sec
-
-  constructor(client: Client, creds: Credentials, log?: (msg: string) => void) {
-    this.client = client;
-    this.creds = creds;
-    this.log = log;
-  }
-
-  async start(
-    receiveId: string,
-    receiveIdType: "open_id" | "user_id" | "union_id" | "email" | "chat_id" = "chat_id",
-  ): Promise<void> {
-    if (this.state) {
-      return;
-    }
-
-    const apiBase = resolveApiBase(this.creds.domain);
-    const cardJson = {
-      schema: "2.0",
-      config: {
-        streaming_mode: true,
-        summary: { content: "[Generating...]" },
-        streaming_config: { print_frequency_ms: { default: 50 }, print_step: { default: 2 } },
-      },
-      body: {
-        elements: [{ tag: "markdown", content: "⏳ Thinking...", element_id: "content" }],
-      },
-    };
-
-    // Create card entity
-    const createRes = await fetch(`${apiBase}/cardkit/v1/cards`, {
-      method: "POST",
-      headers: {
-        Authorization: `Bearer ${await getToken(this.creds)}`,
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify({ type: "card_json", data: JSON.stringify(cardJson) }),
-    });
-    const createData = (await createRes.json()) as {
-      code: number;
-      msg: string;
-      data?: { card_id: string };
-    };
-    if (createData.code !== 0 || !createData.data?.card_id) {
-      throw new Error(`Create card failed: ${createData.msg}`);
-    }
-    const cardId = createData.data.card_id;
-
-    // Send card message
-    const sendRes = await this.client.im.message.create({
-      params: { receive_id_type: receiveIdType },
-      data: {
-        receive_id: receiveId,
-        msg_type: "interactive",
-        content: JSON.stringify({ type: "card", data: { card_id: cardId } }),
-      },
-    });
-    if (sendRes.code !== 0 || !sendRes.data?.message_id) {
-      throw new Error(`Send card failed: ${sendRes.msg}`);
-    }
-
-    this.state = { cardId, messageId: sendRes.data.message_id, sequence: 1, currentText: "" };
-    this.log?.(`Started streaming: cardId=${cardId}, messageId=${sendRes.data.message_id}`);
-  }
-
-  private async updateCardContent(text: string, onError?: (error: unknown) => void): Promise<void> {
-    if (!this.state) {
-      return;
-    }
-    const apiBase = resolveApiBase(this.creds.domain);
-    this.state.sequence += 1;
-    await fetch(`${apiBase}/cardkit/v1/cards/${this.state.cardId}/elements/content/content`, {
-      method: "PUT",
-      headers: {
-        Authorization: `Bearer ${await getToken(this.creds)}`,
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify({
-        content: text,
-        sequence: this.state.sequence,
-        uuid: `s_${this.state.cardId}_${this.state.sequence}`,
-      }),
-    }).catch((error) => onError?.(error));
-  }
-
-  async update(text: string): Promise<void> {
-    if (!this.state || this.closed) {
-      return;
-    }
-    // Throttle: skip if updated recently, but remember pending text
-    const now = Date.now();
-    if (now - this.lastUpdateTime < this.updateThrottleMs) {
-      this.pendingText = text;
-      return;
-    }
-    this.pendingText = null;
-    this.lastUpdateTime = now;
-
-    this.queue = this.queue.then(async () => {
-      if (!this.state || this.closed) {
-        return;
-      }
-      this.state.currentText = text;
-      await this.updateCardContent(text, (e) => this.log?.(`Update failed: ${String(e)}`));
-    });
-    await this.queue;
-  }
-
-  async close(finalText?: string): Promise<void> {
-    if (!this.state || this.closed) {
-      return;
-    }
-    this.closed = true;
-    await this.queue;
-
-    // Use finalText, or pending throttled text, or current text
-    const text = finalText ?? this.pendingText ?? this.state.currentText;
-    const apiBase = resolveApiBase(this.creds.domain);
-
-    // Only send final update if content differs from what's already displayed
-    if (text && text !== this.state.currentText) {
-      await this.updateCardContent(text);
-      this.state.currentText = text;
-    }
-
-    // Close streaming mode
-    this.state.sequence += 1;
-    await fetch(`${apiBase}/cardkit/v1/cards/${this.state.cardId}/settings`, {
-      method: "PATCH",
-      headers: {
-        Authorization: `Bearer ${await getToken(this.creds)}`,
-        "Content-Type": "application/json; charset=utf-8",
-      },
-      body: JSON.stringify({
-        settings: JSON.stringify({
-          config: { streaming_mode: false, summary: { content: truncateSummary(text) } },
-        }),
-        sequence: this.state.sequence,
-        uuid: `c_${this.state.cardId}_${this.state.sequence}`,
-      }),
-    }).catch((e) => this.log?.(`Close failed: ${String(e)}`));
-
-    this.log?.(`Closed streaming: cardId=${this.state.cardId}`);
-  }
-
-  isActive(): boolean {
-    return this.state !== null && !this.closed;
-  }
-}

package/extensions/feishu/src/targets.ts

@@ -1,78 +0,0 @@
-import type { FeishuIdType } from "./types.js";
-
-const CHAT_ID_PREFIX = "oc_";
-const OPEN_ID_PREFIX = "ou_";
-const USER_ID_REGEX = /^[a-zA-Z0-9_-]+$/;
-
-export function detectIdType(id: string): FeishuIdType | null {
-  const trimmed = id.trim();
-  if (trimmed.startsWith(CHAT_ID_PREFIX)) {
-    return "chat_id";
-  }
-  if (trimmed.startsWith(OPEN_ID_PREFIX)) {
-    return "open_id";
-  }
-  if (USER_ID_REGEX.test(trimmed)) {
-    return "user_id";
-  }
-  return null;
-}
-
-export function normalizeFeishuTarget(raw: string): string | null {
-  const trimmed = raw.trim();
-  if (!trimmed) {
-    return null;
-  }
-
-  const lowered = trimmed.toLowerCase();
-  if (lowered.startsWith("chat:")) {
-    return trimmed.slice("chat:".length).trim() || null;
-  }
-  if (lowered.startsWith("user:")) {
-    return trimmed.slice("user:".length).trim() || null;
-  }
-  if (lowered.startsWith("open_id:")) {
-    return trimmed.slice("open_id:".length).trim() || null;
-  }
-
-  return trimmed;
-}
-
-export function formatFeishuTarget(id: string, type?: FeishuIdType): string {
-  const trimmed = id.trim();
-  if (type === "chat_id" || trimmed.startsWith(CHAT_ID_PREFIX)) {
-    return `chat:${trimmed}`;
-  }
-  if (type === "open_id" || trimmed.startsWith(OPEN_ID_PREFIX)) {
-    return `user:${trimmed}`;
-  }
-  return trimmed;
-}
-
-export function resolveReceiveIdType(id: string): "chat_id" | "open_id" | "user_id" {
-  const trimmed = id.trim();
-  if (trimmed.startsWith(CHAT_ID_PREFIX)) {
-    return "chat_id";
-  }
-  if (trimmed.startsWith(OPEN_ID_PREFIX)) {
-    return "open_id";
-  }
-  return "user_id";
-}
-
-export function looksLikeFeishuId(raw: string): boolean {
-  const trimmed = raw.trim();
-  if (!trimmed) {
-    return false;
-  }
-  if (/^(chat|user|open_id):/i.test(trimmed)) {
-    return true;
-  }
-  if (trimmed.startsWith(CHAT_ID_PREFIX)) {
-    return true;
-  }
-  if (trimmed.startsWith(OPEN_ID_PREFIX)) {
-    return true;
-  }
-  return false;
-}

package/extensions/feishu/src/tool-account.ts

@@ -1,58 +0,0 @@
-import type * as Lark from "@larksuiteoapi/node-sdk";
-import type { FasedAgentPluginApi } from "fased/plugin-sdk";
-import { resolveFeishuAccount } from "./accounts.js";
-import { createFeishuClient } from "./client.js";
-import { resolveToolsConfig } from "./tools-config.js";
-import type { FeishuToolsConfig, ResolvedFeishuAccount } from "./types.js";
-
-type AccountAwareParams = { accountId?: string };
-
-function normalizeOptionalAccountId(value: string | undefined): string | undefined {
-  const trimmed = value?.trim();
-  return trimmed ? trimmed : undefined;
-}
-
-export function resolveFeishuToolAccount(params: {
-  api: Pick<FasedAgentPluginApi, "config">;
-  executeParams?: AccountAwareParams;
-  defaultAccountId?: string;
-}): ResolvedFeishuAccount {
-  if (!params.api.config) {
-    throw new Error("Feishu config unavailable");
-  }
-  return resolveFeishuAccount({
-    cfg: params.api.config,
-    accountId:
-      normalizeOptionalAccountId(params.executeParams?.accountId) ??
-      normalizeOptionalAccountId(params.defaultAccountId),
-  });
-}
-
-export function createFeishuToolClient(params: {
-  api: Pick<FasedAgentPluginApi, "config">;
-  executeParams?: AccountAwareParams;
-  defaultAccountId?: string;
-}): Lark.Client {
-  return createFeishuClient(resolveFeishuToolAccount(params));
-}
-
-export function resolveAnyEnabledFeishuToolsConfig(
-  accounts: ResolvedFeishuAccount[],
-): Required<FeishuToolsConfig> {
-  const merged: Required<FeishuToolsConfig> = {
-    doc: false,
-    wiki: false,
-    drive: false,
-    perm: false,
-    scopes: false,
-  };
-  for (const account of accounts) {
-    const cfg = resolveToolsConfig(account.config.tools);
-    merged.doc = merged.doc || cfg.doc;
-    merged.wiki = merged.wiki || cfg.wiki;
-    merged.drive = merged.drive || cfg.drive;
-    merged.perm = merged.perm || cfg.perm;
-    merged.scopes = merged.scopes || cfg.scopes;
-  }
-  return merged;
-}

package/extensions/feishu/src/tools-config.ts

@@ -1,21 +0,0 @@
-import type { FeishuToolsConfig } from "./types.js";
-
-/**
- * Default tool configuration.
- * - doc, wiki, drive, scopes: enabled by default
- * - perm: disabled by default (sensitive operation)
- */
-export const DEFAULT_TOOLS_CONFIG: Required<FeishuToolsConfig> = {
-  doc: true,
-  wiki: true,
-  drive: true,
-  perm: false,
-  scopes: true,
-};
-
-/**
- * Resolve tools config with defaults.
- */
-export function resolveToolsConfig(cfg?: FeishuToolsConfig): Required<FeishuToolsConfig> {
-  return { ...DEFAULT_TOOLS_CONFIG, ...cfg };
-}

package/extensions/feishu/src/types.ts

@@ -1,81 +0,0 @@
-import type { BaseProbeResult } from "fased/plugin-sdk";
-import type {
-  FeishuConfigSchema,
-  FeishuGroupSchema,
-  FeishuAccountConfigSchema,
-  z,
-} from "./config-schema.js";
-import type { MentionTarget } from "./mention.js";
-
-export type FeishuConfig = z.infer<typeof FeishuConfigSchema>;
-export type FeishuGroupConfig = z.infer<typeof FeishuGroupSchema>;
-export type FeishuAccountConfig = z.infer<typeof FeishuAccountConfigSchema>;
-
-export type FeishuDomain = "feishu" | "lark" | (string & {});
-export type FeishuConnectionMode = "websocket" | "webhook";
-
-export type ResolvedFeishuAccount = {
-  accountId: string;
-  enabled: boolean;
-  configured: boolean;
-  name?: string;
-  appId?: string;
-  appSecret?: string;
-  encryptKey?: string;
-  verificationToken?: string;
-  domain: FeishuDomain;
-  /** Merged config (top-level defaults + account-specific overrides) */
-  config: FeishuConfig;
-};
-
-export type FeishuIdType = "open_id" | "user_id" | "union_id" | "chat_id";
-
-export type FeishuMessageContext = {
-  chatId: string;
-  messageId: string;
-  senderId: string;
-  senderOpenId: string;
-  senderName?: string;
-  chatType: "p2p" | "group";
-  mentionedBot: boolean;
-  rootId?: string;
-  parentId?: string;
-  content: string;
-  contentType: string;
-  /** Mention forward targets (excluding the bot itself) */
-  mentionTargets?: MentionTarget[];
-  /** Extracted message body (after removing @ placeholders) */
-  mentionMessageBody?: string;
-};
-
-export type FeishuSendResult = {
-  messageId: string;
-  chatId: string;
-};
-
-export type FeishuProbeResult = BaseProbeResult<string> & {
-  appId?: string;
-  botName?: string;
-  botOpenId?: string;
-};
-
-export type FeishuMediaInfo = {
-  path: string;
-  contentType?: string;
-  placeholder: string;
-};
-
-export type FeishuToolsConfig = {
-  doc?: boolean;
-  wiki?: boolean;
-  drive?: boolean;
-  perm?: boolean;
-  scopes?: boolean;
-};
-
-export type DynamicAgentCreationConfig = {
-  enabled?: boolean;
-  workspaceTemplate?: string;
-  agentDirTemplate?: string;
-  maxAgents?: number;
-};

package/extensions/feishu/src/typing.ts

@@ -1,80 +0,0 @@
-import type { FasedAgentConfig } from "fased/plugin-sdk";
-import { resolveFeishuAccount } from "./accounts.js";
-import { createFeishuClient } from "./client.js";
-
-// Feishu emoji types for typing indicator
-// See: https://open.feishu.cn/document/server-docs/im-v1/message-reaction/emojis-introduce
-// Full list: https://github.com/go-lark/lark/blob/main/emoji.go
-const TYPING_EMOJI = "Typing"; // Typing indicator emoji
-
-export type TypingIndicatorState = {
-  messageId: string;
-  reactionId: string | null;
-};
-
-/**
- * Add a typing indicator (reaction) to a message
- */
-export async function addTypingIndicator(params: {
-  cfg: FasedAgentConfig;
-  messageId: string;
-  accountId?: string;
-}): Promise<TypingIndicatorState> {
-  const { cfg, messageId, accountId } = params;
-  const account = resolveFeishuAccount({ cfg, accountId });
-  if (!account.configured) {
-    return { messageId, reactionId: null };
-  }
-
-  const client = createFeishuClient(account);
-
-  try {
-    const response = await client.im.messageReaction.create({
-      path: { message_id: messageId },
-      data: {
-        reaction_type: { emoji_type: TYPING_EMOJI },
-      },
-    });
-
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- SDK response type
-    const reactionId = (response as any)?.data?.reaction_id ?? null;
-    return { messageId, reactionId };
-  } catch (err) {
-    // Silently fail - typing indicator is not critical
-    console.log(`[feishu] failed to add typing indicator: ${err}`);
-    return { messageId, reactionId: null };
-  }
-}
-
-/**
- * Remove a typing indicator (reaction) from a message
- */
-export async function removeTypingIndicator(params: {
-  cfg: FasedAgentConfig;
-  state: TypingIndicatorState;
-  accountId?: string;
-}): Promise<void> {
-  const { cfg, state, accountId } = params;
-  if (!state.reactionId) {
-    return;
-  }
-
-  const account = resolveFeishuAccount({ cfg, accountId });
-  if (!account.configured) {
-    return;
-  }
-
-  const client = createFeishuClient(account);
-
-  try {
-    await client.im.messageReaction.delete({
-      path: {
-        message_id: state.messageId,
-        reaction_id: state.reactionId,
-      },
-    });
-  } catch (err) {
-    // Silently fail - cleanup is not critical
-    console.log(`[feishu] failed to remove typing indicator: ${err}`);
-  }
-}

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

@@ -1,55 +0,0 @@
-import { Type, type Static } from "@sinclair/typebox";
-
-export const FeishuWikiSchema = Type.Union([
-  Type.Object({
-    action: Type.Literal("spaces"),
-  }),
-  Type.Object({
-    action: Type.Literal("nodes"),
-    space_id: Type.String({ description: "Knowledge space ID" }),
-    parent_node_token: Type.Optional(
-      Type.String({ description: "Parent node token (optional, omit for root)" }),
-    ),
-  }),
-  Type.Object({
-    action: Type.Literal("get"),
-    token: Type.String({ description: "Wiki node token (from URL /wiki/XXX)" }),
-  }),
-  Type.Object({
-    action: Type.Literal("search"),
-    query: Type.String({ description: "Search query" }),
-    space_id: Type.Optional(Type.String({ description: "Limit search to this space (optional)" })),
-  }),
-  Type.Object({
-    action: Type.Literal("create"),
-    space_id: Type.String({ description: "Knowledge space ID" }),
-    title: Type.String({ description: "Node title" }),
-    obj_type: Type.Optional(
-      Type.Union([Type.Literal("docx"), Type.Literal("sheet"), Type.Literal("bitable")], {
-        description: "Object type (default: docx)",
-      }),
-    ),
-    parent_node_token: Type.Optional(
-      Type.String({ description: "Parent node token (optional, omit for root)" }),
-    ),
-  }),
-  Type.Object({
-    action: Type.Literal("move"),
-    space_id: Type.String({ description: "Source knowledge space ID" }),
-    node_token: Type.String({ description: "Node token to move" }),
-    target_space_id: Type.Optional(
-      Type.String({ description: "Target space ID (optional, same space if omitted)" }),
-    ),
-    target_parent_token: Type.Optional(
-      Type.String({ description: "Target parent node token (optional, root if omitted)" }),
-    ),
-  }),
-  Type.Object({
-    action: Type.Literal("rename"),
-    space_id: Type.String({ description: "Knowledge space ID" }),
-    node_token: Type.String({ description: "Node token to rename" }),
-    title: Type.String({ description: "New title" }),
-  }),
-]);
-
-export type FeishuWikiParams = Static<typeof FeishuWikiSchema>;