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

package/lib/__templates__/pi-agent/src/dashboard/web/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "extends": "../../../tsconfig.json",
+  "compilerOptions": {
+    "jsx": "react-jsx",
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "types": ["vite/client"],
+    "noEmit": true
+  },
+  "include": ["vite.config.ts", "src/**/*.ts", "src/**/*.tsx"]
+}
+

package/lib/__templates__/pi-agent/src/dashboard/web/vite.config.ts

@@ -0,0 +1,17 @@
+import { defineConfig } from "vite";
+import react from "@vitejs/plugin-react";
+import { fileURLToPath } from "node:url";
+import { dirname, resolve } from "node:path";
+
+const DIR = dirname(fileURLToPath(import.meta.url));
+
+export default defineConfig({
+  root: DIR,
+  plugins: [react()],
+  base: "/",
+  build: {
+    outDir: resolve(DIR, "dist"),
+    emptyOutDir: true,
+  },
+});
+

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

@@ -0,0 +1,123 @@
+import { fileURLToPath } from "node:url";
+import type { BotAppConfig } from "./core.js";
+import type { FeishuChannel } from "./channels/feishu/index.js";
+import { createFeishuChannel } from "./channels/feishu/index.js";
+import type { WechatChannel } from "./channels/wechat/index.js";
+import { createWechatChannel } from "./channels/wechat/index.js";
+import { loadBotAppConfig } from "./config.js";
+import { createAgentRuntime } from "./agent.js";
+import type { DashboardServer } from "./dashboard/types.js";
+import { createDashboard } from "./dashboard/index.js";
+import type { ConfigStore } from "./dashboard/config-store.js";
+
+export interface BotApp {
+  config: BotAppConfig;
+  channels: {
+    feishu?: FeishuChannel;
+    wechat?: WechatChannel;
+  };
+  dashboard: DashboardServer;
+  start(): Promise<void>;
+  stop(): Promise<void>;
+}
+
+export async function createBotApp(
+  config: BotAppConfig = loadBotAppConfig(),
+  options: { dashboardConfigStore?: ConfigStore } = {},
+): Promise<BotApp> {
+  const runtime = await createAgentRuntime(config.agent);
+  const channels: BotApp["channels"] = {};
+
+  if (config.channels.feishu?.enabled) {
+    channels.feishu = createFeishuChannel(
+      {
+        appId: config.channels.feishu.appId,
+        appSecret: config.channels.feishu.appSecret,
+        domain: config.channels.feishu.domain,
+        encryptKey: config.channels.feishu.encryptKey,
+        verificationToken: config.channels.feishu.verificationToken,
+        routing: {
+          groupRequireMention: config.routing.feishuGroupRequireMention
+        }
+      },
+      {
+        async onMessage(message) {
+          const text = await runtime.run(message);
+          return { text };
+        },
+        async onStreamMessage(message, handlers) {
+          const result = await runtime.stream(message, {
+            onMeta: handlers.onMeta,
+            onDelta: handlers.onDelta,
+            onError: handlers.onError
+          });
+          return { text: result.finalText };
+        }
+      }
+    );
+  }
+
+  if (config.channels.wechat?.enabled) {
+    channels.wechat = createWechatChannel(
+      {
+        routing: {
+          groupRequireMention: config.routing.wechatGroupRequireMention
+        }
+      },
+      {
+        async onMessage(message) {
+          const text = await runtime.run(message);
+          return { text };
+        }
+      }
+    );
+  }
+
+  const dashboard = createDashboard({
+    botConfig: config,
+    channels,
+    agentRuntime: runtime,
+    configStore: options.dashboardConfigStore,
+  });
+
+  return {
+    config,
+    channels,
+    dashboard,
+    async start() {
+      await Promise.all([
+        ...Object.values(channels).map((channel) => channel.start()),
+        dashboard.start()
+      ]);
+    },
+    async stop() {
+      await Promise.all([
+        ...Object.values(channels).map((channel) => channel.stop()),
+        dashboard.stop()
+      ]);
+      await runtime.dispose();
+    }
+  };
+}
+
+export async function main(): Promise<void> {
+  const config = loadBotAppConfig();
+  const app = await createBotApp(config);
+  await app.start();
+
+  console.log(`[${config.appName}] started`);
+  console.log(`Feishu enabled: ${Boolean(app.channels.feishu)}`);
+  console.log(`WeChat enabled: ${Boolean(app.channels.wechat)}`);
+  console.log(`Dashboard: ${app.dashboard.getUrl()}`);
+  console.log(`Agent mode: ${config.agent.mode}`);
+  console.log(`Workspace dir: ${config.agent.cwd}`);
+  console.log(`Agent dir: ${config.agent.agentDir}`);
+}
+
+const entrypoint = process.argv[1];
+if (entrypoint && fileURLToPath(import.meta.url) === entrypoint) {
+  main().catch((error: unknown) => {
+    console.error(error);
+    process.exit(1);
+  });
+}

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

