@coze-arch/cli 0.0.17 → 0.0.19-beta.1

package/lib/__templates__/pi-agent/tests/cli.test.ts

@@ -0,0 +1,136 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createMemoryConfigStore } from "../src/dashboard/config-store.js";
+import { runConfigCommand, type CliContext } from "../src/cli.js";
+
+function createTestContext(initial: Record<string, unknown> = {}) {
+  const store = createMemoryConfigStore(initial);
+  const logs: string[] = [];
+  const errors: string[] = [];
+  const ctx: CliContext = {
+    configStore: store,
+    log: (msg) => logs.push(msg),
+    error: (msg) => errors.push(msg),
+  };
+  return { store, logs, errors, ctx };
+}
+
+test("runConfigCommand returns false for non-config commands", () => {
+  const { ctx } = createTestContext();
+  assert.equal(runConfigCommand([], ctx), false);
+  assert.equal(runConfigCommand(["start"], ctx), false);
+  assert.equal(runConfigCommand(["run"], ctx), false);
+});
+
+test("config set writes a string value at a nested path", () => {
+  const { store, logs, ctx } = createTestContext({ channels: { feishu: { appId: "old" } } });
+  runConfigCommand(["config", "set", "channels.feishu.appId", "cli_new"], ctx);
+  const snapshot = store.snapshot();
+  assert.equal((snapshot.channels as Record<string, Record<string, unknown>>).feishu.appId, "cli_new");
+  assert.ok(logs[0]?.includes("cli_new"));
+});
+
+test("config set coerces boolean values", () => {
+  const { store, ctx } = createTestContext({ channels: { feishu: { enabled: false } } });
+  runConfigCommand(["config", "set", "channels.feishu.enabled", "true"], ctx);
+  const snapshot = store.snapshot();
+  assert.equal((snapshot.channels as Record<string, Record<string, unknown>>).feishu.enabled, true);
+});
+
+test("config set coerces numeric values", () => {
+  const { store, ctx } = createTestContext({ models: { maxTokens: 8192 } });
+  runConfigCommand(["config", "set", "models.maxTokens", "16384"], ctx);
+  const snapshot = store.snapshot();
+  assert.equal((snapshot.models as Record<string, unknown>).maxTokens, 16384);
+});
+
+test("config set creates intermediate objects for missing paths", () => {
+  const { store, ctx } = createTestContext({});
+  runConfigCommand(["config", "set", "channels.feishu.appId", "new-id"], ctx);
+  const snapshot = store.snapshot();
+  assert.equal(
+    (snapshot.channels as Record<string, Record<string, unknown>>).feishu.appId,
+    "new-id",
+  );
+});
+
+test("config set handles array index paths", () => {
+  const { store, ctx } = createTestContext({ items: [{ name: "a" }, { name: "b" }] });
+  runConfigCommand(["config", "set", "items.1.name", "updated"], ctx);
+  const snapshot = store.snapshot();
+  assert.equal((snapshot.items as Array<Record<string, unknown>>)[1]!.name, "updated");
+});
+
+test("config get returns a string value", () => {
+  const { logs, ctx } = createTestContext({ channels: { feishu: { appId: "test-id" } } });
+  runConfigCommand(["config", "get", "channels.feishu.appId"], ctx);
+  assert.equal(logs[0], "test-id");
+});
+
+test("config get returns a formatted object", () => {
+  const { logs, ctx } = createTestContext({ channels: { feishu: { appId: "x", enabled: true } } });
+  runConfigCommand(["config", "get", "channels.feishu"], ctx);
+  const parsed = JSON.parse(logs[0]!) as Record<string, unknown>;
+  assert.equal(parsed.appId, "x");
+  assert.equal(parsed.enabled, true);
+});
+
+test("config get reports error for missing key", () => {
+  const { errors, ctx } = createTestContext({});
+  runConfigCommand(["config", "get", "missing.key"], ctx);
+  assert.ok(errors[0]?.includes("not found"));
+});
+
+test("config list outputs the full config", () => {
+  const original = { channels: { feishu: { enabled: true } } };
+  const { logs, ctx } = createTestContext(original);
+  runConfigCommand(["config", "list"], ctx);
+  const parsed = JSON.parse(logs[0]!) as Record<string, unknown>;
+  assert.deepEqual(parsed, original);
+});
+
+test("config delete removes a key", () => {
+  const { store, logs, ctx } = createTestContext({
+    channels: { feishu: { appId: "x", enabled: true } },
+  });
+  runConfigCommand(["config", "delete", "channels.feishu.appId"], ctx);
+  const snapshot = store.snapshot();
+  const feishu = (snapshot.channels as Record<string, Record<string, unknown>>).feishu;
+  assert.equal("appId" in feishu, false);
+  assert.equal(feishu.enabled, true);
+  assert.ok(logs[0]?.includes("Deleted"));
+});
+
+test("config delete reports error for missing key", () => {
+  const { errors, ctx } = createTestContext({});
+  runConfigCommand(["config", "delete", "missing.key"], ctx);
+  assert.ok(errors[0]?.includes("not found"));
+});
+
+test("config with no subcommand prints usage", () => {
+  const { logs, ctx } = createTestContext();
+  const handled = runConfigCommand(["config"], ctx);
+  assert.equal(handled, true);
+  assert.ok(logs.some((l) => l.includes("Usage")));
+});
+
+test("config with unknown subcommand prints error and usage", () => {
+  const { errors, logs, ctx } = createTestContext();
+  const handled = runConfigCommand(["config", "badcmd"], ctx);
+  assert.equal(handled, true);
+  assert.ok(errors[0]?.includes("Unknown"));
+  assert.ok(logs.some((l) => l.includes("Usage")));
+});
+
+test("config set with missing arguments prints usage", () => {
+  const { errors, ctx } = createTestContext();
+  runConfigCommand(["config", "set", "key"], ctx);
+  assert.ok(errors[0]?.includes("Usage"));
+});
+
+test("config set coerces null value", () => {
+  const { store, ctx } = createTestContext({ key: "value" });
+  runConfigCommand(["config", "set", "key", "null"], ctx);
+  const snapshot = store.snapshot();
+  assert.equal(snapshot.key, null);
+});

