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

package/lib/__templates__/pi-agent/src/tools/web-fetch/index.ts

@@ -0,0 +1,195 @@
+import { type Static, Type } from "@sinclair/typebox";
+import type { ToolDefinition } from "@mariozechner/pi-coding-agent";
+import { FetchClient, type FetchContentItem, type FetchResponse } from "coze-coding-dev-sdk";
+import { formatCozeError } from "../common/format-coze-error.js";
+
+type FetchResultLink = {
+  title?: string;
+  url?: string;
+};
+
+type FetchResultImage = {
+  url?: string;
+  width?: number;
+  height?: number;
+};
+
+type FetchResultItem = {
+  url: string;
+  title?: string;
+  text: string;
+  links: FetchResultLink[];
+  images: FetchResultImage[];
+};
+
+function joinText(items: FetchContentItem[]): string {
+  return items
+    .filter((item) => item.type === "text" && item.text)
+    .map((item) => item.text?.trim() ?? "")
+    .filter(Boolean)
+    .join("\n\n");
+}
+
+function collectLinks(items: FetchContentItem[]): FetchResultLink[] {
+  return items
+    .filter((item) => item.type === "link")
+    .map((item) => ({
+      title: item.text,
+      url: item.url,
+    }));
+}
+
+function collectImages(items: FetchContentItem[]): FetchResultImage[] {
+  return items
+    .filter((item) => item.type === "image")
+    .map((item) => ({
+      url: item.image?.display_url ?? item.image?.image_url,
+      width: item.image?.width,
+      height: item.image?.height,
+    }));
+}
+
+function normalizeFetchedItem(response: FetchResponse, textOnly: boolean): FetchResultItem {
+  const content = response.content ?? [];
+  return {
+    url: response.url ?? "",
+    title: response.title,
+    text: joinText(content),
+    links: textOnly ? [] : collectLinks(content),
+    images: textOnly ? [] : collectImages(content),
+  };
+}
+
+const MAX_CONCURRENCY = 5;
+
+async function fetchContent(
+  urls: string[],
+  textOnly: boolean,
+): Promise<FetchResultItem[]> {
+  const client = new FetchClient();
+  const results: FetchResultItem[] = new Array(urls.length);
+  let next = 0;
+
+  async function worker() {
+    while (next < urls.length) {
+      const idx = next++;
+      const response = await client.fetch(urls[idx]);
+      results[idx] = normalizeFetchedItem(response, textOnly);
+    }
+  }
+
+  await Promise.all(Array.from({ length: Math.min(MAX_CONCURRENCY, urls.length) }, () => worker()));
+
+  return results;
+}
+
+const FetchToolSchema = Type.Object(
+  {
+    urls: Type.Union(
+      [
+        Type.String({ description: "Single URL to fetch." }),
+        Type.Array(Type.String({ description: "URL to fetch." }), {
+          description: "One or more URLs to fetch.",
+          minItems: 1,
+        }),
+      ],
+      {
+        description:
+          "URL input. Accepts either a single URL string or an array of URL strings.",
+      },
+    ),
+    format: Type.Optional(
+      Type.Unsafe<"text" | "markdown" | "json">({
+        type: "string",
+        enum: ["text", "markdown", "json"],
+        description: "Formatting preference for the textual output.",
+      }),
+    ),
+    textOnly: Type.Optional(
+      Type.Boolean({ description: "Only return extracted text, without images or links." }),
+    ),
+  },
+  { additionalProperties: false },
+);
+
+function renderFetchedText(items: FetchResultItem[], format: "text" | "markdown" | "json"): string {
+  if (format === "json") {
+    return JSON.stringify(items, null, 2);
+  }
+
+  if (format === "markdown") {
+    return items
+      .map((item) => {
+        const lines: string[] = [];
+        lines.push(`# ${item.title ?? "Untitled"}`);
+        lines.push(`URL: ${item.url}`);
+        lines.push("", item.text);
+        if (item.links.length > 0) {
+          const validLinks = item.links.filter((link) => link.url);
+          if (validLinks.length > 0) {
+            lines.push("", "## Links");
+            for (const link of validLinks) {
+              lines.push(`- [${link.title ?? link.url}](${link.url})`);
+            }
+          }
+        }
+        return lines.join("\n");
+      })
+      .join("\n\n---\n\n");
+  }
+
+  return items
+    .map((item, index) => {
+      const lines: string[] = [];
+      lines.push(`${index + 1}. ${item.title ?? "Untitled"}`);
+      lines.push(`   URL: ${item.url}`);
+      lines.push(`   ${item.text}`);
+      if (item.links.length > 0) {
+        const validLinks = item.links.filter((link) => link.url);
+        if (validLinks.length > 0) {
+          lines.push("   Links:");
+          for (const link of validLinks) {
+            lines.push(`   - ${link.title ?? link.url}: ${link.url}`);
+          }
+        }
+      }
+      if (item.images.length > 0) {
+        lines.push("   Images:");
+        for (const img of item.images) {
+          lines.push(`   - ${img.url}${typeof img.width === "number" && typeof img.height === "number" ? ` (${img.width}x${img.height})` : ""}`);
+        }
+      }
+      return lines.join("\n");
+    })
+    .join("\n\n");
+}
+
+export const cozeWebFetchTool: ToolDefinition = {
+  name: "coze_web_fetch",
+  label: "Coze Web Fetch",
+  description:
+    "Fetch and extract structured content from web pages or documents through Coze.",
+  parameters: FetchToolSchema,
+  async execute(_toolCallId, rawParams) {
+    const params = rawParams as Static<typeof FetchToolSchema>;
+    const urls = typeof params.urls === "string" ? [params.urls] : params.urls;
+    const textOnly = params.textOnly === true;
+    console.log("[coze_web_fetch] urls=%s textOnly=%s format=%s", urls.join(", "), textOnly, params.format ?? "text");
+    try {
+      const items = await fetchContent(urls, textOnly);
+      console.log("[coze_web_fetch] done, %d pages fetched", items.length);
+      const format = params.format ?? "text";
+      return {
+        content: [{ type: "text", text: renderFetchedText(items, format) }],
+        details: { urls, format, count: items.length },
+      };
+    } catch (error) {
+      const message = formatCozeError(error);
+      console.error("[coze_web_fetch] error:", message);
+      return {
+        content: [{ type: "text", text: `Error: ${message}` }],
+        details: { error: true, message },
+      };
+    }
+  },
+};

