@dyyz1993/create-agent 2.0.0 → 2.1.0

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

@@ -1,150 +1,149 @@
 import { apiClient } from "../lib/api-client";
 
 export interface DropEntry {
-  name: string;
-  relativePath: string;
-  file?: File;
-  isDirectory: boolean;
-  children?: 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[] = [];
+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();
-  });
+		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 items = dataTransfer.items;
+	if (!items) return [];
 
-  const entries: DropEntry[] = [];
-  const tasks: Promise<void>[] = [];
+	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); }),
-      );
-    }
-  }
+	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;
+	await Promise.all(tasks);
+	return entries;
 }
 
 /**
  * Web 端：递归上传 entries 到目标目录
  */
 export async function uploadEntriesWeb(entries: DropEntry[], destDir: string): Promise<number> {
-  let count = 0;
+	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++;
-    }
-  }
+	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;
+	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;
+	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++;
-    }
-  }
+	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;
+	for (const entry of entries) {
+		await process(entry, destDir);
+	}
+	return count;
 }

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

@@ -3,41 +3,43 @@
  * Values are read from environment variables with sensible defaults.
  */
 
+import { randomUUID } from "crypto";
+
+if (process.env.NODE_ENV === "production" && !process.env.AUTH_TOKEN) {
+	throw new Error(
+		"[FATAL] AUTH_TOKEN environment variable must be set in production mode. " +
+			"Example: AUTH_TOKEN=$(openssl rand -hex 32) bun src/server.ts"
+	);
+}
+
 export function parseEnvInt(
-  key: string,
-  value: string | undefined,
-  defaultValue: number,
-  min: number,
-  max: number,
+	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;
+	if (value === undefined || value === "") return defaultValue;
+	const parsed = parseInt(value, 10);
+	if (isNaN(parsed) || parsed < min || parsed > max) {
+		process.stderr.write(`[config] Invalid ${key}: "${value}", using default: ${defaultValue}\n`);
+		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",
+	port: parseEnvInt("PORT", process.env.PORT, 3100, 1024, 65535),
+	authToken: process.env.AUTH_TOKEN || `dev-${randomUUID()}`,
+	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",
+	enableWebService: process.env.ENABLE_WEB_SERVICE === "true",
+	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

@@ -4,12 +4,10 @@
  * 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 { createWebServer, getLocalIP } from "./shared/lib/web-server";
 import { createLogger, configureLogDir } from "./shared/lib/logger";
 import { registerPort, unregisterPort, formatRegistryForOutput } from "./shared/lib/port-registry";
 import { discoverMethodNames } from "./shared/register-all-handlers";
@@ -22,68 +20,58 @@ 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);
+	try {
+		if (existsSync(PORT_FILE)) unlinkSync(PORT_FILE);
+	} catch {}
+	unregisterPort(PROJECT_ROOT);
 }
 
 function writePortFile(port: number) {
-  writeFileSync(PORT_FILE, String(port), "utf-8");
+	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); });
+process.on("SIGINT", () => {
+	cleanupPortFile();
+	process.exit(0);
+});
+process.on("SIGTERM", () => {
+	cleanupPortFile();
+	process.exit(0);
+});
 
-const httpServer = createServer();
-const wss = createWsHandler(httpServer, { config });
+async function start() {
+	const { port, close } = await createWebServer({
+		port: config.port,
+		authToken: config.authToken,
+		maxUploadSize: config.maxUploadSize,
+		corsOrigin: config.corsOrigin,
+	});
 
-httpServer.on("request", createHttpHandler({
-  config,
-  getWebSocketClientCount: () => wss.clients.size,
-}));
+	process.on("SIGINT", () => {
+		close();
+		cleanupPortFile();
+		process.exit(0);
+	});
+	process.on("SIGTERM", () => {
+		close();
+		cleanupPortFile();
+		process.exit(0);
+	});
 
-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);
-  });
-}
+	writePortFile(port);
+	registerPort(PROJECT_ROOT, port, PROJECT_NAME);
 
