@coze-arch/cli 0.0.13 → 0.0.14-alpha.c52ee4

package/lib/__templates__/pi-agent/tests/feishu-channel.test.ts

@@ -0,0 +1,149 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createFeishuChannel } from "../src/channels/feishu/index.js";
+
+test("feishu channel adds and removes thinking reaction around replies", async () => {
+  const operations: string[] = [];
+  let nextReactionId = 0;
+
+  const channel = createFeishuChannel(
+    {
+      thinkingReaction: {
+        enabled: true,
+        emojiType: "OneSecond"
+      },
+      transport: {
+        addReaction({ messageId, emojiType }) {
+          nextReactionId += 1;
+          operations.push(`add:${messageId}:${emojiType}`);
+          return {
+            reactionId: `reaction-${nextReactionId}`,
+            emojiType
+          };
+        },
+        removeReaction({ messageId, reactionId, emojiType }) {
+          operations.push(`remove:${messageId}:${reactionId}:${emojiType}`);
+        },
+        send(message) {
+          operations.push(`send:${message.replyToMessageId}:${message.text}`);
+        }
+      }
+    },
+    {
+      async onMessage() {
+        operations.push("handler:start");
+        await Promise.resolve();
+        operations.push("handler:end");
+        return {
+          text: "reply text"
+        };
+      }
+    }
+  );
+
+  const result = await channel.simulateIncomingText({
+    text: "hello",
+    senderId: "user-1",
+    conversationId: "dm-1",
+    isDirectMessage: true
+  });
+
+  assert.equal(result.handled, true);
+  assert.equal(result.reply?.text, "reply text");
+  assert.deepEqual(operations, [
+    `add:${result.message?.messageId}:OneSecond`,
+    "handler:start",
+    "handler:end",
+    `remove:${result.message?.messageId}:reaction-1:OneSecond`,
+    `send:${result.message?.messageId}:reply text`
+  ]);
+});
+
+test("feishu channel defaults thinking reaction emoji to OneSecond", async () => {
+  const operations: string[] = [];
+
+  const channel = createFeishuChannel(
+    {
+      transport: {
+        addReaction({ messageId, emojiType }) {
+          operations.push(`add:${messageId}:${emojiType}`);
+          return {
+            reactionId: "reaction-1",
+            emojiType
+          };
+        },
+        removeReaction({ messageId, reactionId, emojiType }) {
+          operations.push(`remove:${messageId}:${reactionId}:${emojiType}`);
+        },
+        send(message) {
+          operations.push(`send:${message.replyToMessageId}:${message.text}`);
+        }
+      }
+    },
+    {
+      onMessage() {
+        return {
+          text: "reply text"
+        };
+      }
+    }
+  );
+
+  const result = await channel.simulateIncomingText({
+    text: "hello",
+    senderId: "user-default",
+    conversationId: "dm-default",
+    isDirectMessage: true
+  });
+
+  assert.equal(result.handled, true);
+  assert.deepEqual(operations, [
+    `add:${result.message?.messageId}:OneSecond`,
+    `remove:${result.message?.messageId}:reaction-1:OneSecond`,
+    `send:${result.message?.messageId}:reply text`
+  ]);
+});
+
+test("feishu channel still replies when thinking reaction fails", async () => {
+  const operations: string[] = [];
+
+  const channel = createFeishuChannel(
+    {
+      thinkingReaction: {
+        enabled: true,
+        emojiType: "OneSecond"
+      },
+      transport: {
+        addReaction() {
+          operations.push("add-failed");
+          throw new Error("reaction unavailable");
+        },
+        send(message) {
+          operations.push(`send:${message.replyToMessageId}:${message.text}`);
+        }
+      }
+    },
+    {
+      onMessage() {
+        operations.push("handler");
+        return {
+          text: "reply after failure"
+        };
+      }
+    }
+  );
+
+  const result = await channel.simulateIncomingText({
+    text: "hello",
+    senderId: "user-2",
+    conversationId: "dm-2",
+    isDirectMessage: true
+  });
+
+  assert.equal(result.handled, true);
+  assert.deepEqual(operations, [
+    "add-failed",
+    "handler",
+    `send:${result.message?.messageId}:reply after failure`
+  ]);
+});