package/lib/__templates__/pi-agent/src/tools/web-search/index.ts

@@ -0,0 +1,206 @@
+import { type Static, Type } from "@sinclair/typebox";
+import type { ToolDefinition } from "@mariozechner/pi-coding-agent";
+import { SearchClient, type ImageItem, type SearchResponse, type WebItem } from "coze-coding-dev-sdk";
+import { formatCozeError } from "../common/format-coze-error.js";
+
+type SearchResultItem = {
+  title: string;
+  url?: string;
+  siteName?: string;
+  snippet?: string;
+  content?: string;
+  publishTime?: string;
+  imageUrl?: string;
+  imageWidth?: number;
+  imageHeight?: number;
+};
+
+type SearchResult = {
+  query: string;
+  type: "web" | "image";
+  summary?: string;
+  items: SearchResultItem[];
+};
+
+function mapWebItem(item: WebItem): SearchResultItem {
+  return {
+    title: item.title,
+    url: item.url,
+    siteName: item.site_name,
+    snippet: item.snippet,
+    content: item.content,
+    publishTime: item.publish_time,
+  };
+}
+
+function mapImageItem(item: ImageItem): SearchResultItem {
+  return {
+    title: item.title ?? "Untitled",
+    url: item.url,
+    siteName: item.site_name,
+    publishTime: item.publish_time,
+    imageUrl: item.image?.url,
+    imageWidth: item.image?.width,
+    imageHeight: item.image?.height,
+  };
+}
+
+type SearchInput = {
+  query: string;
+  type?: "web" | "image";
+  count?: number;
+  timeRange?: string;
+  sites?: string;
+  blockHosts?: string;
+  needSummary?: boolean;
+  needContent?: boolean;
+};
+
+async function searchWeb(input: SearchInput): Promise<SearchResult> {
+  const client = new SearchClient();
+  const type = input.type ?? "web";
+  const count = input.count ?? 10;
+  let response: SearchResponse;
+
+  if (type === "image") {
+    response = await client.imageSearch(input.query, count);
+    return {
+      query: input.query,
+      type,
+      items: (response.image_items ?? []).map(mapImageItem),
+    };
+  }
+
+  const hasAdvanced = Boolean(input.timeRange || input.sites || input.blockHosts || input.needContent);
+  if (hasAdvanced) {
+    response = await client.advancedSearch(input.query, {
+      searchType: "web",
+      count,
+      timeRange: input.timeRange,
+      sites: input.sites,
+      blockHosts: input.blockHosts,
+      needSummary: input.needSummary,
+      needContent: input.needContent,
+    });
+  } else {
+    response = await client.webSearch(input.query, count, input.needSummary);
+  }
+
+  return {
+    query: input.query,
+    type,
+    summary: response.summary,
+    items: (response.web_items ?? []).map(mapWebItem),
+  };
+}
+
+const SearchToolSchema = Type.Object(
+  {
+    query: Type.String({ description: "Search query." }),
+    type: Type.Optional(
+      Type.Unsafe<"web" | "image">({
+        type: "string",
+        enum: ["web", "image"],
+        description: "Search type. Defaults to web.",
+      }),
+    ),
+    count: Type.Optional(
+      Type.Integer({
+        description: "Number of results to return.",
+        minimum: 1,
+        maximum: 20,
+      }),
+    ),
+    timeRange: Type.Optional(
+      Type.Unsafe<"1d" | "1w" | "1m">({
+        type: "string",
+        enum: ["1d", "1w", "1m"],
+        description: "Recency filter for web search.",
+      }),
+    ),
+    sites: Type.Optional(
+      Type.String({ description: "Comma-separated domains to include." }),
+    ),
+    blockHosts: Type.Optional(
+      Type.String({ description: "Comma-separated domains to exclude." }),
+    ),
+    needSummary: Type.Optional(
+      Type.Boolean({ description: "Whether to include Coze summary output." }),
+    ),
+    needContent: Type.Optional(
+      Type.Boolean({ description: "Whether to include extracted page content." }),
+    ),
+  },
+  { additionalProperties: false },
+);
+
+function buildSearchText(
+  result: SearchResult,
+  options: { includeContent: boolean },
+): string {
+  const lines = [`Coze web search: ${result.query}`];
+  if (result.summary) {
+    lines.push("", `Summary: ${result.summary}`);
+  }
+  lines.push("", `Results (${result.items.length})`);
+  for (const [index, item] of result.items.entries()) {
+    lines.push(`${index + 1}. ${item.title}`);
+    if (item.url) {
+      lines.push(`   URL: ${item.url}`);
+    }
+    if (item.imageUrl) {
+      lines.push(`   Image: ${item.imageUrl}`);
+    }
+    if (item.siteName) {
+      lines.push(`   Source: ${item.siteName}`);
+    }
+    if (item.publishTime) {
+      lines.push(`   Published: ${item.publishTime}`);
+    }
+    if (item.snippet) {
+      lines.push(`   ${item.snippet}`);
+    }
+    if (options.includeContent && item.content) {
+      lines.push("   Content:");
+      lines.push(`   ${item.content}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+export const cozeWebSearchTool: ToolDefinition = {
+  name: "coze_web_search",
+  label: "Coze Web Search",
+  description:
+    "Search the web or images through Coze. Supports summaries, recency filters, and site restrictions.",
+  parameters: SearchToolSchema,
+  async execute(_toolCallId, rawParams) {
+    const params = rawParams as Static<typeof SearchToolSchema>;
+    console.log("[coze_web_search] query=%s type=%s count=%s", params.query, params.type ?? "web", params.count ?? 10);
+    try {
+      const result = await searchWeb(params);
+      console.log("[coze_web_search] done, %d results", result.items.length);
+      return {
+        content: [
+          {
+            type: "text",
+            text: buildSearchText(result, { includeContent: params.needContent === true }),
+          },
+        ],
+        details: {
+          query: result.query,
+          type: result.type,
+          summary: result.summary,
+          count: result.items.length,
+        },
+      };
+    } catch (error) {
+      const message = formatCozeError(error);
+      console.error("[coze_web_search] error:", message);
+      return {
+        content: [{ type: "text", text: `Error: ${message}` }],
+        details: { error: true, message },
+      };
+    }
+  },
+};

package/lib/__templates__/pi-agent/template.config.js

@@ -0,0 +1,45 @@
+
+
+
+
+
+
+
+
+
+export const paramsSchema = {
+  type: 'object',
+  properties: {
+    port: {
+      type: 'number',
+      default: 5000,
+      minimum: 1024,
+      maximum: 65535,
+      description: 'Dashboard server port',
+    },
+    workspaceDir: {
+      type: 'string',
+      default: '/workspace/workspace',
+      description: 'Workspace directory path',
+    },
+  },
+  required: [],
+  additionalProperties: false,
+};
+
+const config = {
+  description:
+    'Pi Agent：`coze init ${COZE_WORKSPACE_PATH} --template pi-agent`\n' +
+    '- 适用：基于 pi-agent-core 的 AI Agent 应用\n' +
+    '- 支持飞书、微信等多渠道接入\n' +
+    '- 内置 Dashboard 管理面板\n' +
+    '- 使用 TypeScript + Express + Vite',
+  paramsSchema,
+
+  defaultParams: {
+    port: 5000,
+    workspaceDir: '/workspace/workspace',
+  },
+};
+
+export default config;

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);
+});