@coze-arch/cli 0.0.15-alpha.a0f5b9 → 0.0.15-alpha.dfd4c4

package/lib/__templates__/pi-agent/src/channels/feishu/streaming-card.ts

@@ -1,297 +0,0 @@
-import type { Client } from "@larksuiteoapi/node-sdk";
-
-type FeishuDomain = string | undefined;
-
-type Credentials = {
-  appId: string;
-  appSecret: string;
-  domain?: FeishuDomain;
-};
-
-type CardState = {
-  cardId: string;
-  messageId: string;
-  sequence: number;
-  currentText: string;
-};
-
-type StreamingStartOptions = {
-  replyToMessageId: string;
-  replyInThread?: boolean;
-};
-
-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() + 60_000) {
-    return cached.token;
-  }
-
-  const response = 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 }),
-  });
-  if (!response.ok) {
-    throw new Error(`Token request failed with HTTP ${response.status}`);
-  }
-
-  const data = (await response.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;
-}
-
-async function readResponseBodySafe(response: Response): Promise<string> {
-  try {
-    const text = await response.text();
-    return text.trim();
-  } catch {
-    return "";
-  }
-}
-
-function truncateSummary(text: string, max = 50): string {
-  const clean = text.replace(/\n/g, " ").trim();
-  return clean.length <= max ? clean : `${clean.slice(0, max - 3)}...`;
-}
-
-export function mergeStreamingText(previousText: string | undefined, nextText: string | undefined): string {
-  const previous = typeof previousText === "string" ? previousText : "";
-  const next = typeof nextText === "string" ? nextText : "";
-  if (!next) return previous;
-  if (!previous || next === previous) return next;
-  if (next.startsWith(previous)) return next;
-  if (previous.startsWith(next)) return previous;
-  if (next.includes(previous)) return next;
-  if (previous.includes(next)) return previous;
-
-  const maxOverlap = Math.min(previous.length, next.length);
-  for (let overlap = maxOverlap; overlap > 0; overlap -= 1) {
-    if (previous.slice(-overlap) === next.slice(0, overlap)) {
-      return `${previous}${next.slice(overlap)}`;
-    }
-  }
-  return `${previous}${next}`;
-}
-
-export class FeishuStreamingCardSession {
-  private state: CardState | null = null;
-  private queue: Promise<void> = Promise.resolve();
-  private closed = false;
-  private pendingText: string | null = null;
-  private flushTimer: ReturnType<typeof setTimeout> | null = null;
-  private lastUpdateTime = 0;
-  private readonly updateThrottleMs = 100;
-
-  constructor(
-    private readonly client: Client,
-    private readonly creds: Credentials,
-    private readonly log?: (message: string, fields?: Record<string, unknown>) => void,
-  ) {}
-
-  async start(
-    _receiveId: string,
-    _receiveIdType: "open_id" | "user_id" | "union_id" | "email" | "chat_id" = "chat_id",
-    options?: StreamingStartOptions,
-  ): Promise<void> {
-    if (this.state) return;
-    if (!options?.replyToMessageId) {
-      throw new Error("replyToMessageId is required for feishu streaming card replies");
-    }
-
-    const cardJson = {
-      schema: "2.0",
-      config: {
-        streaming_mode: true,
-        summary: { content: "[Generating...]" },
-        streaming_config: { print_frequency_ms: { default: 50 }, print_step: { default: 1 } },
-      },
-      body: {
-        elements: [{ tag: "markdown", content: "⏳ Thinking...", element_id: "content" }],
-      },
-    };
-
-    const token = await getToken(this.creds);
-    const createRes = await fetch(`${resolveApiBase(this.creds.domain)}/cardkit/v1/cards`, {
-      method: "POST",
-      headers: {
-        Authorization: `Bearer ${token}`,
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify({ type: "card_json", data: JSON.stringify(cardJson) }),
-    });
-    if (!createRes.ok) {
-      const body = await readResponseBodySafe(createRes);
-      throw new Error(
-        `Create card request failed with HTTP ${createRes.status}${body ? `: ${body}` : ""}`,
-      );
-    }
-
-    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 (code=${createData.code}): ${createData.msg}`);
-    }
-
-    const cardId = createData.data.card_id;
-    const cardContent = JSON.stringify({ type: "card", data: { card_id: cardId } });
-    const sendRes = (await this.client.im.message.reply({
-      path: { message_id: options.replyToMessageId },
-      data: {
-        msg_type: "interactive",
-        content: cardContent,
-        ...(options.replyInThread ? { reply_in_thread: true } : {}),
-      },
-    })) as {
-      code?: number;
-      msg?: string;
-      data?: { message_id?: string };
-    };
-
-    if (sendRes.code !== 0 || !sendRes.data?.message_id) {
-      throw new Error(`Send card failed: ${sendRes.msg}`);
-    }
-    this.log?.("stream start", { cardId, messageId: sendRes.data.message_id });
-
-    this.state = {
-      cardId,
-      messageId: sendRes.data.message_id,
-      sequence: 1,
-      currentText: "",
-    };
-  }
-
-  private async updateCardContent(text: string): Promise<void> {
-    if (!this.state) return;
-    this.state.sequence += 1;
-    const token = await getToken(this.creds);
-    const response = await fetch(
-      `${resolveApiBase(this.creds.domain)}/cardkit/v1/cards/${this.state.cardId}/elements/content/content`,
-      {
-        method: "PUT",
-        headers: {
-          Authorization: `Bearer ${token}`,
-          "Content-Type": "application/json",
-        },
-        body: JSON.stringify({
-          content: text,
-          sequence: this.state.sequence,
-          uuid: `s_${this.state.cardId}_${this.state.sequence}`,
-        }),
-      },
-    );
-    if (!response.ok) {
-      const body = await readResponseBodySafe(response);
-      throw new Error(
-        `Update card request failed with HTTP ${response.status}${body ? `: ${body}` : ""}`,
-      );
-    }
-  }
-
-  async update(text: string): Promise<void> {
-    if (!this.state || this.closed) return;
-    const mergedInput = mergeStreamingText(this.pendingText ?? this.state.currentText, text);
-    if (!mergedInput || mergedInput === this.state.currentText) return;
-
-    const now = Date.now();
-    if (now - this.lastUpdateTime < this.updateThrottleMs) {
-      this.pendingText = mergedInput;
-      if (!this.flushTimer) {
-        this.flushTimer = setTimeout(() => {
-          this.flushTimer = null;
-          const pending = this.pendingText;
-          this.pendingText = null;
-          if (pending) {
-            void this.update(pending).catch((error) => this.log?.("stream update failed", { error: String(error) }));
-          }
-        }, this.updateThrottleMs);
-      }
-      return;
-    }
-
-    this.pendingText = null;
-    this.lastUpdateTime = now;
-    this.queue = this.queue.then(async () => {
-      if (!this.state || this.closed) return;
-      const mergedText = mergeStreamingText(this.state.currentText, mergedInput);
-      if (!mergedText || mergedText === this.state.currentText) return;
-      this.state.currentText = mergedText;
-      this.log?.("stream update", { text: mergedText });
-      await this.updateCardContent(mergedText);
-    });
-    await this.queue;
-  }
-
-  async close(finalText?: string): Promise<void> {
-    if (!this.state || this.closed) return;
-    this.closed = true;
-    if (this.flushTimer) {
-      clearTimeout(this.flushTimer);
-      this.flushTimer = null;
-    }
-    await this.queue;
-
-    const text = finalText ? mergeStreamingText(this.state.currentText, finalText) : this.state.currentText;
-    if (text && text !== this.state.currentText) {
-      await this.updateCardContent(text);
-      this.state.currentText = text;
-    }
-
-    this.state.sequence += 1;
-    const token = await getToken(this.creds);
-    const response = await fetch(`${resolveApiBase(this.creds.domain)}/cardkit/v1/cards/${this.state.cardId}/settings`, {
-      method: "PATCH",
-      headers: {
-        Authorization: `Bearer ${token}`,
-        "Content-Type": "application/json; charset=utf-8",
-      },
-      body: JSON.stringify({
-        settings: JSON.stringify({
-          config: { streaming_mode: false, summary: { content: truncateSummary(this.state.currentText) } },
-        }),
-        sequence: this.state.sequence,
-        uuid: `c_${this.state.cardId}_${this.state.sequence}`,
-      }),
-    });
-    if (!response.ok) {
-      const body = await readResponseBodySafe(response);
-      throw new Error(
-        `Close card request failed with HTTP ${response.status}${body ? `: ${body}` : ""}`,
-      );
-    }
-
-    this.state = null;
-    this.pendingText = null;
-  }
-
-  isActive(): boolean {
-    return this.state !== null && !this.closed;
-  }
-}

package/lib/__templates__/pi-agent/src/channels/wechat/index.ts

@@ -1,171 +0,0 @@
-import {
-  type BotMessage,
-  type BotReply,
-  type ChannelHandler,
-  type ChannelInstance,
-  type ChannelTransport,
-  createBotMessage,
-  normalizeReply,
-  shouldHandleGroupMessage
-} from "../../core.js";
-
-export interface WechatIncomingEvent {
-  message?: WechatIncomingEvent;
-  messageId?: string;
-  fromUser?: string;
-  roomId?: string;
-  conversationId?: string;
-  senderId?: string;
-  text?: string;
-  mentions?: string[];
-  threadId?: string;
-}
-
-export interface WechatOutgoingMessage extends BotReply {
-  channel: "wechat";
-  conversationId: string;
-  replyToMessageId: string;
-}
-
-export interface WechatChannelConfig {
-  routing?: {
-    groupRequireMention?: boolean;
-  };
-  transport?: ChannelTransport<WechatOutgoingMessage>;
-}
-
-export interface WechatHandleResult {
-  handled: boolean;
-  reason?: "ignored" | "filtered";
-  message?: BotMessage;
-  reply?: WechatOutgoingMessage | null;
-}
-
-export interface WechatChannel extends ChannelInstance {
-  name: "wechat";
-  isStarted(): boolean;
-  getSentMessages(): WechatOutgoingMessage[];
-  handleEvent(event: WechatIncomingEvent): Promise<WechatHandleResult>;
-  simulateIncomingText(input: {
-    text: string;
-    senderId?: string;
-    conversationId?: string;
-    isDirectMessage?: boolean;
-    mentions?: string[];
-  }): Promise<WechatHandleResult>;
-}
-
-function unwrapSource(event: WechatIncomingEvent): WechatIncomingEvent {
-  return event.message ?? event;
-}
-
-export function normalizeWechatEvent(event: WechatIncomingEvent): BotMessage | null {
-  const source = unwrapSource(event);
-  const roomId = source.roomId ?? source.conversationId;
-  const senderId = source.fromUser ?? source.senderId;
-  const text = source.text;
-
-  if (!senderId || typeof text !== "string") {
-    return null;
-  }
-
-  return createBotMessage({
-    channel: "wechat",
-    conversationId: roomId ?? senderId,
-    senderId,
-    messageId: source.messageId ?? `wechat-${Date.now()}`,
-    text,
-    isDirectMessage: !roomId,
-    mentions: source.mentions ?? [],
-    threadId: source.threadId,
-    raw: event
-  });
-}
-
-function createOutgoingMessage(message: BotMessage, reply: BotReply): WechatOutgoingMessage {
-  return {
-    channel: "wechat",
-    conversationId: message.conversationId,
-    replyToMessageId: message.messageId,
-    text: reply.text
-  };
-}
-
-export function createWechatChannel(
-  config: WechatChannelConfig = {},
-  handler: ChannelHandler = {}
-): WechatChannel {
-  const sentMessages: WechatOutgoingMessage[] = [];
-  let started = false;
-
-  async function sendReply(
-    message: BotMessage,
-    reply: string | BotReply | null | void
-  ): Promise<WechatOutgoingMessage | null> {
-    const normalizedReply = normalizeReply(reply);
-    if (!normalizedReply) return null;
-
-    const outgoingMessage = createOutgoingMessage(message, normalizedReply);
-    sentMessages.push(outgoingMessage);
-
-    await config.transport?.send?.(outgoingMessage);
-    return outgoingMessage;
-  }
-
-  return {
-    name: "wechat",
-    async start() {
-      started = true;
-      await config.transport?.start?.();
-    },
-    async stop() {
-      started = false;
-      await config.transport?.stop?.();
-    },
-    isStarted() {
-      return started;
-    },
-    getSentMessages() {
-      return [...sentMessages];
-    },
-    async handleEvent(event) {
-      const message = normalizeWechatEvent(event);
-      if (!message) {
-        return { handled: false, reason: "ignored" };
-      }
-
-      const shouldHandle = shouldHandleGroupMessage(message, {
-        requireMention: config.routing?.groupRequireMention ?? false
-      });
-
-      if (!shouldHandle) {
-        return { handled: false, reason: "filtered", message };
-      }
-
-      const reply = await handler.onMessage?.(message);
-      const outgoingMessage = await sendReply(message, reply);
-
-      return {
-        handled: true,
-        message,
-        reply: outgoingMessage
-      };
-    },
-    async simulateIncomingText({
-      text,
-      senderId = "wechat-user",
-      conversationId = "wechat-chat",
-      isDirectMessage = true,
-      mentions = []
-    }) {
-      return this.handleEvent({
-        messageId: `wechat-${Date.now()}`,
-        fromUser: senderId,
-        roomId: isDirectMessage ? undefined : conversationId,
-        conversationId,
-        text,
-        mentions
-      });
-    }
-  };
-}