@dyyz1993/create-agent 2.1.0 → 2.1.2

package/templates/cowork/scripts/dev.ts

@@ -0,0 +1,138 @@
+/**
+ * Dev orchestration script — single command to start backend + Vite.
+ *
+ * Usage: bun run dev:web
+ *
+ * 1. Starts backend server (dynamic port, writes to .server-port)
+ * 2. Waits for .server-port to appear
+ * 3. Starts Vite dev server (reads backend port for proxy)
+ * 4. On Ctrl+C / SIGTERM: kills both processes, cleans up .server-port
+ */
+
+import { spawn } from "child_process";
+import { existsSync, readFileSync, unlinkSync } from "fs";
+import { resolve } from "path";
+
+const ROOT = resolve(import.meta.dir, "..");
+const PORT_FILE = resolve(ROOT, ".server-port");
+const MAX_WAIT_MS = 10000;
+const POLL_INTERVAL_MS = 100;
+
+let backend: ReturnType<typeof spawn> | null = null;
+let vite: ReturnType<typeof spawn> | null = null;
+let shuttingDown = false;
+
+function cleanup() {
+  if (shuttingDown) return;
+  shuttingDown = true;
+
+  if (vite && !vite.killed) {
+    vite.kill("SIGTERM");
+  }
+  if (backend && !backend.killed) {
+    backend.kill("SIGTERM");
+  }
+  try { if (existsSync(PORT_FILE)) unlinkSync(PORT_FILE); } catch { /* ignore cleanup errors */ }
+
+  setTimeout(() => {
+    if (backend && !backend.killed) backend.kill("SIGKILL");
+    if (vite && !vite.killed) vite.kill("SIGKILL");
+    process.exit(0);
+  }, 3000);
+}
+
+process.on("SIGINT", cleanup);
+process.on("SIGTERM", cleanup);
+process.on("exit", () => {
+  try { if (existsSync(PORT_FILE)) unlinkSync(PORT_FILE); } catch { /* ignore */ }
+});
+
+function log(tag: string, msg: string) {
+  console.log(`[${tag}] ${msg}`);
+}
+
+function waitForPortFile(): Promise<number> {
+  return new Promise((resolve, reject) => {
+    const start = Date.now();
+    const check = () => {
+      if (existsSync(PORT_FILE)) {
+        try {
+          const port = parseInt(readFileSync(PORT_FILE, "utf-8").trim());
+          if (port > 0) { resolve(port); return; }
+        } catch { /* ignore parse errors */ }
+      }
+      if (Date.now() - start > MAX_WAIT_MS) {
+        reject(new Error("Timed out waiting for backend to start"));
+        return;
+      }
+      setTimeout(check, POLL_INTERVAL_MS);
+    };
+    check();
+  });
+}
+
+async function main() {
+  log("dev", "Starting backend server...");
+
+  backend = spawn("bun", ["src/server.ts"], {
+    cwd: ROOT,
+    stdio: ["pipe", "pipe", "pipe"],
+  });
+
+  backend.stdout?.on("data", (data: Buffer) => {
+    data.toString().split("\n").filter(Boolean).forEach((line) => {
+      log("backend", line);
+    });
+  });
+
+  backend.stderr?.on("data", (data: Buffer) => {
+    data.toString().split("\n").filter(Boolean).forEach((line) => {
+      log("backend", line);
+    });
+  });
+
+  backend.on("exit", (code) => {
+    if (!shuttingDown) {
+      log("backend", `exited with code ${code}`);
+      cleanup();
+    }
+  });
+
+  const backendPort = await waitForPortFile();
+  log("dev", `Backend ready on port ${backendPort}`);
+
+  log("dev", "Starting Vite dev server...");
+  vite = spawn("vite", [], {
+    cwd: ROOT,
+    stdio: ["pipe", "pipe", "pipe"],
+    env: { ...process.env },
+  });
+
+  vite.stdout?.on("data", (data: Buffer) => {
+    data.toString().split("\n").filter(Boolean).forEach((line) => {
+      log("vite", line);
+    });
+  });
+
+  vite.stderr?.on("data", (data: Buffer) => {
+    data.toString().split("\n").filter(Boolean).forEach((line) => {
+      log("vite", line);
+    });
+  });
+
+  vite.on("exit", (code) => {
+    if (!shuttingDown) {
+      log("vite", `exited with code ${code}`);
+      cleanup();
+    }
+  });
+
+  log("dev", `Proxy: Vite → http://localhost:${backendPort}`);
+  log("dev", "Press Ctrl+C to stop both servers");
+}
+
+main().catch((err) => {
+  console.error("Dev startup failed:", err.message);
+  cleanup();
+  process.exit(1);
+});