package/lib/__templates__/pi-agent/tests/config.test.ts

@@ -0,0 +1,315 @@
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import test from "node:test";
+import { AuthStorage, ModelRegistry } from "@mariozechner/pi-coding-agent";
+import {
+  getDefaultConfigPath,
+  loadConfig,
+  loadBotAppConfig,
+  resolveRuntimeModel
+} from "../src/config.js";
+
+function createConfigFile(config: unknown): string {
+  const tempDir = mkdtempSync(join(tmpdir(), "pi-bot-workspace-config-"));
+  const workspaceDir = join(tempDir, "workspace");
+  const configPath = join(workspaceDir, "config.json");
+
+  mkdirSync(workspaceDir, { recursive: true });
+  writeFileSync(configPath, JSON.stringify(config, null, 2));
+
+  return configPath;
+}
+
+test("loadConfig resolves workspace directory and default model", () => {
+  const configPath = createConfigFile({
+    agents: {
+      defaults: {
+        workspace: ".",
+        thinkingLevel: "medium",
+        model: {
+          primary: "coze/glm-4-7-251222"
+        }
+      }
+    },
+    models: {
+      providers: {
+        coze: {
+          api: "openai-completions",
+          baseUrl: "${COZE_BASE_URL}",
+          apiKey: "${COZE_API_KEY}",
+          models: [
+            {
+              id: "glm-4-7-251222",
+              name: "GLM 4.7",
+              input: ["text"],
+              reasoning: false,
+              contextWindow: 200000,
+              maxTokens: 8192,
+              cost: {
+                input: 0,
+                output: 0,
+                cacheRead: 0,
+                cacheWrite: 0
+              }
+            }
+          ]
+        }
+      }
+    }
+  });
+
+  const loaded = loadConfig(configPath);
+  const tempRoot = dirname(dirname(configPath));
+
+  rmSync(tempRoot, { recursive: true, force: true });
+
+  assert.equal(loaded.workspaceDir, dirname(configPath));
+  assert.equal(loaded.thinkingLevel, "medium");
+  assert.deepEqual(loaded.defaultModel, {
+    provider: "coze",
+    modelId: "glm-4-7-251222"
+  });
+});
+
+test("loadBotAppConfig defaults agent mode to pi when env override is absent", () => {
+  const configPath = createConfigFile({
+    agents: {
+      defaults: {
+        workspace: ".",
+        model: {
+          primary: "openai/gpt-5-mini"
+        }
+      }
+    }
+  });
+
+  const loaded = loadBotAppConfig({
+    configPath,
+    env: {}
+  });
+  const tempRoot = dirname(dirname(configPath));
+
+  rmSync(tempRoot, { recursive: true, force: true });
+
+  assert.equal(loaded.agent.mode, "pi");
+});
+
+test("resolveRuntimeModel builds a custom provider model from workspace/config.json", async () => {
+  const configPath = createConfigFile({
+    agents: {
+      defaults: {
+        workspace: ".",
+        model: {
+          primary: "coze/glm-4-7-251222"
+        }
+      }
+    },
+    models: {
+      providers: {
+        missing: {
+          api: "openai-completions",
+          baseUrl: "${MISSING_BASE_URL}",
+          apiKey: "${MISSING_API_KEY}",
+          models: [
+            {
+              id: "unused-model",
+              name: "Unused",
+              input: ["text"],
+              reasoning: false
+            }
+          ]
+        },
+        coze: {
+          api: "openai-completions",
+          baseUrl: "${COZE_BASE_URL}",
+          apiKey: "${COZE_API_KEY}",
+          headers: {
+            "X-Workspace": "${WORKSPACE_ID}"
+          },
+          models: [
+            {
+              id: "glm-4-7-251222",
+              name: "GLM 4.7",
+              input: ["text"],
+              reasoning: false,
+              contextWindow: 200000,
+              maxTokens: 8192,
+              headers: {
+                "X-Trace": "${TRACE_ID}"
+              },
+              cost: {
+                input: 0,
+                output: 0,
+                cacheRead: 0,
+                cacheWrite: 0
+              }
+            }
+          ]
+        }
+      }
+    }
+  });
+
+  const tempRoot = dirname(dirname(configPath));
+  const env = {
+    COZE_BASE_URL: "https://coze.example.com/v1",
+    COZE_API_KEY: "coze-secret",
+    WORKSPACE_ID: "workspace-1",
+    TRACE_ID: "trace-1"
+  };
+
+  const resolved = resolveRuntimeModel({
+    configPath,
+    env
+  });
+
+  assert.ok(resolved);
+  assert.equal(resolved.model.provider, "coze");
+  assert.equal(resolved.model.api, "openai-completions");
+  assert.equal(resolved.model.baseUrl, env.COZE_BASE_URL);
+  assert.equal(resolved.apiKey, env.COZE_API_KEY);
+  assert.deepEqual(resolved.model.headers, {
+    "X-Workspace": env.WORKSPACE_ID,
+    "X-Trace": env.TRACE_ID
+  });
+
+  const authStorage = AuthStorage.inMemory();
+  const modelRegistry = new ModelRegistry(authStorage, join(tempRoot, "absent-models.json"));
+
+  authStorage.setRuntimeApiKey(resolved.model.provider, resolved.apiKey!);
+
+  const auth = await modelRegistry.getApiKeyAndHeaders(resolved.model);
+  rmSync(tempRoot, { recursive: true, force: true });
+
+  assert.deepEqual(auth, {
+    ok: true,
+    apiKey: env.COZE_API_KEY,
+    headers: {
+      "X-Workspace": env.WORKSPACE_ID,
+      "X-Trace": env.TRACE_ID
+    }
+  });
+});
+
+test("resolveRuntimeModel applies workspace overrides to built-in providers", () => {
+  const configPath = createConfigFile({
+    agents: {
+      defaults: {
+        workspace: ".",
+        model: {
+          primary: "openai/gpt-5-mini"
+        }
+      }
+    },
+    models: {
+      providers: {
+        openai: {
+          baseUrl: "https://proxy.example.com/v1",
+          headers: {
+            "X-Proxy": "${PROXY_ID}"
+          },
+          modelOverrides: {
+            "gpt-5-mini": {
+              maxTokens: 4096
+            }
+          }
+        }
+      }
+    }
+  });
+
+  const tempRoot = dirname(dirname(configPath));
+  const resolved = resolveRuntimeModel({
+    provider: "openai",
+    model: "gpt-5-mini",
+    baseUrl: "https://forced.example.com/v1",
+    configPath,
+    env: {
+      PROXY_ID: "proxy-1"
+    }
+  });
+
+  rmSync(tempRoot, { recursive: true, force: true });
+
+  assert.ok(resolved);
+  assert.equal(resolved.model.provider, "openai");
+  assert.equal(resolved.model.id, "gpt-5-mini");
+  assert.equal(resolved.model.baseUrl, "https://forced.example.com/v1");
+  assert.equal(resolved.model.maxTokens, 4096);
+  assert.equal(resolved.model.headers?.["X-Proxy"], "proxy-1");
+});
+
+test("loadBotAppConfig builds the app config from config.json plus env-backed channels", () => {
+  const configPath = createConfigFile({
+    agents: {
+      defaults: {
+        workspace: ".",
+        thinkingLevel: "high",
+        model: {
+          primary: "coze/auto"
+        }
+      }
+    },
+    models: {
+      providers: {
+        coze: {
+          api: "openai-completions",
+          apiKey: "${COZE_API_KEY}",
+          baseUrl: "${COZE_BASE_URL}",
+          models: [
+            {
+              id: "auto",
+              name: "Auto",
+              input: ["text"],
+              reasoning: false
+            }
+          ]
+        }
+      }
+    },
+    channels: {
+      feishu: {
+        enabled: true,
+        appId: "${FEISHU_APP_ID}",
+        appSecret: "${FEISHU_APP_SECRET}",
+        domain: "${FEISHU_DOMAIN}",
+        encryptKey: "${FEISHU_ENCRYPT_KEY}",
+        verificationToken: "${FEISHU_VERIFICATION_TOKEN}",
+        requireMention: false,
+        thinkingReaction: {
+          enabled: false,
+          emojiType: "OneSecond"
+        }
+      }
+    }
+  });
+  const tempRoot = dirname(dirname(configPath));
+  const loaded = loadBotAppConfig({
+    configPath,
+    env: {
+      PI_BOT_AGENT_MODE: "pi",
+      FEISHU_APP_ID: "app-id",
+      FEISHU_APP_SECRET: "app-secret",
+      FEISHU_DOMAIN: "feishu.example.com",
+      FEISHU_ENCRYPT_KEY: "encrypt-key",
+      FEISHU_VERIFICATION_TOKEN: "verify-token"
+    }
+  });
+
+  rmSync(tempRoot, { recursive: true, force: true });
+
+  assert.equal(getDefaultConfigPath(), resolve(process.cwd(), "../workspace/config.json"));
+  assert.equal(loaded.agent.mode, "pi");
+  assert.equal(loaded.agent.provider, "coze");
+  assert.equal(loaded.agent.model, "auto");
+  assert.equal(loaded.agent.configPath, configPath);
+  assert.equal(loaded.agent.thinkingLevel, "high");
+  assert.equal(loaded.agent.cwd, dirname(configPath));
+  assert.equal(loaded.channels.feishu?.appId, "app-id");
+  assert.equal(loaded.channels.feishu?.verificationToken, "verify-token");
+  assert.equal(loaded.routing.feishuGroupRequireMention, false);
+  assert.equal(loaded.channels.feishu?.thinkingReaction?.enabled, false);
+  assert.equal(loaded.channels.feishu?.thinkingReaction?.emojiType, "OneSecond");
+});