@@ -0,0 +1,125 @@
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { DefaultResourceLoader, type SettingsManager } from "@mariozechner/pi-coding-agent";
+import { getProjectRoot } from "./config.js";
+
+type PiResourceLoaderArgs = {
+  cwd: string;
+  agentDir?: string;
+  settingsManager: SettingsManager;
+};
+
+export function getPiResourcesDir(): string {
+  return join(getProjectRoot(), "pi-resources");
+}
+
+export function buildPiResourceLoaderOptions(
+  args: PiResourceLoaderArgs
+): ConstructorParameters<typeof DefaultResourceLoader>[0] {
+  const piResourcesDir = getPiResourcesDir();
+  const repoSystemPromptPath = join(piResourcesDir, "SYSTEM.md");
+  const repoAppendSystemPromptPath = join(piResourcesDir, "APPEND_SYSTEM.md");
+  const localSystemPromptPath = join(args.cwd, ".pi", "SYSTEM.md");
+  const localAppendSystemPromptPath = join(args.cwd, ".pi", "APPEND_SYSTEM.md");
+  const systemPromptSource = pickFirstExistingPath([localSystemPromptPath, repoSystemPromptPath]);
+  const appendSystemPromptSource = pickFirstExistingPath([
+    localAppendSystemPromptPath,
+    repoAppendSystemPromptPath
+  ]);
+
+  return {
+    cwd: args.cwd,
+    agentDir: args.agentDir,
+    settingsManager: args.settingsManager,
+    additionalExtensionPaths: discoverExtensionEntries(join(piResourcesDir, "extensions")),
+    additionalSkillPaths: existingPaths([join(piResourcesDir, "skills")]),
+    additionalPromptTemplatePaths: existingPaths([join(piResourcesDir, "prompts")]),
+    // Keep the bot runtime independent from repo/workspace AGENTS.md files.
+    agentsFilesOverride: () => ({ agentsFiles: [] }),
+    // Make source precedence explicit instead of expressing it indirectly through
+    // override callbacks: workspace/.pi wins, then repo-managed resources, then the
+    // loader's own defaults when neither exists.
+    systemPrompt: systemPromptSource,
+    appendSystemPrompt: appendSystemPromptSource
+  };
+}
+
+export function createPiResourceLoader(args: PiResourceLoaderArgs): DefaultResourceLoader {
+  return new DefaultResourceLoader(buildPiResourceLoaderOptions(args));
+}
+
+function existingPaths(paths: string[]): string[] {
+  return paths.filter((path) => existsSync(path));
+}
+
+function pickFirstExistingPath(paths: string[]): string | undefined {
+  return paths.find((path) => existsSync(path));
+}
+
+function discoverExtensionEntries(dir: string): string[] {
+  if (!existsSync(dir)) {
+    return [];
+  }
+
+  const discovered = new Set<string>();
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    if (entry.name.startsWith(".")) {
+      continue;
+    }
+
+    const entryPath = join(dir, entry.name);
+    if (entry.isFile() && isExtensionModule(entry.name)) {
+      discovered.add(entryPath);
+      continue;
+    }
+
+    if (!entry.isDirectory()) {
+      continue;
+    }
+
+    for (const extensionEntry of resolveExtensionEntries(entryPath)) {
+      discovered.add(extensionEntry);
+    }
+  }
+
+  return Array.from(discovered);
+}
+
+function resolveExtensionEntries(dir: string): string[] {
+  const packageJsonPath = join(dir, "package.json");
+  if (existsSync(packageJsonPath)) {
+    const manifest = readPiManifest(packageJsonPath);
+    if (manifest?.extensions?.length) {
+      return manifest.extensions
+        .map((extensionPath) => join(dir, extensionPath))
+        .filter((extensionPath) => existsSync(extensionPath));
+    }
+  }
+
+  const indexTs = join(dir, "index.ts");
+  if (existsSync(indexTs)) {
+    return [indexTs];
+  }
+
+  const indexJs = join(dir, "index.js");
+  if (existsSync(indexJs)) {
+    return [indexJs];
+  }
+
+  return [];
+}
+
+function readPiManifest(packageJsonPath: string): { extensions?: string[] } | undefined {
+  try {
+    const pkg = JSON.parse(readFileSync(packageJsonPath, "utf-8")) as {
+      pi?: { extensions?: string[] };
+    };
+    return pkg.pi;
+  } catch {
+    return undefined;
+  }
+}
+
+function isExtensionModule(fileName: string): boolean {
+  return fileName.endsWith(".ts") || fileName.endsWith(".js");
+}