package/templates/cowork/src/__tests__/hybrid-mode.test.ts

@@ -0,0 +1,126 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+
+vi.mock("electrobun/bun", () => ({
+	BrowserWindow: {
+		defineRPC: vi.fn(() => ({})),
+	},
+	BrowserView: {
+		defineRPC: vi.fn(() => ({
+			requests: {},
+			messages: {},
+		})),
+	},
+	Updater: {
+		localInfo: vi.fn(() => ({ channel: vi.fn(() => "dev") })),
+	},
+	ApplicationMenu: {
+		setApplicationMenu: vi.fn(),
+	},
+}));
+
+vi.mock("electrobun", () => ({}));
+
+describe("混合模式", () => {
+	beforeEach(() => {
+		vi.resetModules();
+		delete process.env.ENABLE_WEB_SERVICE;
+		delete process.env.AUTH_TOKEN;
+		process.env.NODE_ENV = "test";
+	});
+
+	afterEach(() => {
+		vi.restoreAllMocks();
+	});
+
+	it("默认不启动 Web 服务（enableWebService 为 false）", async () => {
+		const { config } = await import("../server-config");
+		expect(config.enableWebService).toBe(false);
+	});
+
+	it("enableWebService=true 时启动 HTTP + WS 服务", async () => {
+		process.env.ENABLE_WEB_SERVICE = "true";
+		const { config } = await import("../server-config");
+		expect(config.enableWebService).toBe(true);
+	});
+
+	it("IPC 和 WS 服务同时工作，状态隔离", async () => {
+		const { ElectrobunTransport } = await import("../gateway/ipc-transport");
+		const ipcTransport = new ElectrobunTransport();
+		expect(ipcTransport.isConnected()).toBe(false);
+
+		ipcTransport.setBrowserView({ executeJavascript: vi.fn() });
+		expect(ipcTransport.isConnected()).toBe(true);
+
+		const { createWebServer } = await import("../shared/lib/web-server");
+		const webServer = await createWebServer({
+			port: 0,
+			authToken: "test-token",
+			maxUploadSize: 1024,
+			corsOrigin: "*",
+		});
+		expect(webServer.port).toBeGreaterThan(0);
+		expect(ipcTransport.isConnected()).toBe(true);
+		await webServer.close();
+	});
+
+	it("WS 客户端需要 token 才能连接", async () => {
+		const { createWebServer } = await import("../shared/lib/web-server");
+		const webServer = await createWebServer({
+			port: 0,
+			authToken: "test-token",
+			maxUploadSize: 1024,
+			corsOrigin: "*",
+		});
+		expect(webServer.authToken).toBeTruthy();
+		expect(webServer.authToken.length).toBeGreaterThan(0);
+		await webServer.close();
+	});
+
+	it("IPC 客户端不需要 token", async () => {
+		const { ElectrobunTransport } = await import("../gateway/ipc-transport");
+		const transport = new ElectrobunTransport();
+		transport.setBrowserView({ executeJavascript: vi.fn() });
+		expect(transport.isConnected()).toBe(true);
+	});
+
+	it("动态生成的 token 每次启动不同", async () => {
+		const { createWebServer } = await import("../shared/lib/web-server");
+		const ws1 = await createWebServer({
+			port: 0,
+			authToken: `token-${Date.now()}-1`,
+			maxUploadSize: 1024,
+			corsOrigin: "*",
+		});
+		const ws2 = await createWebServer({
+			port: 0,
+			authToken: `token-${Date.now()}-2`,
+			maxUploadSize: 1024,
+			corsOrigin: "*",
+		});
+		expect(ws1.authToken).not.toBe(ws2.authToken);
+		await ws1.close();
+		await ws2.close();
+	});
+
+	it("关闭桌面端时 Web 服务也关闭", async () => {
+		const { createWebServer } = await import("../shared/lib/web-server");
+		const webServer = await createWebServer({
+			port: 0,
+			authToken: "test-token",
+			maxUploadSize: 1024,
+			corsOrigin: "*",
+		});
+		expect(webServer.httpServer.listening).toBe(true);
+		await webServer.close();
+		await new Promise((r) => setTimeout(r, 50));
+		expect(webServer.httpServer.listening).toBe(false);
+	});
+
+	it("getLocalIP 返回有效 IP 地址", async () => {
+		const { getLocalIP } = await import("../shared/lib/web-server");
+		const ip = getLocalIP();
+		expect(ip).toBeTruthy();
+		// IPv4 pattern
+		expect(ip).toMatch(/^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/);
+	});
+});