-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");
-  });
+	const localIp = getLocalIP();
+	log.info(`HTTP + WebSocket server running on http://localhost:${port}`);
+	log.info(`Local network access: http://${localIp}:${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}");
+	log.info(formatRegistryForOutput());
 }
 
 start().catch((err) => {
-  log.error("Server failed to start", { error: err.message });
-  process.exit(1);
+	log.error("Server failed to start", { error: err.message });
+	process.exit(1);
 });

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

@@ -0,0 +1,127 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { join } from "path";
+import { homedir } from "os";
+import { unlink } from "fs/promises";
+import { existsSync } from "fs";
+
+vi.mock("../../lib/logger", () => ({
+	createLogger: () => ({
+		info: vi.fn(),
+		error: vi.fn(),
+		warn: vi.fn(),
+		debug: vi.fn(),
+	}),
+}));
+
+function createMockServer() {
+	const handlers = new Map<string, (params: unknown) => Promise<unknown>>();
+	return {
+		register: vi.fn((method: string, handler: (params: unknown) => Promise<unknown>) => {
+			handlers.set(method, handler);
+		}),
+		emitEvent: vi.fn(),
+		handlers,
+		async call(method: string, params: unknown) {
+			const h = handlers.get(method);
+			if (!h) throw new Error(`No handler for ${method}`);
+			return h(params);
+		},
+	};
+}
+
+const DESKTOP_HISTORY_PATH = join(homedir(), ".pi-agent", "chat-history-desktop.json");
+
+describe("Chat Handler 并发安全", () => {
+	beforeEach(() => {
+		vi.resetModules();
+	});
+
+	afterEach(async () => {
+		if (existsSync(DESKTOP_HISTORY_PATH)) {
+			await unlink(DESKTOP_HISTORY_PATH).catch(() => {});
+		}
+	});
+
+	it("两个独立的 RPCServer 应注册各自的 handler", async () => {
+		const { register } = await import("../chat");
+		const serverA = createMockServer();
+		const serverB = createMockServer();
+
+		register(serverA as any, { platform: "desktop" });
+		register(serverB as any, { platform: "web" });
+
+		expect(serverA.register).toHaveBeenCalledWith("chat.list", expect.any(Function));
+		expect(serverA.register).toHaveBeenCalledWith("chat.send", expect.any(Function));
+		expect(serverB.register).toHaveBeenCalledWith("chat.list", expect.any(Function));
+		expect(serverB.register).toHaveBeenCalledWith("chat.send", expect.any(Function));
+	});
+
+	it("server A 的消息不影响 server B 的消息列表", async () => {
+		const { register } = await import("../chat");
+		const serverA = createMockServer();
+		const serverB = createMockServer();
+
+		register(serverA as any, { platform: "desktop" });
+		register(serverB as any, { platform: "web" });
+
+		await serverA.call("chat.send", { content: "hello from desktop" });
+		await serverB.call("chat.send", { content: "hello from web" });
+
+		const resultA = (await serverA.call("chat.list", { limit: 50 })) as {
+			messages: { content: string }[];
+		};
+		const resultB = (await serverB.call("chat.list", { limit: 50 })) as {
+			messages: { content: string }[];
+		};
+
+		const desktopContents = resultA.messages.map((m) => m.content);
+		const webContents = resultB.messages.map((m) => m.content);
+
+		expect(desktopContents).toContain("hello from desktop");
+		expect(webContents).toContain("hello from web");
+		expect(desktopContents).not.toContain("hello from web");
+		expect(webContents).not.toContain("hello from desktop");
+	});
+
+	it("同一 server 内的消息按顺序写入", async () => {
+		const { register } = await import("../chat");
+		const server = createMockServer();
+		register(server as any, { platform: "desktop" });
+
+		await server.call("chat.send", { content: "msg1" });
+		await server.call("chat.send", { content: "msg2" });
+		await server.call("chat.send", { content: "msg3" });
+
+		const result = (await server.call("chat.list", { limit: 50 })) as {
+			messages: { role: string; content: string }[];
+		};
+
+		const userMsgs = result.messages.filter((m) => m.role === "user").map((m) => m.content);
+		expect(userMsgs).toEqual(["msg1", "msg2", "msg3"]);
+	});
+
+	it("存储路径应包含平台标识（desktop/web）或唯一 ID", async () => {
+		const { getStoragePathFor } = await import("../chat");
+		const desktopPath = getStoragePathFor("desktop");
+		const webPath = getStoragePathFor("web");
+
+		expect(desktopPath).toContain("desktop");
+		expect(webPath).not.toBe(desktopPath);
+		expect(webPath).toMatch(/web/);
+	});
+
+	it("desktop 使用固定路径保留历史", async () => {
+		const { getStoragePathFor } = await import("../chat");
+		const path1 = getStoragePathFor("desktop");
+		const path2 = getStoragePathFor("desktop");
+		expect(path1).toBe(path2);
+		expect(path1).toContain("chat-history-desktop.json");
+	});
+
+	it("web 每次生成不同的路径", async () => {
+		const { getStoragePathFor } = await import("../chat");
+		const path1 = getStoragePathFor("web");
+		const path2 = getStoragePathFor("web");
+		expect(path1).not.toBe(path2);
+	});
+});