package/lib/__templates__/pi-agent/src/session-store.ts

@@ -0,0 +1,223 @@
+import { createHash, randomUUID } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { CURRENT_SESSION_VERSION } from "@mariozechner/pi-coding-agent";
+
+export type SessionRecord = {
+  sessionKey: string;
+  keyHash: string;
+  sessionId: string;
+  sessionFile: string;
+  updatedAt: number;
+};
+
+type IndexFileShapeV1 = {
+  version: 1;
+  updatedAt: number;
+  sessions: Record<
+    string,
+    {
+      keyHash: string;
+      sessionId: string;
+      sessionFile: string;
+      updatedAt: number;
+    }
+  >;
+};
+
+function sha256Hex(input: string): string {
+  return createHash("sha256").update(input).digest("hex");
+}
+
+function safeRename(from: string, to: string): void {
+  try {
+    fs.renameSync(from, to);
+  } catch {
+    // best-effort
+  }
+}
+
+function ensureDir(dirPath: string): void {
+  fs.mkdirSync(dirPath, { recursive: true });
+}
+
+function readJsonFile(filePath: string): unknown {
+  const raw = fs.readFileSync(filePath, "utf-8");
+  return JSON.parse(raw) as unknown;
+}
+
+function writeFileAtomic(filePath: string, content: string, mode: number): void {
+  const dir = path.dirname(filePath);
+  ensureDir(dir);
+  const tmpPath = `${filePath}.tmp`;
+  fs.writeFileSync(tmpPath, content, { encoding: "utf-8", mode });
+  fs.renameSync(tmpPath, filePath);
+}
+
+function ensureTranscriptHeader(params: { sessionFile: string; sessionId: string }): void {
+  if (fs.existsSync(params.sessionFile)) {
+    return;
+  }
+  ensureDir(path.dirname(params.sessionFile));
+  const header = {
+    type: "session",
+    version: CURRENT_SESSION_VERSION,
+    id: params.sessionId,
+    timestamp: new Date().toISOString(),
+    cwd: process.cwd(),
+  };
+  fs.writeFileSync(params.sessionFile, `${JSON.stringify(header)}\n`, {
+    encoding: "utf-8",
+    mode: 0o600,
+  });
+}
+
+function decodeIndexFileShapeV1(value: unknown): IndexFileShapeV1 | null {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const rec = value as Record<string, unknown>;
+  if (rec.version !== 1) return null;
+  if (!("sessions" in rec) || !rec.sessions || typeof rec.sessions !== "object" || Array.isArray(rec.sessions)) {
+    return null;
+  }
+  const updatedAt = typeof rec.updatedAt === "number" ? rec.updatedAt : Date.now();
+  const sessions = rec.sessions as Record<string, unknown>;
+  const out: IndexFileShapeV1["sessions"] = {};
+  for (const [sessionKey, entry] of Object.entries(sessions)) {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) continue;
+    const e = entry as Record<string, unknown>;
+    const keyHash = typeof e.keyHash === "string" ? e.keyHash : "";
+    const sessionId = typeof e.sessionId === "string" ? e.sessionId : "";
+    const sessionFile = typeof e.sessionFile === "string" ? e.sessionFile : "";
+    const entryUpdatedAt = typeof e.updatedAt === "number" ? e.updatedAt : updatedAt;
+    if (!sessionKey || !keyHash || !sessionId || !sessionFile) continue;
+    out[sessionKey] = { keyHash, sessionId, sessionFile, updatedAt: entryUpdatedAt };
+  }
+  return { version: 1, updatedAt, sessions: out };
+}
+
+export class SessionStore {
+  private readonly sessionsDir: string;
+  private readonly indexPath: string;
+  private readonly transcriptsDir: string;
+  private readonly archiveDir: string;
+  private readonly cache = new Map<string, SessionRecord>();
+
+  constructor(private readonly agentDir: string) {
+    this.sessionsDir = path.join(agentDir, ".pi-bot", "sessions");
+    this.indexPath = path.join(this.sessionsDir, "index.json");
+    this.transcriptsDir = path.join(this.sessionsDir, "transcripts");
+    this.archiveDir = path.join(this.sessionsDir, "archive");
+  }
+
+  load(): void {
+    this.cache.clear();
+
+    if (!fs.existsSync(this.indexPath)) {
+      return;
+    }
+
+    try {
+      const decoded = decodeIndexFileShapeV1(readJsonFile(this.indexPath));
+      if (!decoded) {
+        throw new Error("invalid index.json schema");
+      }
+      for (const [sessionKey, entry] of Object.entries(decoded.sessions)) {
+        this.cache.set(sessionKey, {
+          sessionKey,
+          keyHash: entry.keyHash,
+          sessionId: entry.sessionId,
+          sessionFile: entry.sessionFile,
+          updatedAt: entry.updatedAt,
+        });
+      }
+    } catch {
+      // Keep a corrupt copy for debugging instead of crashing startup.
+      safeRename(this.indexPath, `${this.indexPath}.corrupt-${Date.now()}`);
+      this.cache.clear();
+    }
+  }
+
+  listSessionKeys(): string[] {
+    return Array.from(this.cache.keys());
+  }
+
+  get(sessionKey: string): SessionRecord | undefined {
+    return this.cache.get(sessionKey);
+  }
+
+  ensureSession(sessionKey: string): SessionRecord {
+    const existing = this.cache.get(sessionKey);
+    if (existing) {
+      // If the transcript was deleted externally, recreate the header so the
+      // session remains recoverable.
+      ensureTranscriptHeader({ sessionFile: existing.sessionFile, sessionId: existing.sessionId });
+      return existing;
+    }
+
+    const now = Date.now();
+    const keyHash = sha256Hex(sessionKey);
+    const sessionId = randomUUID();
+    const sessionFile = path.join(this.transcriptsDir, `${keyHash}-${sessionId}.jsonl`);
+    const record: SessionRecord = {
+      sessionKey,
+      keyHash,
+      sessionId,
+      sessionFile,
+      updatedAt: now,
+    };
+    this.cache.set(sessionKey, record);
+    ensureTranscriptHeader({ sessionFile, sessionId });
+    this.saveIndex();
+    return record;
+  }
+
+  resetSession(sessionKey: string): SessionRecord {
+    const prior = this.cache.get(sessionKey);
+    if (prior && fs.existsSync(prior.sessionFile)) {
+      ensureDir(this.archiveDir);
+      const baseName = path.basename(prior.sessionFile);
+      const archivedBase = baseName.endsWith(".jsonl") ? baseName : `${baseName}.jsonl`;
+      const archivedPathCandidate = path.join(this.archiveDir, archivedBase);
+      const archivedPath = fs.existsSync(archivedPathCandidate)
+        ? path.join(this.archiveDir, `${prior.keyHash}-${prior.sessionId}-${Date.now()}.jsonl`)
+        : archivedPathCandidate;
+      safeRename(prior.sessionFile, archivedPath);
+    }
+
+    // Keep keyHash stable for this sessionKey, rotate sessionId + sessionFile.
+    const now = Date.now();
+    const keyHash = prior?.keyHash ?? sha256Hex(sessionKey);
+    const sessionId = randomUUID();
+    const sessionFile = path.join(this.transcriptsDir, `${keyHash}-${sessionId}.jsonl`);
+    const next: SessionRecord = {
+      sessionKey,
+      keyHash,
+      sessionId,
+      sessionFile,
+      updatedAt: now,
+    };
+    this.cache.set(sessionKey, next);
+    ensureTranscriptHeader({ sessionFile, sessionId });
+    this.saveIndex();
+    return next;
+  }
+
+  private saveIndex(): void {
+    const now = Date.now();
+    const sessions: IndexFileShapeV1["sessions"] = {};
+    for (const [sessionKey, entry] of this.cache.entries()) {
+      sessions[sessionKey] = {
+        keyHash: entry.keyHash,
+        sessionId: entry.sessionId,
+        sessionFile: entry.sessionFile,
+        updatedAt: entry.updatedAt,
+      };
+    }
+    const payload: IndexFileShapeV1 = {
+      version: 1,
+      updatedAt: now,
+      sessions,
+    };
+    writeFileAtomic(this.indexPath, JSON.stringify(payload, null, 2), 0o600);
+  }
+}

package/lib/__templates__/pi-agent/src/tools/common/format-coze-error.ts

@@ -0,0 +1,12 @@
+export function formatCozeError(error: unknown): string {
+  if (error && typeof error === "object" && "message" in error) {
+    const message = String(error.message);
+    const status =
+      "statusCode" in error && typeof error.statusCode === "number" ? ` (${error.statusCode})` : "";
+    return `${message}${status}`;
+  }
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}

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

@@ -0,0 +1,2 @@
+export { cozeWebSearchTool } from "./web-search/index.js";
+export { cozeWebFetchTool } from "./web-fetch/index.js";