@coze-arch/cli 0.0.18 → 0.0.19-alpha.502ddf

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

@@ -0,0 +1,297 @@
+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

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

package/lib/__templates__/pi-agent/src/cli.ts

@@ -0,0 +1,117 @@
+import { getDefaultConfigPath, getNested, setNested, deleteNested } from "./config.js";
+import { createFileConfigStore, type ConfigStore } from "./dashboard/config-store.js";
+
+function coerceValue(raw: string): unknown {
+  const trimmed = raw.trim();
+  if (trimmed === "true") return true;
+  if (trimmed === "false") return false;
+  if (trimmed === "null") return null;
+  if (trimmed !== "" && /^-?(?:\d+\.?\d*|\.\d+)$/.test(trimmed)) return Number(trimmed);
+  return raw;
+}
+
+function formatOutput(value: unknown): string {
+  if (value === undefined) return "";
+  if (value === null || typeof value === "boolean" || typeof value === "number") {
+    return String(value);
+  }
+  if (typeof value === "string") return value;
+  return JSON.stringify(value, null, 2);
+}
+
+export interface CliContext {
+  configStore: ConfigStore;
+  log: (message: string) => void;
+  error: (message: string) => void;
+}
+
+function printUsage(ctx: CliContext) {
+  ctx.log("Usage:");
+  ctx.log("  config set <key-path> <value>   Set a config value");
+  ctx.log("  config get <key-path>           Get a config value");
+  ctx.log("  config list                     Show full config");
+  ctx.log("  config delete <key-path>        Delete a config key");
+}
+
+export function runConfigCommand(args: string[], ctx: CliContext): boolean {
+  if (args[0] !== "config") return false;
+
+  const subcommand = args[1];
+
+  if (!subcommand) {
+    printUsage(ctx);
+    return true;
+  }
+
+  switch (subcommand) {
+    case "set": {
+      const keyPath = args[2];
+      const rawValue = args[3];
+      if (!keyPath || rawValue === undefined) {
+        ctx.error("Usage: config set <key-path> <value>");
+        return true;
+      }
+      const store = ctx.configStore;
+      const root = store.read();
+      const value = coerceValue(rawValue);
+      setNested(root, keyPath.split("."), value);
+      store.write(root);
+      ctx.log(`Set ${keyPath} = ${formatOutput(value)}`);
+      return true;
+    }
+    case "get": {
+      const keyPath = args[2];
+      if (!keyPath) {
+        ctx.error("Usage: config get <key-path>");
+        return true;
+      }
+      const root = ctx.configStore.read();
+      const value = getNested(root, keyPath.split("."));
+      if (value === undefined) {
+        ctx.error(`Key "${keyPath}" not found.`);
+      } else {
+        ctx.log(formatOutput(value));
+      }
+      return true;
+    }
+    case "list": {
+      const root = ctx.configStore.read();
+      ctx.log(JSON.stringify(root, null, 2));
+      return true;
+    }
+    case "delete": {
+      const keyPath = args[2];
+      if (!keyPath) {
+        ctx.error("Usage: config delete <key-path>");
+        return true;
+      }
+      const store = ctx.configStore;
+      const root = store.read();
+      const deleted = deleteNested(root, keyPath.split("."));
+      if (deleted) {
+        store.write(root);
+        ctx.log(`Deleted ${keyPath}`);
+      } else {
+        ctx.error(`Key "${keyPath}" not found.`);
+      }
+      return true;
+    }
+    default:
+      ctx.error(`Unknown config subcommand: ${subcommand}`);
+      printUsage(ctx);
+      return true;
+  }
+}
+
+export function runCli(args: string[]): boolean {
+  if (args[0] !== "config") return false;
+
+  const configPath = getDefaultConfigPath();
+  const configStore = createFileConfigStore(configPath);
+
+  return runConfigCommand(args, {
+    configStore,
+    log: (message) => console.log(message),
+    error: (message) => console.error(message),
+  });
+}