@dyyz1993/create-agent 2.0.0 → 2.0.1

package/templates/general/src/server.ts

@@ -1,15 +1,7 @@
-/**
- * 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 { 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 +14,59 @@ 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); });
-
-const httpServer = createServer();
-const wss = createWsHandler(httpServer, { config });
+process.on("SIGINT", () => {
+	cleanupPortFile();
+	process.exit(0);
+});
+process.on("SIGTERM", () => {
+	cleanupPortFile();
+	process.exit(0);
+});
 
-httpServer.on("request", createHttpHandler({
-  config,
-  getWebSocketClientCount: () => wss.clients.size,
-}));
+async function start() {
+	const { port, close } = await createWebServer({
+		port: config.port,
+		authToken: config.authToken,
+		maxUploadSize: config.maxUploadSize,
+		corsOrigin: config.corsOrigin,
+	});
 
-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);
-  });
-}
+	process.on("SIGINT", () => {
+		close();
+		cleanupPortFile();
+		process.exit(0);
+	});
+	process.on("SIGTERM", () => {
+		close();
+		cleanupPortFile();
+		process.exit(0);
+	});
 
-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`);
-}
+	writePortFile(port);
+	registerPort(PROJECT_ROOT, port, PROJECT_NAME);
 
-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}");
+	// 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);
+	log.error("Server failed to start", { error: err.message });
+	process.exit(1);
 });

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

@@ -9,175 +9,180 @@ 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");
+const STORAGE_PATH = join(homedir(), ".pi-agent", "chat-history-desktop.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; },
-  };
+	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 {}
+	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");
+	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");
-  });
+	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");
+	});
 });