package/templates/cowork/src/__tests__/server-config-security.test.ts

@@ -0,0 +1,55 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+
+describe("Server Config 安全策略", () => {
+	const originalEnv = process.env;
+
+	beforeEach(() => {
+		vi.resetModules();
+		process.env = { ...originalEnv };
+	});
+
+	afterEach(() => {
+		process.env = originalEnv;
+	});
+
+	it("生产环境未设 AUTH_TOKEN 应抛出致命错误", async () => {
+		process.env.NODE_ENV = "production";
+		delete process.env.AUTH_TOKEN;
+		await expect(import("../server-config")).rejects.toThrow(/AUTH_TOKEN/);
+	});
+
+	it("开发环境未设 AUTH_TOKEN 应自动生成随机 token", async () => {
+		process.env.NODE_ENV = "development";
+		delete process.env.AUTH_TOKEN;
+		const mod = await import("../server-config");
+		expect(mod.config.authToken).toBeTruthy();
+		expect(mod.config.authToken).not.toBe("pi-agent-template-token");
+		expect(mod.config.authToken.length).toBeGreaterThan(20);
+	});
+
+	it("显式设置 AUTH_TOKEN 应使用用户提供的值", async () => {
+		delete process.env.NODE_ENV;
+		process.env.AUTH_TOKEN = "my-custom-token-12345";
+		const mod = await import("../server-config");
+		expect(mod.config.authToken).toBe("my-custom-token-12345");
+	});
+
+	it("自动生成的 token 每次不同", async () => {
+		process.env.NODE_ENV = "development";
+		delete process.env.AUTH_TOKEN;
+		vi.resetModules();
+		const mod1 = await import("../server-config");
+		const token1 = mod1.config.authToken;
+		vi.resetModules();
+		const mod2 = await import("../server-config");
+		const token2 = mod2.config.authToken;
+		expect(token1).not.toBe(token2);
+	});
+
+	it("生产环境设了 AUTH_TOKEN 不应抛错", async () => {
+		process.env.NODE_ENV = "production";
+		process.env.AUTH_TOKEN = "production-secure-token";
+		const mod = await import("../server-config");
+		expect(mod.config.authToken).toBe("production-secure-token");
+	});
+});

package/templates/cowork/src/__tests__/server-config.test.ts

