@dyyz1993/create-agent 1.9.0

package/templates/agent/src/mainview/types/index.ts

@@ -0,0 +1,33 @@
+export type TreeNode = {
+  name: string;
+  path: string;
+  type: "file" | "directory";
+  size?: number;
+  children?: TreeNode[];
+  expanded?: boolean;
+  loaded?: boolean;
+};
+
+export type DemoMethod = "system.ping" | "system.hello" | "system.echo" | "chat.send";
+
+export type FilePreview = {
+  path: string;
+  name: string;
+  content: string | null;
+  imageUrl: string | null;
+  mimeType: string;
+  size: number;
+  isText: boolean;
+  isImage: boolean;
+  totalLines?: number;
+};
+
+export type ChatMessage = {
+  id: string;
+  role: "user" | "assistant";
+  content: string;
+  timestamp: number;
+};
+
+export type EditingType = "rename" | "newFile" | "newDir";
+export type EditingNode = { path: string; type: EditingType };

package/templates/agent/src/mainview/utils/constants.ts

@@ -0,0 +1 @@
+export const MAX_PREVIEW_SIZE = 500 * 1024; // 500KB

package/templates/agent/src/mainview/utils/drop-handler.ts

@@ -0,0 +1,150 @@
+import { apiClient } from "../lib/api-client";
+
+export interface DropEntry {
+  name: string;
+  relativePath: string;
+  file?: File;
+  isDirectory: boolean;
+  children?: DropEntry[];
+}
+
+/**
+ * 递归读取 webkitGetAsEntry，返回扁平文件列表 + 目录结构
+ */
+function readEntry(
+  entry: FileSystemEntry,
+  path: string,
+): Promise<DropEntry> {
+  if (entry.isFile) {
+    return new Promise((resolve) => {
+      (entry as FileSystemFileEntry).file((file) => {
+        resolve({ name: entry.name, relativePath: path, file, isDirectory: false });
+      });
+    });
+  }
+  // Directory
+  return new Promise((resolve) => {
+    const reader = (entry as FileSystemDirectoryEntry).createReader();
+    const children: DropEntry[] = [];
+
+    const readBatch = () => {
+      reader.readEntries(async (entries) => {
+        if (entries.length === 0) {
+          resolve({ name: entry.name, relativePath: path, isDirectory: true, children });
+          return;
+        }
+        for (const e of entries) {
+          children.push(await readEntry(e, `${path}/${e.name}`));
+        }
+        readBatch(); // readEntries may not return all entries in one call
+      });
+    };
+    readBatch();
+  });
+}
+
+/**
+ * 从 DataTransfer 递归读取所有文件和目录
+ */
+export async function readDropItems(dataTransfer: DataTransfer): Promise<DropEntry[]> {
+  const items = dataTransfer.items;
+  if (!items) return [];
+
+  const entries: DropEntry[] = [];
+  const tasks: Promise<void>[] = [];
+
+  for (let i = 0; i < items.length; i++) {
+    const item = items[i];
+    // Try webkitGetAsEntry (Chrome, Edge, Safari)
+    const entry = item.webkitGetAsEntry?.();
+    if (entry) {
+      tasks.push(
+        readEntry(entry, entry.name).then<void>((e) => { entries.push(e); }),
+      );
+    }
+  }
+
+  await Promise.all(tasks);
+  return entries;
+}
+
+/**
+ * Web 端：递归上传 entries 到目标目录
+ */
+export async function uploadEntriesWeb(entries: DropEntry[], destDir: string): Promise<number> {
+  let count = 0;
+
+  async function process(entry: DropEntry, currentDir: string): Promise<void> {
+    if (entry.isDirectory) {
+      // Create directory
+      const dirPath = `${currentDir}/${entry.name}`;
+      await apiClient.call("file.createDir", { dirPath: currentDir, name: entry.name });
+      count++;
+      if (entry.children) {
+        for (const child of entry.children) {
+          await process(child, dirPath);
+        }
+      }
+    } else if (entry.file) {
+      // Upload file via HTTP
+      const filePath = `${currentDir}/${entry.name}`;
+      const arrayBuffer = await entry.file.arrayBuffer();
+      const baseUrl = apiClient.getBaseUrl();
+      const token = apiClient.getAuthToken();
+      const res = await fetch(
+        `${baseUrl}/file/upload?path=${encodeURIComponent(filePath)}&token=${token}`,
+        { method: "POST", body: arrayBuffer },
+      );
+      if (!res.ok) throw new Error(`Upload failed: ${entry.name}`);
+      count++;
+    }
+  }
+
+  for (const entry of entries) {
+    await process(entry, destDir);
+  }
+  return count;
+}
+
+/**
+ * 桌面端：通过 RPC file.copy 直接复制
+ */
+export async function importFilesDesktop(entries: DropEntry[], destDir: string): Promise<number> {
+  let count = 0;
+
+  async function process(entry: DropEntry, currentDir: string): Promise<void> {
+    if (entry.isDirectory) {
+      const dirPath = `${currentDir}/${entry.name}`;
+      await apiClient.call("file.createDir", { dirPath: currentDir, name: entry.name });
+      count++;
+      if (entry.children) {
+        for (const child of entry.children) {
+          await process(child, dirPath);
+        }
+      }
+    } else if (entry.file) {
+      // Desktop: File object has .path property (Electron/Electrobun)
+      const srcPath = (entry.file as File & { path?: string }).path;
+      if (srcPath) {
+        await apiClient.call("file.copy", { srcPath, destDir: currentDir });
+      } else {
+        // Fallback: no path available, upload via HTTP
+        const filePath = `${currentDir}/${entry.name}`;
+        const arrayBuffer = await entry.file.arrayBuffer();
+        const baseUrl = apiClient.getBaseUrl();
+        const token = apiClient.getAuthToken();
+        const res = await fetch(
+          `${baseUrl}/file/upload?path=${encodeURIComponent(filePath)}&token=${token}`,
+          { method: "POST", body: arrayBuffer },
+        );
+        if (!res.ok) throw new Error(`Upload failed: ${entry.name}`);
+      }
+      count++;
+    }
+  }
+
+  for (const entry of entries) {
+    await process(entry, destDir);
+  }
+  return count;
+}