package/lib/__templates__/pi-agent/tests/feishu-streaming-card.test.ts

@@ -0,0 +1,15 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { mergeStreamingText } from "../src/channels/feishu/streaming-card.js";
+
+test("mergeStreamingText prefers progressive full-text updates", () => {
+  assert.equal(mergeStreamingText("", "hel"), "hel");
+  assert.equal(mergeStreamingText("hel", "hello"), "hello");
+  assert.equal(mergeStreamingText("hello", "hello world"), "hello world");
+});
+
+test("mergeStreamingText merges overlapping chunks without duplicating suffixes", () => {
+  assert.equal(mergeStreamingText("hello", "lo world"), "hello world");
+  assert.equal(mergeStreamingText("abc", "bcdef"), "abcdef");
+});
+

package/lib/__templates__/pi-agent/tests/session-store.test.ts

@@ -0,0 +1,61 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, readFileSync, rmSync, existsSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import { SessionStore } from "../src/session-store.js";
+
+test("SessionStore persists index + transcript header and can reload", () => {
+  const root = mkdtempSync(join(tmpdir(), "pi-bot-session-store-"));
+  try {
+    const store1 = new SessionStore(root);
+    store1.load();
+
+    const key = "dashboard:dm:dashboard-user";
+    const record1 = store1.ensureSession(key);
+
+    assert.equal(record1.sessionKey, key);
+    assert.ok(record1.sessionId);
+    assert.ok(record1.sessionFile.endsWith(".jsonl"));
+    assert.ok(existsSync(record1.sessionFile));
+
+    const firstLine = readFileSync(record1.sessionFile, "utf-8").split(/\r?\n/)[0] ?? "";
+    const header = JSON.parse(firstLine) as { type?: string; id?: string };
+    assert.equal(header.type, "session");
+    assert.equal(header.id, record1.sessionId);
+
+    const store2 = new SessionStore(root);
+    store2.load();
+    assert.deepEqual(store2.listSessionKeys(), [key]);
+    const record2 = store2.ensureSession(key);
+    assert.equal(record2.sessionId, record1.sessionId);
+    assert.equal(record2.sessionFile, record1.sessionFile);
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("SessionStore reset archives prior transcript and rotates sessionId", () => {
+  const root = mkdtempSync(join(tmpdir(), "pi-bot-session-store-reset-"));
+  try {
+    const store = new SessionStore(root);
+    store.load();
+
+    const key = "feishu:dm:user-1";
+    const first = store.ensureSession(key);
+    assert.ok(existsSync(first.sessionFile));
+
+    const second = store.resetSession(key);
+    assert.notEqual(second.sessionId, first.sessionId);
+    assert.notEqual(second.sessionFile, first.sessionFile);
+    assert.ok(existsSync(second.sessionFile));
+
+    const sessionsDir = join(root, ".pi-bot", "sessions");
+    const archiveDir = join(sessionsDir, "archive");
+    // Old file should have been moved into archive (best-effort rename).
+    assert.ok(existsSync(archiveDir));
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+

package/lib/__templates__/pi-agent/tests/smoke/run-smoke.ts

@@ -0,0 +1,275 @@
+import assert from "node:assert/strict";
+import { createServer } from "node:net";
+import { createBotApp } from "../../src/index.js";
+import { createMemoryConfigStore } from "../../src/dashboard/config-store.js";
+
+async function readJson(url: string, init?: RequestInit): Promise<unknown> {
+  const res = await fetch(url, init);
+  assert.equal(res.ok, true, `${init?.method ?? "GET"} ${url} failed with ${res.status}`);
+  return (await res.json()) as unknown;
+}
+
+async function allocateFreePort(): Promise<number> {
+  return await new Promise<number>((resolve, reject) => {
+    const server = createServer();
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      if (!address || typeof address === "string") {
+        server.close(() => reject(new Error("Failed to allocate free port.")));
+        return;
+      }
+      const { port } = address;
+      server.close((error) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve(port);
+      });
+    });
+  });
+}
+
+async function run(): Promise<void> {
+  const previousNodeEnv = process.env.NODE_ENV;
+  const previousDashboardPort = process.env.PI_BOT_DASHBOARD_PORT;
+  process.env.NODE_ENV = "production";
+  process.env.PI_BOT_DASHBOARD_PORT = String(await allocateFreePort());
+
+  const configStore = createMemoryConfigStore({
+    agents: {
+      defaults: {
+        model: {
+          primary: "coze/auto"
+        }
+      }
+    },
+    models: {
+      providers: {
+        coze: {
+          models: [
+            { id: "auto", name: "Auto" },
+            { id: "glm-4.7", name: "GLM-4.7" }
+          ]
+        }
+      }
+    },
+    channels: {
+      feishu: {
+        enabled: true,
+        requireMention: true,
+        appId: "app-id",
+        thinkingReaction: {
+          enabled: true,
+          emojiType: "SMILE"
+        }
+      },
+      wechat: {
+        enabled: true,
+        requireMention: false,
+        implementation: "mock"
+      }
+    }
+  });
+
+  let app: Awaited<ReturnType<typeof createBotApp>> | null = null;
+
+  try {
+    app = await createBotApp(
+      {
+        appName: "smoke-bot",
+        agent: {
+          mode: "mock"
+        },
+        routing: {
+          feishuGroupRequireMention: true,
+          wechatGroupRequireMention: false
+        },
+        channels: {
+          feishu: { enabled: true },
+          wechat: { enabled: true }
+        }
+      },
+      {
+        dashboardConfigStore: configStore
+      }
+    );
+
+    await app.start();
+
+    const dashboardUrl = app.dashboard.getUrl();
+    const initialModels = (await readJson(`${dashboardUrl}/api/models`)) as {
+      defaultModel: string;
+      options: Array<{ value: string; label: string }>;
+    };
+    assert.equal(initialModels.defaultModel, "coze/auto");
+    assert.deepEqual(initialModels.options, [
+      { value: "coze/auto", label: "coze / Auto" },
+      { value: "coze/glm-4.7", label: "coze / GLM-4.7" }
+    ]);
+
+    await readJson(`${dashboardUrl}/api/models`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        models: {
+          defaultModel: "coze/glm-4.7"
+        }
+      })
+    });
+    const savedModels = (await readJson(`${dashboardUrl}/api/models`)) as { defaultModel: string };
+    assert.equal(savedModels.defaultModel, "coze/glm-4.7");
+    assert.equal(
+      (((configStore.snapshot().agents as { defaults?: { model?: { primary?: string } } }).defaults?.model?.primary) ?? ""),
+      "coze/glm-4.7"
+    );
+
+    const initialChannels = (await readJson(`${dashboardUrl}/api/channels`)) as {
+      feishu: { enabled: boolean; thinkingReaction?: { enabled?: boolean; emojiType?: string } };
+      wechat: { enabled: boolean; implementation?: string };
+      routing: { feishuGroupRequireMention: boolean; wechatGroupRequireMention: boolean };
+    };
+    assert.equal(initialChannels.feishu.enabled, true);
+    assert.equal(initialChannels.feishu.thinkingReaction?.emojiType, "SMILE");
+    assert.equal(initialChannels.wechat.implementation, "mock");
+
+    await readJson(`${dashboardUrl}/api/channels`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        channels: {
+          routing: {
+            feishuGroupRequireMention: false,
+            wechatGroupRequireMention: true
+          },
+          feishu: {
+            enabled: false,
+            requireMention: false,
+            appId: "updated-app-id",
+            domain: "",
+            encryptKey: "",
+            verificationToken: "",
+            appSecret: "",
+            thinkingReaction: {
+              enabled: false,
+              emojiType: "THINK"
+            }
+          },
+          wechat: {
+            enabled: true,
+            requireMention: true,
+            implementation: "mock"
+          }
+        }
+      })
+    });
+    const savedChannels = (await readJson(`${dashboardUrl}/api/channels`)) as {
+      feishu: { enabled: boolean; appId?: string; thinkingReaction?: { enabled?: boolean; emojiType?: string } };
+      wechat: { requireMention?: boolean };
+    };
+    assert.equal(savedChannels.feishu.enabled, false);
+    assert.equal(savedChannels.feishu.appId, "updated-app-id");
+    assert.equal(savedChannels.feishu.thinkingReaction?.enabled, false);
+    assert.equal(savedChannels.wechat.requireMention, true);
+
+    const feishuResult = await app.channels.feishu?.simulateIncomingText({
+      text: "hello from feishu",
+      senderId: "feishu-user-1",
+      conversationId: "feishu-dm-1",
+      isDirectMessage: true
+    });
+    assert.ok(feishuResult);
+    assert.equal(feishuResult.handled, true);
+    assert.equal(feishuResult.reply?.text, "mock:feishu:dm:feishu-user-1: hello from feishu");
+
+    const duplicateFeishuEvent = {
+      message: {
+        message_id: "feishu-duplicate-1",
+        chat_id: "feishu-dm-duplicate",
+        chat_type: "p2p",
+        content: JSON.stringify({ text: "duplicate hello" })
+      },
+      sender: {
+        sender_id: {
+          open_id: "feishu-user-duplicate"
+        }
+      }
+    };
+
+    const firstDuplicateResult = await app.channels.feishu?.handleEvent(duplicateFeishuEvent);
+    assert.ok(firstDuplicateResult);
+    assert.equal(firstDuplicateResult.handled, true);
+
+    const secondDuplicateResult = await app.channels.feishu?.handleEvent(duplicateFeishuEvent);
+    assert.ok(secondDuplicateResult);
+    assert.equal(secondDuplicateResult.handled, false);
+    assert.equal(secondDuplicateResult.reason, "ignored");
+
+    const filteredGroupMessage = await app.channels.feishu?.simulateIncomingText({
+      text: "group message without mention",
+      senderId: "feishu-user-2",
+      conversationId: "feishu-group-1",
+      isDirectMessage: false,
+      mentions: []
+    });
+    assert.ok(filteredGroupMessage);
+    assert.equal(filteredGroupMessage.handled, false);
+
+    const handledGroupMessage = await app.channels.feishu?.simulateIncomingText({
+      text: "group message with mention",
+      senderId: "feishu-user-2",
+      conversationId: "feishu-group-1",
+      isDirectMessage: false,
+      mentions: [{ id: "bot" }]
+    });
+    assert.ok(handledGroupMessage);
+    assert.equal(handledGroupMessage.handled, true);
+
+    const wechatResult = await app.channels.wechat?.simulateIncomingText({
+      text: "hello from wechat",
+      senderId: "wechat-user-1",
+      conversationId: "wechat-dm-1",
+      isDirectMessage: true
+    });
+    assert.ok(wechatResult);
+    assert.equal(wechatResult.handled, true);
+    assert.equal(wechatResult.reply?.text, "mock:wechat:group:wechat-dm-1: hello from wechat");
+
+    const secondWechatResult = await app.channels.wechat?.simulateIncomingText({
+      text: "hello again from wechat",
+      senderId: "wechat-user-1",
+      conversationId: "wechat-dm-1",
+      isDirectMessage: true
+    });
+    assert.ok(secondWechatResult);
+    assert.equal(secondWechatResult.handled, true);
+    assert.equal(
+      secondWechatResult.reply?.text,
+      "mock:wechat:group:wechat-dm-1: hello again from wechat"
+    );
+  } finally {
+    await app?.stop();
+    if (previousNodeEnv === undefined) {
+      delete process.env.NODE_ENV;
+    } else {
+      process.env.NODE_ENV = previousNodeEnv;
+    }
+    if (previousDashboardPort === undefined) {
+      delete process.env.PI_BOT_DASHBOARD_PORT;
+    } else {
+      process.env.PI_BOT_DASHBOARD_PORT = previousDashboardPort;
+    }
+  }
+
+  console.log("smoke test passed");
+}
+
+run().catch((error: unknown) => {
+  console.error(error);
+  process.exit(1);
+});