@@ -0,0 +1,59 @@
+import { describe, it, expect } from "vitest";
+import { parseEnvInt } from "../server-config";
+
+describe("parseEnvInt", () => {
+  it("should return default when value is undefined", () => {
+    expect(parseEnvInt("TEST_KEY", undefined, 3100, 1024, 65535)).toBe(3100);
+  });
+
+  it("should return default when value is empty string", () => {
+    expect(parseEnvInt("TEST_KEY", "", 3100, 1024, 65535)).toBe(3100);
+  });
+
+  it("should parse valid number", () => {
+    expect(parseEnvInt("TEST_KEY", "8080", 3100, 1024, 65535)).toBe(8080);
+  });
+
+  it("should return default for NaN input", () => {
+    expect(parseEnvInt("TEST_KEY", "abc", 3100, 1024, 65535)).toBe(3100);
+  });
+
+  it("should return default for out-of-range value (too low)", () => {
+    expect(parseEnvInt("TEST_KEY", "80", 3100, 1024, 65535)).toBe(3100);
+  });
+
+  it("should return default for out-of-range value (too high)", () => {
+    expect(parseEnvInt("TEST_KEY", "99999", 3100, 1024, 65535)).toBe(3100);
+  });
+
+  it("should accept boundary min value", () => {
+    expect(parseEnvInt("TEST_KEY", "1024", 3100, 1024, 65535)).toBe(1024);
+  });
+
+  it("should accept boundary max value", () => {
+    expect(parseEnvInt("TEST_KEY", "65535", 3100, 1024, 65535)).toBe(65535);
+  });
+});
+
+describe("server-config exports", () => {
+  it("should export config with all required fields", async () => {
+    const { config } = await import("../server-config");
+    expect(config).toHaveProperty("port");
+    expect(config).toHaveProperty("authToken");
+    expect(config).toHaveProperty("maxUploadSize");
+    expect(config).toHaveProperty("logDir");
+    expect(config).toHaveProperty("corsOrigin");
+    expect(typeof config.port).toBe("number");
+    expect(typeof config.authToken).toBe("string");
+    expect(typeof config.maxUploadSize).toBe("number");
+    expect(typeof config.corsOrigin).toBe("string");
+  });
+
+  it("should have sensible defaults", async () => {
+    const { config } = await import("../server-config");
+    expect(config.port).toBeGreaterThanOrEqual(1024);
+    expect(config.port).toBeLessThanOrEqual(65535);
+    expect(config.maxUploadSize).toBeGreaterThan(0);
+    expect(config.corsOrigin).toBeTruthy();
+  });
+});

package/templates/cowork/src/bun/index.ts

@@ -0,0 +1,130 @@
+import { BrowserWindow, BrowserView, Updater, ApplicationMenu } from 'electrobun/bun';
+import { RPCServer } from '@dyyz1993/rpc-core';
+import { ElectrobunTransport } from '../gateway/ipc-transport';
+import { registerAllHandlers } from '../shared/register-all-handlers';
+import { createLogger, configureLogDir } from '../shared/lib/logger';
+import { config } from '../server-config';
+
+configureLogDir('logs');
+const log = createLogger('server');
+
+async function getMainViewUrl(): Promise<string> {
+	const channel = await Updater.localInfo.channel();
+	const DEV_SERVER_URL = `http://localhost:${process.env.VITE_PORT || '7300'}`;
+	if (channel === 'dev') {
+		try {
+			await fetch(DEV_SERVER_URL, { method: 'HEAD' });
+			log.info(`HMR enabled: Using Vite dev server at ${DEV_SERVER_URL}`);
+			return DEV_SERVER_URL;
+		} catch {
+			log.info('Vite dev server not running.');
+		}
+	}
+	return 'views://mainview/index.html';
+}
+
+const url = await getMainViewUrl();
+
+const transport = new ElectrobunTransport();
+const server = new RPCServer(transport);
+
+// --- 注册 RPC handlers（自动导入 handlers barrel） ---
+registerAllHandlers(server, { platform: 'desktop' });
+
+// --- 创建窗口 ---
+
+const mainWindow = new BrowserWindow({
+	title: 'Cowork',
+	url,
+	frame: {
+		width: 1200,
+		height: 800,
+		x: 200,
+		y: 200,
+	},
+	rpc: BrowserView.defineRPC({
+		maxRequestTime: 60000,
+		handlers: {
+			requests: {},
+			messages: {
+				// @ts-expect-error Electrobun's messages schema doesn't support custom keys at compile time
+				'rpc-message': (data: unknown) => {
+					try {
+						const message = typeof data === 'string' ? JSON.parse(data) : data;
+						transport.handleMessage(message);
+					} catch (error) {
+						log.error('Failed to parse RPC message', { error });
+					}
+				},
+			},
+		},
+	}),
+});
+
+transport.setBrowserView(mainWindow.webview);
+
+log.info('Pi Agent desktop app started!');
+
+// ==============================
+// Optional: Web service for LAN access (hybrid mode)
+// ==============================
+if (config.enableWebService) {
+	try {
+		const { createWebServer, getLocalIP } = await import('../shared/lib/web-server');
+
+		const webServer = await createWebServer({
+			port: config.port,
+			authToken: config.authToken,
+			maxUploadSize: config.maxUploadSize,
+			corsOrigin: '*',
+		});
+
+		const localIp = getLocalIP();
+		log.info(`[Hybrid] Web service started: http://${localIp}:${webServer.port}`);
+		log.info(`[Hybrid] RPC: POST http://${localIp}:${webServer.port}/api/rpc`);
+		log.info(`[Hybrid] SSE: GET  http://${localIp}:${webServer.port}/api/events`);
+		log.info(
+			`[Hybrid] Share URL: http://${localIp}:${webServer.port}?token=${webServer.authToken}`,
+		);
+
+		server.emitEvent('hybrid.ready', {
+			url: `http://${localIp}:${webServer.port}`,
+			rpcUrl: `http://${localIp}:${webServer.port}/api/rpc`,
+			sseUrl: `http://${localIp}:${webServer.port}/api/events`,
+			token: webServer.authToken,
+		});
+	} catch (err) {
+		log.error('[Hybrid] Failed to start web service', {
+			error: err instanceof Error ? err.message : String(err),
+		});
+	}
+}
+
+ApplicationMenu.setApplicationMenu([
+	{
+		label: 'Pi Agent',
+		submenu: [
+			{ role: 'about' },
+			{ type: 'separator' },
+			{ role: 'hide' },
+			{ role: 'hideOthers' },
+			{ role: 'showAll' },
+			{ type: 'separator' },
+			{ role: 'quit' },
+		],
+	},
+	{
+		label: 'Edit',
+		submenu: [
+			{ role: 'undo' },
+			{ role: 'redo' },
+			{ type: 'separator' },
+			{ role: 'cut' },
+			{ role: 'copy' },
+			{ role: 'paste' },
+			{ role: 'selectAll' },
+		],
+	},
+	{ label: 'View', submenu: [{ role: 'toggleFullScreen' }] },
+	{ label: 'Window', submenu: [{ role: 'minimize' }, { role: 'zoom' }] },
+]);