package/templates/agent/src/mainview/utils/file-icon.tsx

@@ -0,0 +1,24 @@
+import {
+  FolderOpen,
+  Folder,
+  FileText,
+  FileCode,
+  Image,
+  FileArchive,
+} from "lucide-react";
+import type { TreeNode } from "../types";
+
+export function getFileIcon(node: TreeNode) {
+  if (node.type === "directory") {
+    return node.expanded ? (
+      <FolderOpen className="w-4 h-4 text-yellow-400 shrink-0" />
+    ) : (
+      <Folder className="w-4 h-4 text-yellow-400 shrink-0" />
+    );
+  }
+  const ext = node.name.split(".").pop()?.toLowerCase() || "";
+  if (["ts", "tsx", "js", "jsx"].includes(ext)) return <FileCode className="w-4 h-4 text-blue-400 shrink-0" />;
+  if (["png", "jpg", "jpeg", "gif", "svg", "webp"].includes(ext)) return <Image className="w-4 h-4 text-green-400 shrink-0" />;
+  if (["zip", "gz", "tar", "rar"].includes(ext)) return <FileArchive className="w-4 h-4 text-orange-400 shrink-0" />;
+  return <FileText className="w-4 h-4 text-gray-400 shrink-0" />;
+}

package/templates/agent/src/mainview/utils/file-utils.ts

@@ -0,0 +1,35 @@
+export function getLanguage(filename: string): string {
+  const ext = filename.split(".").pop()?.toLowerCase() || "";
+  const map: Record<string, string> = {
+    ts: "typescript", tsx: "tsx", js: "javascript", jsx: "jsx",
+    mjs: "javascript", cjs: "javascript", mts: "typescript", cts: "typescript",
+    json: "json", html: "markup", css: "css", md: "markdown",
+    py: "python", rs: "rust", go: "go", sh: "bash", bash: "bash",
+    yml: "yaml", yaml: "yaml", toml: "toml", xml: "markup",
+    sql: "sql", graphql: "graphql",
+  };
+  return map[ext] || "";
+}
+
+export function isTextFile(filename: string): boolean {
+  const ext = filename.split(".").pop()?.toLowerCase() || "";
+  const textExts = new Set([
+    "ts", "tsx", "js", "jsx", "json", "html", "css", "scss", "less",
+    "md", "txt", "py", "rs", "go", "sh", "bash", "yml", "yaml", "toml",
+    "xml", "sql", "graphql", "env", "gitignore", "prettierrc", "eslintrc",
+    "lock", "log", "conf", "cfg", "ini", "csv", "tsv",
+    "mjs", "cjs", "mts", "cts", "map",
+  ]);
+  return textExts.has(ext);
+}
+
+export function isImageFile(filename: string): boolean {
+  const ext = filename.split(".").pop()?.toLowerCase() || "";
+  return ["png", "jpg", "jpeg", "gif", "svg", "webp", "ico", "bmp"].includes(ext);
+}
+
+export function formatSize(bytes: number): string {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}