package/lib/__templates__/pi-agent/tests/dashboard-docs-api.test.ts

@@ -0,0 +1,125 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import test from "node:test";
+import { readDocsResponse } from "../src/dashboard/api/docs.js";
+
+function writeDoc(rootDir: string, relativePath: string, content: string) {
+  const filePath = join(rootDir, relativePath);
+  mkdirSync(dirname(filePath), { recursive: true });
+  writeFileSync(filePath, content, "utf-8");
+}
+
+test("readDocsResponse lists markdown docs by order and picks the first doc by default", () => {
+  const docsDir = mkdtempSync(join(tmpdir(), "pi-bot-dashboard-docs-"));
+
+  try {
+    writeDoc(
+      docsDir,
+      "channels/feishu.md",
+      `---
+title: 飞书接入
+summary: 飞书文档
+group: 渠道
+order: 30
+---
+# 飞书接入
+
+这里是飞书说明。
+`
+    );
+    writeDoc(
+      docsDir,
+      "getting-started.md",
+      `---
+title: 快速开始
+summary: 启动项目
+group: 入门
+order: 10
+---
+# 快速开始
+
+先启动项目。
+`
+    );
+
+    const response = readDocsResponse({ docsDir });
+
+    assert.deepEqual(
+      response.docs.map((doc) => doc.slug),
+      ["getting-started", "channels/feishu"]
+    );
+    assert.equal(response.selectedDoc?.slug, "getting-started");
+    assert.equal(response.requestedSlugFound, true);
+  } finally {
+    rmSync(docsDir, { recursive: true, force: true });
+  }
+});
+
+test("readDocsResponse returns the requested doc and strips frontmatter from content", () => {
+  const docsDir = mkdtempSync(join(tmpdir(), "pi-bot-dashboard-docs-selected-"));
+
+  try {
+    writeDoc(
+      docsDir,
+      "getting-started.md",
+      `---
+title: 快速开始
+summary: 启动项目
+group: 入门
+order: 10
+---
+# 快速开始
+
+先启动项目。
+`
+    );
+    writeDoc(
+      docsDir,
+      "channels/feishu.md",
+      `---
+title: 飞书接入
+summary: 飞书文档
+group: 渠道
+order: 30
+---
+# 飞书接入
+
+这里是飞书说明。
+`
+    );
+
+    const response = readDocsResponse({ docsDir, slug: "channels/feishu" });
+
+    assert.equal(response.selectedDoc?.slug, "channels/feishu");
+    assert.match(response.selectedDoc?.content ?? "", /^# 飞书接入/m);
+    assert.doesNotMatch(response.selectedDoc?.content ?? "", /^---$/m);
+    assert.equal(response.requestedSlugFound, true);
+  } finally {
+    rmSync(docsDir, { recursive: true, force: true });
+  }
+});
+
+test("readDocsResponse falls back to the default doc when the requested slug is missing", () => {
+  const docsDir = mkdtempSync(join(tmpdir(), "pi-bot-dashboard-docs-fallback-"));
+
+  try {
+    writeDoc(
+      docsDir,
+      "getting-started.md",
+      `# 快速开始
+
+先启动项目。
+`
+    );
+
+    const response = readDocsResponse({ docsDir, slug: "does-not-exist" });
+
+    assert.equal(response.selectedDoc?.slug, "getting-started");
+    assert.equal(response.requestedSlug, "does-not-exist");
+    assert.equal(response.requestedSlugFound, false);
+  } finally {
+    rmSync(docsDir, { recursive: true, force: true });
+  }
+});