@dyyz1993/create-agent 2.0.0 → 2.0.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);
+	});
+});

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

@@ -0,0 +1,244 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import type { RPCServer } from "@dyyz1993/rpc-core";
+
+vi.mock("../../lib/logger", () => ({
+	createLogger: () => ({
+		info: vi.fn(),
+		error: vi.fn(),
+		warn: vi.fn(),
+		debug: vi.fn(),
+	}),
+}));
+
+function createMockServer() {
+	const handlers: Record<string, Function> = {};
+	return {
+		handlers,
+		server: {
+			register: vi.fn((method: string, handler: Function) => {
+				handlers[method] = handler;
+			}),
+			emitEvent: vi.fn(),
+		} as unknown as RPCServer,
+	};
+}
+
+// --- Timer ---
+describe("Handler 隔离性 - timer", () => {
+	beforeEach(() => {
+		vi.useFakeTimers();
+		vi.resetModules();
+	});
+
+	afterEach(() => {
+		vi.useRealTimers();
+	});
+
+	it("两个独立的 RPCServer 各自维护独立的定时器状态", async () => {
+		const a = createMockServer();
+		const b = createMockServer();
+
+		const { register } = await import("../timer");
+		register(a.server, { platform: "web" });
+		register(b.server, { platform: "web" });
+
+		const resultA = await a.handlers["timer.start"]({});
+		expect(resultA).toEqual({ started: true });
+
+		const resultB = await b.handlers["timer.start"]({});
+		expect(resultB).toEqual({ started: true });
+
+		await a.handlers["timer.stop"]({});
+		const resultB2 = await b.handlers["timer.start"]({});
+		expect(resultB2).toEqual({ alreadyRunning: true });
+	});
+
+	it("server A 停止定时器不影响 server B 的定时器", async () => {
+		const a = createMockServer();
+		const b = createMockServer();
+
+		const { register } = await import("../timer");
+		register(a.server, { platform: "web" });
+		register(b.server, { platform: "web" });
+
+		await a.handlers["timer.start"]({});
+		await b.handlers["timer.start"]({});
+
+		await a.handlers["timer.stop"]({});
+
+		vi.advanceTimersByTime(2000);
+		expect(b.server.emitEvent).toHaveBeenCalled();
+	});
+});
+
+// --- Bash ---
+describe("Handler 隔离性 - bash", () => {
+	beforeEach(() => {
+		vi.resetModules();
+		vi.stubGlobal("Bun", { spawn: vi.fn() });
+		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);
+				}
+			}
+		);
+	});
+
+	it("两个独立的 RPCServer 各自维护独立的进程列表", async () => {
+		const a = createMockServer();
+		const b = createMockServer();
+
+		const { register } = await import("../bash");
+		register(a.server, { platform: "web" });
+		register(b.server, { platform: "web" });
+
+		const mockSub = {
+			pid: 100,
+			stdout: { text: () => Promise.resolve("ok") },
+			stderr: { text: () => Promise.resolve("") },
+			exited: Promise.resolve(0),
+		};
+		(Bun.spawn as ReturnType<typeof vi.fn>).mockReturnValue(mockSub);
+
+		const resultA = await a.handlers["bash.execute"]({ command: "echo A" });
+		const resultB = await b.handlers["bash.execute"]({ command: "echo B" });
+
+		expect(resultA.pid).toBe(1);
+		expect(resultB.pid).toBe(1);
+	});
+
+	it("server A 的 pidCounter 不影响 server B", async () => {
+		const a = createMockServer();
+		const b = createMockServer();
+
+		const { register } = await import("../bash");
+		register(a.server, { platform: "web" });
+		register(b.server, { platform: "web" });
+
+		const mockSub = {
+			pid: 100,
+			stdout: { text: () => Promise.resolve("ok") },
+			stderr: { text: () => Promise.resolve("") },
+			exited: Promise.resolve(0),
+		};
+		(Bun.spawn as ReturnType<typeof vi.fn>).mockReturnValue(mockSub);
+
+		await a.handlers["bash.execute"]({ command: "ls" });
+		await a.handlers["bash.execute"]({ command: "ls" });
+		await a.handlers["bash.execute"]({ command: "ls" });
+
+		const resultB = await b.handlers["bash.execute"]({ command: "ls" });
+		expect(resultB.pid).toBe(1);
+	});
+});
+
+// --- Feed ---
+describe("Handler 隔离性 - feed", () => {
+	beforeEach(() => {
+		vi.resetModules();
+	});
+
+	it("两个独立的 RPCServer 各自维护独立的帖子列表", async () => {
+		const a = createMockServer();
+		const b = createMockServer();
+
+		const { register } = await import("../feed");
+		register(a.server, { platform: "web" });
+		register(b.server, { platform: "web" });
+
+		await a.handlers["feed.post"]({ content: "post from A", category: "tech" });
+
+		const listB = await b.handlers["feed.list"]({});
+		expect(listB.posts).toHaveLength(0);
+
+		const listA = await a.handlers["feed.list"]({});
+		expect(listA.posts).toHaveLength(1);
+		expect(listA.posts[0].content).toBe("post from A");
+	});
+});
+
+// --- Todo ---
+describe("Handler 隔离性 - todo", () => {
+	beforeEach(() => {
+		vi.resetModules();
+	});
+
+	it("两个独立的 RPCServer 各自维护独立的 todo 列表", async () => {
+		const a = createMockServer();
+		const b = createMockServer();
+
+		const { register } = await import("../todo");
+		register(a.server, { platform: "web" });
+		register(b.server, { platform: "web" });
+
+		await a.handlers["todo.add"]({ content: "task from A" });
+
+		const listB = await b.handlers["todo.list"]({});
+		expect(listB.items).toHaveLength(0);
+
+		const listA = await a.handlers["todo.list"]({});
+		expect(listA.items).toHaveLength(1);
+	});
+
+	it("server A 的 todoIdCounter 不影响 server B", async () => {
+		const a = createMockServer();
+		const b = createMockServer();
+
+		const { register } = await import("../todo");
+		register(a.server, { platform: "web" });
+		register(b.server, { platform: "web" });
+
+		await a.handlers["todo.add"]({ content: "A1" });
+		await a.handlers["todo.add"]({ content: "A2" });
+		await a.handlers["todo.add"]({ content: "A3" });
+
+		const resultB = await b.handlers["todo.add"]({ content: "B1" });
+		expect(resultB.item.id).toBe("todo-1");
+	});
+});
+
+// --- Rules ---
+describe("Handler 隔离性 - rules", () => {
+	beforeEach(() => {
+		vi.resetModules();
+	});
+
+	it("两个独立的 RPCServer 各自维护独立的规则列表", async () => {
+		const a = createMockServer();
+		const b = createMockServer();
+
+		const { register } = await import("../rules");
+		register(a.server, { platform: "web" });
+		register(b.server, { platform: "web" });
+
+		await a.handlers["rules.add"]({ name: "rule A", pattern: "*.ts" });
+
+		const listB = await b.handlers["rules.list"]({});
+		expect(listB.rules).toHaveLength(0);
+
+		const listA = await a.handlers["rules.list"]({});
+		expect(listA.rules).toHaveLength(1);
+	});
+
+	it("server A 的 ruleIdCounter 不影响 server B", async () => {
+		const a = createMockServer();
+		const b = createMockServer();
+
+		const { register } = await import("../rules");
+		register(a.server, { platform: "web" });
+		register(b.server, { platform: "web" });
+
+		await a.handlers["rules.add"]({ name: "A1", pattern: "*.ts" });
+		await a.handlers["rules.add"]({ name: "A2", pattern: "*.js" });
+
+		const resultB = await b.handlers["rules.add"]({ name: "B1", pattern: "*.css" });
+		expect(resultB.rule.id).toBe("rule-1");
+	});
+});