package/templates/agent/src/server-config.ts

@@ -0,0 +1,43 @@
+/**
+ * Web server configuration — single source of truth.
+ * Values are read from environment variables with sensible defaults.
+ */
+
+export function parseEnvInt(
+  key: string,
+  value: string | undefined,
+  defaultValue: number,
+  min: number,
+  max: number,
+): number {
+  if (value === undefined || value === "") return defaultValue;
+  const parsed = parseInt(value, 10);
+  if (isNaN(parsed) || parsed < min || parsed > max) {
+    console.warn(
+      `[config] Invalid ${key}: "${value}", using default: ${defaultValue}`,
+    );
+    return defaultValue;
+  }
+  return parsed;
+}
+
+export const config = {
+  port: parseEnvInt("PORT", process.env.PORT, 3100, 1024, 65535),
+  authToken: process.env.AUTH_TOKEN || "pi-agent-template-token",
+  maxUploadSize: parseEnvInt(
+    "MAX_UPLOAD_SIZE",
+    process.env.MAX_UPLOAD_SIZE,
+    50 * 1024 * 1024,
+    0,
+    1024 * 1024 * 1024,
+  ),
+  logDir: process.env.LOG_DIR || "logs",
+  enableBash: process.env.ENABLE_BASH !== "false",
+  corsOrigin: process.env.CORS_ORIGIN || "http://localhost:5173",
+} as const;
+
+if (process.env.NODE_ENV === "production" && !process.env.AUTH_TOKEN) {
+  console.warn(
+    "[security] WARNING: Using default AUTH_TOKEN in production. Set AUTH_TOKEN environment variable.",
+  );
+}

package/templates/agent/src/server.ts

@@ -0,0 +1,89 @@
+/**
+ * Web server entry point — HTTP file endpoints + WebSocket RPC gateway.
+ * Port auto-negotiation: tries config.port first, increments on EADDRINUSE.
+ * Writes actual port to .server-port for dev orchestration.
+ */
+
+import { createServer } from "http";
+import { writeFileSync, unlinkSync, existsSync } from "fs";
+import { join, resolve, basename } from "path";
+import { config } from "./server-config";
+import { createHttpHandler } from "./gateway/http-routes";
+import { createWsHandler } from "./gateway/ws-handler";
+import { createLogger, configureLogDir } from "./shared/lib/logger";
+import { registerPort, unregisterPort, formatRegistryForOutput } from "./shared/lib/port-registry";
+import { discoverMethodNames } from "./shared/register-all-handlers";
+
+configureLogDir(config.logDir);
+const log = createLogger("server");
+
+const PORT_FILE = join(import.meta.dir, "..", ".server-port");
+const PROJECT_ROOT = resolve(import.meta.dir, "..");
+const PROJECT_NAME = basename(PROJECT_ROOT);
+
+function cleanupPortFile() {
+  try { if (existsSync(PORT_FILE)) unlinkSync(PORT_FILE); } catch {}
+  unregisterPort(PROJECT_ROOT);
+}
+
+function writePortFile(port: number) {
+  writeFileSync(PORT_FILE, String(port), "utf-8");
+}
+
+process.on("exit", cleanupPortFile);
+process.on("SIGINT", () => { cleanupPortFile(); process.exit(0); });
+process.on("SIGTERM", () => { cleanupPortFile(); process.exit(0); });
+
+const httpServer = createServer();
+const wss = createWsHandler(httpServer, { config });
+
+httpServer.on("request", createHttpHandler({
+  config,
+  getWebSocketClientCount: () => wss.clients.size,
+}));
+
+function checkPort(port: number): Promise<number> {
+  return new Promise((resolve, reject) => {
+    const testServer = createServer();
+    testServer.once("error", (err: NodeJS.ErrnoException) => {
+      testServer.close();
+      reject(err);
+    });
+    testServer.once("listening", () => {
+      testServer.close();
+      resolve(port);
+    });
+    testServer.listen(port);
+  });
+}
+
+async function findAvailablePort(startPort: number, maxRetries: number = 10): Promise<number> {
+  for (let port = startPort; port < startPort + maxRetries; port++) {
+    try {
+      await checkPort(port);
+      return port;
+    } catch {
+      log.info(`Port ${port} in use, trying ${port + 1}...`);
+    }
+  }
+  throw new Error(`No available port found after ${maxRetries} retries`);
+}
+
+async function start() {
+  const port = await findAvailablePort(config.port);
+  httpServer.listen(port, () => {
+    writePortFile(port);
+    registerPort(PROJECT_ROOT, port, PROJECT_NAME);
+    log.info(`HTTP + WebSocket server running on http://localhost:${port}`);
+    log.info(`WebSocket: ws://localhost:${port}/ws (auth required)`);
+    log.info(`Available RPC methods: ${discoverMethodNames().join(", ")}`);
+    log.info("File endpoints: GET /file/{path}, GET /info/{path}");
+    // eslint-disable-next-line no-console
+    console.log("\n" + formatRegistryForOutput() + "\n");
+  });
+}
+
+start().catch((err) => {
+  log.error("Server failed to start", { error: err.message });
+  process.exit(1);
+});