package/lib/__templates__/pi-agent/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "noEmit": true,
+    "skipLibCheck": true,
+    "verbatimModuleSyntax": true,
+    "forceConsistentCasingInFileNames": true,
+    "allowSyntheticDefaultImports": true,
+    "resolveJsonModule": true,
+    "baseUrl": "."
+  },
+  "include": [
+    "src/**/*.ts",
+    "tests/**/*.ts",
+    "types/**/*.d.ts"
+  ]
+}

package/lib/__templates__/pi-agent/types/larksuiteoapi-node-sdk.d.ts

@@ -0,0 +1,113 @@
+declare module "@larksuiteoapi/node-sdk" {
+  export enum AppType {
+    SelfBuild = "SelfBuild"
+  }
+
+  export enum Domain {
+    Feishu = "https://open.feishu.cn",
+    Lark = "https://open.larksuite.com"
+  }
+
+  export enum LoggerLevel {
+    warn = "warn"
+  }
+
+  export interface ClientOptions {
+    appId: string;
+    appSecret: string;
+    appType: AppType;
+    domain?: Domain | string;
+  }
+
+  export interface MessageReplyArgs {
+    path: {
+      message_id: string;
+    };
+    data: {
+      msg_type: string;
+      content: string;
+    };
+  }
+
+  export interface MessageReactionCreateArgs {
+    path: {
+      message_id: string;
+    };
+    data: {
+      reaction_type: {
+        emoji_type: string;
+      };
+    };
+  }
+
+  export interface MessageReactionDeleteArgs {
+    path: {
+      message_id: string;
+      reaction_id: string;
+    };
+  }
+
+  export class Client {
+    constructor(options: ClientOptions);
+    request(args: {
+      method: string;
+      url: string;
+      data: Record<string, never>;
+    }): Promise<{
+      bot?: {
+        open_id?: string;
+      };
+      data?: {
+        bot?: {
+          open_id?: string;
+        };
+      };
+    }>;
+    im: {
+      message: {
+        reply(args: MessageReplyArgs): Promise<unknown>;
+      };
+      messageReaction: {
+        create(args: MessageReactionCreateArgs): Promise<{
+          code?: number;
+          msg?: string;
+          data?: {
+            reaction_id?: string;
+            reaction_type?: {
+              emoji_type?: string;
+            };
+          };
+        }>;
+        delete(args: MessageReactionDeleteArgs): Promise<{
+          code?: number;
+          msg?: string;
+          data?: {
+            reaction_id?: string;
+            reaction_type?: {
+              emoji_type?: string;
+            };
+          };
+        }>;
+      };
+    };
+  }
+
+  export class EventDispatcher {
+    constructor(options: {
+      encryptKey: string;
+      verificationToken: string;
+    });
+    register(handlers: Record<string, (data: unknown) => Promise<void> | void>): void;
+  }
+
+  export class WSClient {
+    constructor(options: {
+      appId: string;
+      appSecret: string;
+      domain?: Domain | string;
+      loggerLevel?: LoggerLevel;
+    });
+    start(args: { eventDispatcher: EventDispatcher }): Promise<void>;
+    close(args?: { force?: boolean }): void;
+  }
+}