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

package/lib/__templates__/pi-agent/src/dashboard/web/src/styles.css

@@ -0,0 +1,294 @@
+@import "tailwindcss";
+@source "../../../../node_modules/streamdown/dist/*.js";
+@source "../../../../node_modules/@streamdown/code/dist/*.js";
+
+:root {
+  color-scheme: light;
+  --background: oklch(1 0 0);
+  --foreground: oklch(0.145 0 0);
+  --card: oklch(1 0 0);
+  --card-foreground: oklch(0.145 0 0);
+  --popover: oklch(1 0 0);
+  --popover-foreground: oklch(0.145 0 0);
+  --primary: oklch(0.205 0 0);
+  --primary-foreground: oklch(0.985 0 0);
+  --secondary: oklch(0.97 0 0);
+  --secondary-foreground: oklch(0.205 0 0);
+  --muted: oklch(0.97 0 0);
+  --muted-foreground: oklch(0.556 0 0);
+  --accent: oklch(0.97 0 0);
+  --accent-foreground: oklch(0.205 0 0);
+  --destructive: oklch(0.577 0.245 27.325);
+  --destructive-foreground: oklch(0.985 0 0);
+  --border: oklch(0.922 0 0);
+  --input: oklch(0.922 0 0);
+  --ring: oklch(0.708 0 0);
+  --radius: 0.625rem;
+}
+
+.dark {
+  color-scheme: dark;
+  --background: oklch(0.145 0 0);
+  --foreground: oklch(0.985 0 0);
+  --card: oklch(0.205 0 0);
+  --card-foreground: oklch(0.985 0 0);
+  --popover: oklch(0.205 0 0);
+  --popover-foreground: oklch(0.985 0 0);
+  --primary: oklch(0.922 0 0);
+  --primary-foreground: oklch(0.205 0 0);
+  --secondary: oklch(0.269 0 0);
+  --secondary-foreground: oklch(0.985 0 0);
+  --muted: oklch(0.269 0 0);
+  --muted-foreground: oklch(0.708 0 0);
+  --accent: oklch(0.269 0 0);
+  --accent-foreground: oklch(0.985 0 0);
+  --destructive: oklch(0.704 0.191 22.216);
+  --destructive-foreground: oklch(0.985 0 0);
+  --border: oklch(1 0 0 / 10%);
+  --input: oklch(1 0 0 / 15%);
+  --ring: oklch(0.556 0 0);
+}
+
+@theme inline {
+  --font-sans: ui-sans-serif, system-ui, -apple-system, "Segoe UI", Roboto, Arial, "Apple Color Emoji", "Segoe UI Emoji";
+  --color-background: var(--background);
+  --color-foreground: var(--foreground);
+  --color-card: var(--card);
+  --color-card-foreground: var(--card-foreground);
+  --color-popover: var(--popover);
+  --color-popover-foreground: var(--popover-foreground);
+  --color-primary: var(--primary);
+  --color-primary-foreground: var(--primary-foreground);
+  --color-secondary: var(--secondary);
+  --color-secondary-foreground: var(--secondary-foreground);
+  --color-muted: var(--muted);
+  --color-muted-foreground: var(--muted-foreground);
+  --color-accent: var(--accent);
+  --color-accent-foreground: var(--accent-foreground);
+  --color-destructive: var(--destructive);
+  --color-destructive-foreground: var(--destructive-foreground);
+  --color-border: var(--border);
+  --color-input: var(--input);
+  --color-ring: var(--ring);
+  --radius-sm: calc(var(--radius) - 6px);
+  --radius-md: calc(var(--radius) - 2px);
+  --radius-lg: var(--radius);
+  --radius-xl: calc(var(--radius) + 8px);
+}
+
+@layer base {
+  * {
+    box-sizing: border-box;
+  }
+
+  body {
+    @apply bg-background font-sans text-foreground antialiased transition-colors;
+    height: 100vh;
+    overflow: hidden;
+  }
+
+  #root {
+    height: 100%;
+  }
+
+  a {
+    @apply text-inherit;
+  }
+
+  h1,
+  h2,
+  h3,
+  p {
+    @apply m-0;
+  }
+}
+
+@supports (height: 100dvh) {
+  @layer base {
+    body {
+      height: 100dvh;
+    }
+  }
+}
+
+.streamdown-content [data-streamdown] {
+  overflow-wrap: anywhere;
+}
+
+.streamdown-content [data-streamdown="code-block"] {
+  position: relative;
+  margin: 1rem 0;
+  gap: 0.5rem;
+  border: 1px solid color-mix(in oklab, var(--border) 100%, transparent);
+  border-radius: 0.875rem;
+  background: color-mix(in oklab, var(--muted) 65%, var(--background));
+  padding: 0.75rem;
+}
+
+.streamdown-content [data-streamdown="code-block-header"] {
+  display: flex;
+  min-height: 1.75rem;
+  align-items: center;
+  height: auto;
+  padding: 0 4.5rem 0 0.125rem;
+  color: var(--muted-foreground);
+  font-size: 0.75rem;
+}
+
+.streamdown-content [data-streamdown="code-block-header"] + div {
+  position: absolute;
+  top: 0.75rem;
+  right: 0.75rem;
+  left: auto;
+  z-index: 20;
+  margin: 0;
+  padding: 0;
+}
+
+.streamdown-content [data-streamdown="code-block-actions"] {
+  gap: 0.375rem;
+  border: 1px solid color-mix(in oklab, var(--border) 100%, transparent);
+  border-radius: 0.625rem;
+  background: color-mix(in oklab, var(--background) 88%, transparent);
+  padding: 0.25rem;
+  box-shadow: none;
+  backdrop-filter: none;
+}
+
+.streamdown-content [data-streamdown="code-block-actions"] button {
+  display: inline-flex;
+  height: 1.75rem;
+  width: 1.75rem;
+  align-items: center;
+  justify-content: center;
+  border: 0;
+  border-radius: 0.5rem;
+  background: transparent;
+  color: var(--muted-foreground);
+  transition:
+    background-color 150ms ease,
+    color 150ms ease;
+}
+
+.streamdown-content [data-streamdown="code-block-actions"] button:hover {
+  background: color-mix(in oklab, var(--accent) 100%, transparent);
+  color: var(--foreground);
+}
+
+.streamdown-content [data-streamdown="code-block-actions"] button:focus-visible {
+  outline: 2px solid color-mix(in oklab, var(--ring) 65%, transparent);
+  outline-offset: 1px;
+}
+
+.streamdown-content [data-streamdown="code-block-body"] {
+  border: 1px solid color-mix(in oklab, var(--border) 100%, transparent);
+  border-radius: 0.75rem;
+  background: color-mix(in oklab, var(--background) 92%, var(--muted));
+  margin-top: 0.5rem;
+  padding: 0.875rem 1rem;
+}
+
+.streamdown-content [data-streamdown="code-block-body"] pre {
+  margin: 0;
+  background: transparent;
+}
+
+.streamdown-content pre {
+  overflow: auto;
+}
+
+.streamdown-content img {
+  max-width: 100%;
+  height: auto;
+}
+
+.docs-content [data-streamdown] {
+  overflow-wrap: anywhere;
+}
+
+.docs-content h1,
+.docs-content h2,
+.docs-content h3,
+.docs-content h4 {
+  margin: 1.5rem 0 0.75rem;
+  font-weight: 600;
+  letter-spacing: -0.02em;
+}
+
+.docs-content h1:first-child,
+.docs-content h2:first-child,
+.docs-content h3:first-child {
+  margin-top: 0;
+}
+
+.docs-content h1 {
+  font-size: 1.5rem;
+}
+
+.docs-content h2 {
+  font-size: 1.2rem;
+}
+
+.docs-content h3 {
+  font-size: 1rem;
+}
+
+.docs-content p,
+.docs-content ul,
+.docs-content ol,
+.docs-content table,
+.docs-content blockquote {
+  margin: 0.75rem 0;
+}
+
+.docs-content ul,
+.docs-content ol {
+  padding-left: 1.25rem;
+}
+
+.docs-content li + li {
+  margin-top: 0.35rem;
+}
+
+.docs-content a {
+  color: var(--primary);
+  text-decoration: underline;
+  text-underline-offset: 0.2em;
+}
+
+.docs-content hr {
+  margin: 1.25rem 0;
+  border: 0;
+  border-top: 1px solid color-mix(in oklab, var(--border) 100%, transparent);
+}
+
+.docs-content blockquote {
+  border-left: 3px solid color-mix(in oklab, var(--border) 100%, transparent);
+  padding-left: 1rem;
+  color: var(--muted-foreground);
+}
+
+.docs-content table {
+  width: 100%;
+  border-collapse: collapse;
+  overflow: hidden;
+  border-radius: 0.875rem;
+  border: 1px solid color-mix(in oklab, var(--border) 100%, transparent);
+}
+
+.docs-content th,
+.docs-content td {
+  border-bottom: 1px solid color-mix(in oklab, var(--border) 100%, transparent);
+  padding: 0.75rem;
+  text-align: left;
+  vertical-align: top;
+}
+
+.docs-content th {
+  background: color-mix(in oklab, var(--muted) 80%, var(--background));
+  font-weight: 600;
+}
+
+.docs-content tbody tr:last-child td {
+  border-bottom: 0;
+}

package/lib/__templates__/pi-agent/src/dashboard/web/src/utils/index.ts

@@ -0,0 +1,11 @@
+import { type ClassValue, clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+import { cloneDeep } from "lodash-es";
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs));
+}
+
+export function deepClone<T>(value: T): T {
+  return cloneDeep(value);
+}

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