package/templates/agent/src/shared/handlers/__tests__/bash-handler.test.ts

@@ -0,0 +1,135 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import type { RPCServer } from "@dyyz1993/rpc-core";
+
+vi.stubGlobal("Bun", {
+  spawn: vi.fn(),
+});
+
+vi.mock("../../lib/logger", () => ({
+  createLogger: () => ({
+    info: vi.fn(),
+    error: vi.fn(),
+    warn: vi.fn(),
+    debug: vi.fn(),
+  }),
+}));
+
+describe("Bash Handler", () => {
+  let registeredHandlers: Record<string, Function>;
+  let mockServer: {
+    register: ReturnType<typeof vi.fn>;
+    emitEvent: ReturnType<typeof vi.fn>;
+  };
+
+  function createMockSubprocess(overrides: { stdout?: string; stderr?: string; exitCode?: number; pid?: number } = {}) {
+    return {
+      pid: overrides.pid ?? 1234,
+      stdout: { text: () => Promise.resolve(overrides.stdout ?? "") },
+      stderr: { text: () => Promise.resolve(overrides.stderr ?? "") },
+      exited: Promise.resolve(overrides.exitCode ?? 0),
+    };
+  }
+
+  beforeEach(async () => {
+    vi.resetModules();
+    registeredHandlers = {};
+    mockServer = {
+      register: vi.fn((method: string, handler: Function) => {
+        registeredHandlers[method] = handler;
+      }),
+      emitEvent: vi.fn(),
+    };
+
+    (Bun.spawn as ReturnType<typeof vi.fn>).mockReturnValue(createMockSubprocess());
+
+    vi.stubGlobal("Response", class {
+      private src: any;
+      constructor(src: any) { this.src = src; }
+      async text() {
+        if (this.src && typeof this.src.text === "function") return this.src.text();
+        return String(this.src);
+      }
+    });
+
+    const { register } = await import("../bash");
+    register(mockServer as unknown as RPCServer, { platform: "web" });
+  });
+
+  it("should register bash.execute, bash.kill, bash.listProcesses", () => {
+    expect(registeredHandlers["bash.execute"]).toBeDefined();
+    expect(registeredHandlers["bash.kill"]).toBeDefined();
+    expect(registeredHandlers["bash.listProcesses"]).toBeDefined();
+  });
+
+  it("bash.execute should run command and return output", async () => {
+    (Bun.spawn as ReturnType<typeof vi.fn>).mockReturnValue(
+      createMockSubprocess({ stdout: "hello output" }),
+    );
+
+    const result = await registeredHandlers["bash.execute"]({ command: "echo hello" });
+    expect(result).toHaveProperty("pid");
+    expect(result.output).toContain("hello output");
+    expect(Bun.spawn).toHaveBeenCalledWith(
+      ["echo", "hello"],
+      expect.objectContaining({ stdout: "pipe", stderr: "pipe" }),
+    );
+  });
+
+  it("bash.execute should include stderr in output", async () => {
+    (Bun.spawn as ReturnType<typeof vi.fn>).mockReturnValue(
+      createMockSubprocess({ stdout: "", stderr: "error msg", exitCode: 1 }),
+    );
+
+    const result = await registeredHandlers["bash.execute"]({ command: "ls /nonexistent" });
+    expect(result.output).toContain("error msg");
+    expect(result.output).toContain("[stderr]");
+    expect(mockServer.emitEvent).toHaveBeenCalledWith(
+      "bash.exit",
+      expect.objectContaining({ code: 1 }),
+      {},
+    );
+  });
+
+  it("bash.execute should handle spawn failure gracefully", async () => {
+    (Bun.spawn as ReturnType<typeof vi.fn>).mockImplementation(() => {
+      throw new Error("spawn failed");
+    });
+
+    const result = await registeredHandlers["bash.execute"]({ command: "bad-command" });
+    expect(result.output).toContain("Error: spawn failed");
+    expect(mockServer.emitEvent).toHaveBeenCalledWith(
+      "bash.exit",
+      expect.objectContaining({ code: 1 }),
+      {},
+    );
+  });
+
+  it("bash.listProcesses should return tracked processes", async () => {
+    (Bun.spawn as ReturnType<typeof vi.fn>).mockReturnValue(
+      createMockSubprocess({ stdout: "test" }),
+    );
+
+    await registeredHandlers["bash.execute"]({ command: "echo test" });
+    const result = await registeredHandlers["bash.listProcesses"]();
+    expect(result.processes).toBeInstanceOf(Array);
+    expect(result.processes.length).toBeGreaterThanOrEqual(1);
+    expect(result.processes[0]).toHaveProperty("command");
+    expect(result.processes[0]).toHaveProperty("pid");
+  });
+
+  it("bash.kill should succeed for tracked process using returned pid", async () => {
+    (Bun.spawn as ReturnType<typeof vi.fn>).mockReturnValue(
+      createMockSubprocess({ stdout: "ok", pid: 9999 }),
+    );
+
+    const execResult = await registeredHandlers["bash.execute"]({ command: "echo hi" });
+
+    const killResult = await registeredHandlers["bash.kill"]({ pid: execResult.pid });
+    expect(killResult).toEqual({ success: true });
+  });
+
+  it("bash.kill should fail for unknown pid", async () => {
+    const result = await registeredHandlers["bash.kill"]({ pid: 99999 });
+    expect(result).toEqual({ success: false });
+  });
+});