package/templates/cowork/src/bun/three.d.ts

@@ -0,0 +1 @@
+declare module "three";

package/templates/cowork/src/gateway/http-routes.ts

@@ -0,0 +1 @@
+export { createHttpHandler, type HttpRouteDeps } from "../shared/http-routes";

package/templates/cowork/src/gateway/ipc-transport.ts

@@ -0,0 +1,68 @@
+import type { Transport, MessageHandler, ErrorHandler } from "@dyyz1993/rpc-core";
+
+/**
+ * Transport that bridges between Bun and Webview via:
+ * - Bun → Browser: executeJavascript calls window.__piAgentIPC()
+ * - Browser → Bun: __electrobunBunBridge.postMessage with Electrobun message format
+ */
+export class ElectrobunTransport implements Transport {
+  private messageHandlers: Set<MessageHandler> = new Set();
+  private errorHandlers: Set<ErrorHandler> = new Set();
+  private browserView: { executeJavascript: (js: string) => void } | null = null;
+  private closed = false;
+
+  setBrowserView(view: { executeJavascript: (js: string) => void }): void {
+    this.browserView = view;
+  }
+
+  async send(message: unknown): Promise<void> {
+    if (this.closed) {
+      throw new Error("Transport is closed");
+    }
+    if (!this.browserView) {
+      throw new Error("BrowserView not set");
+    }
+
+    // Pass JSON directly as a JS expression — JSON is valid JavaScript
+    const msgJson = JSON.stringify(message);
+    this.browserView.executeJavascript(
+      `if(typeof window.__piAgentIPC==="function"){window.__piAgentIPC(${msgJson})}`
+    );
+  }
+
+  onMessage(handler: MessageHandler): () => void {
+    this.messageHandlers.add(handler);
+    return () => {
+      this.messageHandlers.delete(handler);
+    };
+  }
+
+  onError(handler: ErrorHandler): () => void {
+    this.errorHandlers.add(handler);
+    return () => {
+      this.errorHandlers.delete(handler);
+    };
+  }
+
+  onDisconnect(): () => void {
+    return () => {};
+  }
+
+  isConnected(): boolean {
+    return this.browserView !== null && !this.closed;
+  }
+
+  close(): void {
+    this.closed = true;
+    this.messageHandlers.clear();
+    this.errorHandlers.clear();
+    this.browserView = null;
+  }
+
+  handleMessage(message: unknown): void {
+    if (this.closed) return;
+    for (const handler of this.messageHandlers) {
+      handler(message);
+    }
+  }
+}