@dyyz1993/create-agent 1.9.0

package/templates/general/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/general/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/general/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/general/src/server-config.ts

@@ -0,0 +1,42 @@
+/**
+ * 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",
+  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/general/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/general/src/shared/handlers/__tests__/chat.test.ts

@@ -0,0 +1,183 @@
+import { describe, test, expect, beforeEach } from "vitest";
+import type { RPCServer } from "@dyyz1993/rpc-core";
+import { register } from "../chat";
+import { writeFile, mkdir } from "fs/promises";
+import { existsSync } from "fs";
+import { join, dirname } from "path";
+import { homedir } from "os";
+
+type Handler = (params: unknown) => Promise<unknown>;
+type EmittedEvent = { event: string; payload: unknown; filter: unknown };
+
+const STORAGE_PATH = join(homedir(), ".pi-agent", "chat-history.json");
+
+function createMockServer() {
+  const handlers = new Map<string, Handler>();
+  const events: EmittedEvent[] = [];
+  return {
+    register: (method: string, handler: Handler) => {
+      handlers.set(method, handler);
+    },
+    emitEvent: (event: string, payload: unknown, filter?: unknown) => {
+      events.push({ event, payload, filter });
+    },
+    get: (method: string) => handlers.get(method),
+    has: (method: string) => handlers.has(method),
+    getEvents: () => events,
+    clearEvents: () => { events.length = 0; },
+  };
+}
+
+async function clearHistory(): Promise<void> {
+  try {
+    if (existsSync(STORAGE_PATH)) {
+      const { unlink } = await import("fs/promises");
+      await unlink(STORAGE_PATH);
+    }
+  } catch {}
+}
+
+async function writeHistory(messages: Record<string, unknown>[]): Promise<void> {
+  const dir = dirname(STORAGE_PATH);
+  if (!existsSync(dir)) {
+    await mkdir(dir, { recursive: true });
+  }
+  await writeFile(STORAGE_PATH, JSON.stringify(messages, null, 2), "utf-8");
+}
+
+describe("chat handler", () => {
+  let server: ReturnType<typeof createMockServer>;
+
+  beforeEach(async () => {
+    server = createMockServer();
+    register(server as unknown as RPCServer, { platform: "desktop" });
+    await clearHistory();
+  });
+
+  test("registers chat.list", () => {
+    expect(server.has("chat.list")).toBe(true);
+  });
+
+  test("registers chat.send", () => {
+    expect(server.has("chat.send")).toBe(true);
+  });
+
+  test("chat.list returns empty when no history", async () => {
+    const result = await server.get("chat.list")!({}) as Record<string, unknown>;
+    expect(result.messages).toEqual([]);
+    expect(result.hasMore).toBe(false);
+  });
+
+  test("chat.list with existing history returns messages", async () => {
+    const msgs = [
+      { id: "1", role: "user", content: "hi", timestamp: 1000 },
+      { id: "2", role: "assistant", content: "hello", timestamp: 2000 },
+    ];
+    await writeHistory(msgs);
+
+    const result = await server.get("chat.list")!({}) as Record<string, unknown>;
+    const messages = result.messages as Record<string, unknown>[];
+    expect(messages.length).toBe(2);
+    expect(result.hasMore).toBe(false);
+  });
+
+  test("chat.list respects limit param", async () => {
+    const msgs = Array.from({ length: 100 }, (_, i) => ({
+      id: `msg-${i}`,
+      role: i % 2 === 0 ? "user" as const : "assistant" as const,
+      content: `message ${i}`,
+      timestamp: i * 1000,
+    }));
+    await writeHistory(msgs);
+
+    const result = await server.get("chat.list")!({ limit: 10 }) as Record<string, unknown>;
+    const messages = result.messages as Record<string, unknown>[];
+    expect(messages.length).toBe(10);
+    expect(result.hasMore).toBe(true);
+    expect(messages[0].id).toBe("msg-90");
+  });
+
+  test("chat.list default limit is 50", async () => {
+    const msgs = Array.from({ length: 60 }, (_, i) => ({
+      id: `msg-${i}`,
+      role: "user" as const,
+      content: `message ${i}`,
+      timestamp: i * 1000,
+    }));
+    await writeHistory(msgs);
+
+    const result = await server.get("chat.list")!({}) as Record<string, unknown>;
+    const messages = result.messages as Record<string, unknown>[];
+    expect(messages.length).toBe(50);
+    expect(result.hasMore).toBe(true);
+  });
+
+  test("chat.send returns { ok: true }", async () => {
+    const result = await server.get("chat.send")!({ content: "hello" }) as Record<string, unknown>;
+    expect(result.ok).toBe(true);
+  });
+
+  test("chat.send emits chat.message events for user and assistant", async () => {
+    await server.get("chat.send")!({ content: "hi" });
+
+    const events = server.getEvents().filter((e) => e.event === "chat.message");
+    expect(events.length).toBe(2);
+
+    const userEvent = events[0].payload as Record<string, unknown>;
+    expect(userEvent.role).toBe("user");
+    expect(userEvent.content).toBe("hi");
+
+    const assistantEvent = events[1].payload as Record<string, unknown>;
+    expect(assistantEvent.role).toBe("assistant");
+    expect(assistantEvent.content).toBeTruthy();
+  });
+
+  test("chat.send stores messages in history", async () => {
+    await server.get("chat.send")!({ content: "hello world" });
+
+    const result = await server.get("chat.list")!({}) as Record<string, unknown>;
+    const messages = result.messages as Record<string, unknown>[];
+    expect(messages.length).toBe(2);
+    expect(messages[0].role).toBe("user");
+    expect(messages[0].content).toBe("hello world");
+    expect(messages[1].role).toBe("assistant");
+  });
+
+  test("chat.send message has correct shape", async () => {
+    await server.get("chat.send")!({ content: "test" });
+
+    const events = server.getEvents().filter((e) => e.event === "chat.message");
+    const userMsg = events[0].payload as Record<string, unknown>;
+    expect(userMsg).toHaveProperty("id");
+    expect(userMsg).toHaveProperty("role");
+    expect(userMsg).toHaveProperty("content");
+    expect(userMsg).toHaveProperty("timestamp");
+    expect(typeof userMsg.id).toBe("string");
+    expect(typeof userMsg.timestamp).toBe("number");
+  });
+
+  test("chat.message events include role filter", async () => {
+    await server.get("chat.send")!({ content: "yo" });
+
+    const events = server.getEvents().filter((e) => e.event === "chat.message");
+    expect(events[0].filter).toEqual({ role: "user" });
+    expect(events[1].filter).toEqual({ role: "assistant" });
+  });
+
+  test("chat.send with greeting gets greeting reply", async () => {
+    await server.get("chat.send")!({ content: "hello" });
+
+    const events = server.getEvents().filter((e) => e.event === "chat.message");
+    const reply = events[1].payload as Record<string, unknown>;
+    expect(reply.content).toBeTruthy();
+    expect(reply.role).toBe("assistant");
+  });
+
+  test("chat.send with math expression gets calculation reply", async () => {
+    await server.get("chat.send")!({ content: "12 * 8" });
+
+    const events = server.getEvents().filter((e) => e.event === "chat.message");
+    const reply = events[1].payload as Record<string, unknown>;
+    expect(reply.content).toContain("96");
+  });
+});

package/templates/general/src/shared/handlers/__tests__/system.test.ts

@@ -0,0 +1,94 @@
+import { describe, test, expect } from "vitest";
+import type { RPCServer } from "@dyyz1993/rpc-core";
+import { register } from "../system";
+
+type Handler = (params: unknown) => Promise<unknown>;
+
+function createMockServer() {
+  const handlers = new Map<string, Handler>();
+  return {
+    register: (method: string, handler: Handler) => {
+      handlers.set(method, handler);
+    },
+    emitEvent: () => {},
+    get: (method: string) => handlers.get(method),
+    has: (method: string) => handlers.has(method),
+  };
+}
+
+describe("system handler", () => {
+  const server = createMockServer();
+  register(server as unknown as RPCServer, { platform: "desktop" });
+
+  test("registers system.ping", () => {
+    expect(server.has("system.ping")).toBe(true);
+  });
+
+  test("registers system.hello", () => {
+    expect(server.has("system.hello")).toBe(true);
+  });
+
+  test("registers system.echo", () => {
+    expect(server.has("system.echo")).toBe(true);
+  });
+
+  test("system.ping returns pong with timestamp and platform", async () => {
+    const before = Date.now();
+    const result = await server.get("system.ping")!({}) as Record<string, unknown>;
+    const after = Date.now();
+
+    expect(result.pong).toBe(true);
+    expect(result.platform).toBe("desktop");
+    expect(result.timestamp).toBeGreaterThanOrEqual(before);
+    expect(result.timestamp).toBeLessThanOrEqual(after);
+  });
+
+  test("system.ping respects platform option", async () => {
+    const webServer = createMockServer();
+    register(webServer as unknown as RPCServer, { platform: "web" });
+    const result = await webServer.get("system.ping")!({}) as Record<string, unknown>;
+    expect(result.platform).toBe("web");
+  });
+
+  test("system.hello with name returns personalized greeting", async () => {
+    const result = await server.get("system.hello")!({ name: "Alice" }) as Record<string, unknown>;
+    expect(result.message).toBe("Hello Alice!");
+    expect(result.timestamp).toBeDefined();
+  });
+
+  test("system.hello without name defaults to World", async () => {
+    const result = await server.get("system.hello")!({}) as Record<string, unknown>;
+    expect(result.message).toBe("Hello World!");
+  });
+
+  test("system.hello with undefined name defaults to World", async () => {
+    const result = await server.get("system.hello")!({ name: undefined }) as Record<string, unknown>;
+    expect(result.message).toBe("Hello World!");
+  });
+
+  test("system.hello with empty string name defaults to World", async () => {
+    const result = await server.get("system.hello")!({ name: "" }) as Record<string, unknown>;
+    expect(result.message).toBe("Hello World!");
+  });
+
+  test("system.echo returns the input as-is", async () => {
+    const data = { foo: "bar", num: 42, nested: { a: [1, 2, 3] } };
+    const result = await server.get("system.echo")!(data);
+    expect(result).toEqual(data);
+  });
+
+  test("system.echo with null returns null", async () => {
+    const result = await server.get("system.echo")!(null);
+    expect(result).toBeNull();
+  });
+
+  test("system.echo with primitive returns primitive", async () => {
+    const result = await server.get("system.echo")!(42);
+    expect(result).toBe(42);
+  });
+
+  test("system.echo with empty object returns empty object", async () => {
+    const result = await server.get("system.echo")!({});
+    expect(result).toEqual({});
+  });
+});