package/templates/agent/src/shared/handlers/__tests__/chat-handler.test.ts

@@ -0,0 +1,77 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+vi.mock("../../lib/logger", () => ({
+  createLogger: () => ({
+    info: vi.fn(),
+    error: vi.fn(),
+    warn: vi.fn(),
+    debug: vi.fn(),
+  }),
+}));
+
+describe("Chat Handler", () => {
+  beforeEach(() => {
+    vi.resetModules();
+  });
+
+  describe("generateReply logic", () => {
+    it("should handle greeting patterns", () => {
+      const greetingPattern = /^(hi|hello|hey|howdy|hola|yo|sup)\b/i;
+      expect(greetingPattern.test("hello")).toBe(true);
+      expect(greetingPattern.test("hi there")).toBe(true);
+      expect(greetingPattern.test("what is this")).toBe(false);
+    });
+
+    it("should match time/date queries", () => {
+      const timePattern = /what('?s| is) the (time|date|day)|current (time|date)|what time|today'?s date/i;
+      expect(timePattern.test("what's the time")).toBe(true);
+      expect(timePattern.test("what is the date")).toBe(true);
+      expect(timePattern.test("current time")).toBe(true);
+      expect(timePattern.test("hello world")).toBe(false);
+    });
+
+    it("should match math expressions", () => {
+      const mathPattern = /(?:what(?:'s| is)\s+)?(\d+(?:\.\d+)?)\s*([+\-*/x×÷^])\s*(\d+(?:\.\d+)?)/;
+      expect(mathPattern.test("12 * 8")).toBe(true);
+      expect(mathPattern.test("what is 100 / 4")).toBe(true);
+      expect(mathPattern.test("3 + 5")).toBe(true);
+      expect(mathPattern.test("hello")).toBe(false);
+    });
+
+    it("should compute math correctly", () => {
+      const compute = (a: number, op: string, b: number): number => {
+        switch (op) {
+          case "+": return a + b;
+          case "-": return a - b;
+          case "*": return a * b;
+          case "/": return b !== 0 ? a / b : NaN;
+          default: return NaN;
+        }
+      };
+
+      expect(compute(3, "+", 5)).toBe(8);
+      expect(compute(10, "-", 4)).toBe(6);
+      expect(compute(6, "*", 7)).toBe(42);
+      expect(compute(20, "/", 4)).toBe(5);
+      expect(compute(1, "/", 0)).toBeNaN();
+    });
+  });
+
+  describe("register", () => {
+    it("should register chat.list and chat.send methods", async () => {
+      const registeredMethods: string[] = [];
+      const mockServer = {
+        register: vi.fn((method: string) => {
+          registeredMethods.push(method);
+        }),
+        emitEvent: vi.fn(),
+      };
+
+      const { register } = await import("../chat");
+      register(mockServer as any, { platform: "web" });
+
+      expect(registeredMethods).toContain("chat.list");
+      expect(registeredMethods).toContain("chat.send");
+    });
+  });
+});