package/templates/agent/src/shared/handlers/bash.ts

@@ -4,86 +4,86 @@ import type { RPCMethods, HandlerOptions } from "../rpc-schema";
 import { validateCommand, setCommandPolicy } from "../lib/bash-security";
 
 type RegisterFn = <K extends keyof RPCMethods & string>(
-  method: K,
-  handler: (params: MethodParams<RPCMethods, K>) => Promise<MethodResult<RPCMethods, K>>,
+	method: K,
+	handler: (params: MethodParams<RPCMethods, K>) => Promise<MethodResult<RPCMethods, K>>
 ) => void;
 
 interface TrackedProcess {
-  pid: number;
-  command: string;
-  running: boolean;
+	pid: number;
+	command: string;
+	running: boolean;
 }
 
-const processes = new Map<number, TrackedProcess>();
-let pidCounter = 1;
-
 export function register(server: RPCServer, _options: HandlerOptions): void {
-  setCommandPolicy({
-    enabled: _options.enableBash !== false,
-    blockedPatterns: [
-      /rm\s+-rf\s+(.*\s)?\/($|\s)/,
-      /rm\s+-rf\s+--no-preserve-root/,
-      /mkfs/,
-      /dd\s+if=/,
-      />\s*\/dev\//,
-      /:()\s*\{.*\|.*&\s*\}/,
-      /shutdown/,
-      /reboot/,
-    ],
-    allowedCommands: null,
-  });
+	const processes = new Map<number, TrackedProcess>();
+	let pidCounter = 1;
+
+	setCommandPolicy({
+		enabled: _options.enableBash !== false,
+		blockedPatterns: [
+			/rm\s+-rf\s+(.*\s)?\/($|\s)/,
+			/rm\s+-rf\s+--no-preserve-root/,
+			/mkfs/,
+			/dd\s+if=/,
+			/>\s*\/dev\//,
+			/:()\s*\{.*\|.*&\s*\}/,
+			/shutdown/,
+			/reboot/,
+		],
+		allowedCommands: null,
+	});
 
-  const r: RegisterFn = (method, handler) => {
-    server.register(method, handler as (params: unknown) => Promise<unknown>);
-  };
+	const r: RegisterFn = (method, handler) => {
+		server.register(method, handler as (params: unknown) => Promise<unknown>);
+	};
 
-  r("bash.execute", async (params) => {
-    const safeCommand = validateCommand(params.command);
-    const pid = pidCounter++;
-    const proc: TrackedProcess = { pid, command: safeCommand, running: true };
-    processes.set(pid, proc);
+	r("bash.execute", async (params) => {
+		const safeCommand = validateCommand(params.command);
+		const pid = pidCounter++;
+		const proc: TrackedProcess = { pid, command: safeCommand, running: true };
+		processes.set(pid, proc);
 
-    try {
-      const subprocess = Bun.spawn(safeCommand.split(" "), {
-        cwd: params.cwd || process.cwd(),
-        stdout: "pipe",
-        stderr: "pipe",
-      });
+		try {
+			const subprocess = Bun.spawn(safeCommand.split(" "), {
+				cwd: params.cwd || process.cwd(),
+				stdout: "pipe",
+				stderr: "pipe",
+			});
 
-      proc.pid = subprocess.pid;
+			proc.pid = subprocess.pid;
 
-      const stdout = await new Response(subprocess.stdout).text();
-      const stderr = await new Response(subprocess.stderr).text();
-      const exitCode = await subprocess.exited;
+			const stdout = await new Response(subprocess.stdout).text();
+			const stderr = await new Response(subprocess.stderr).text();
+			const exitCode = await subprocess.exited;
 
-      proc.running = false;
+			proc.running = false;
 
-      const output = stdout + (stderr ? `\n[stderr]\n${stderr}` : "");
+			const output = stdout + (stderr ? `\n[stderr]\n${stderr}` : "");
 
-      server.emitEvent("bash.output", { pid, data: output, stream: "stdout" }, {});
-      server.emitEvent("bash.exit", { pid, code: exitCode }, {});
+			server.emitEvent("bash.output", { pid, data: output, stream: "stdout" }, {});
+			server.emitEvent("bash.exit", { pid, code: exitCode }, {});
 
-      return { pid, output };
-    } catch (err) {
-      proc.running = false;
-      const output = `Error: ${err instanceof Error ? err.message : String(err)}`;
-      server.emitEvent("bash.output", { pid, data: output, stream: "stderr" }, {});
-      server.emitEvent("bash.exit", { pid, code: 1 }, {});
-      return { pid, output };
-    }
-  });
+			return { pid, output };
+		} catch (err) {
+			proc.running = false;
+			const output = `Error: ${err instanceof Error ? err.message : String(err)}`;
+			server.emitEvent("bash.output", { pid, data: output, stream: "stderr" }, {});
+			server.emitEvent("bash.exit", { pid, code: 1 }, {});
+			return { pid, output };
+		}
+	});
 
-  r("bash.kill", async (params) => {
-    const proc = processes.get(params.pid);
-    if (proc) {
-      proc.running = false;
-      processes.delete(params.pid);
-      return { success: true };
-    }
-    return { success: false };
-  });
+	r("bash.kill", async (params) => {
+		const proc = processes.get(params.pid);
+		if (proc) {
+			proc.running = false;
+			processes.delete(params.pid);
+			return { success: true };
+		}
+		return { success: false };
+	});
 
-  r("bash.listProcesses", async () => ({
-    processes: Array.from(processes.values()),
-  }));
+	r("bash.listProcesses", async () => ({
+		processes: Array.from(processes.values()),
+	}));
 }