@dyyz1993/create-agent 2.0.0 → 2.1.0

package/templates/chat/src/shared/lib/web-server.ts

@@ -0,0 +1,128 @@
+import { createServer, type Server } from "http";
+import { networkInterfaces } from "os";
+import { createHttpHandler } from "../http-routes";
+import { createWsHandler } from "../../gateway/ws-handler";
+import { createLogger } from "./logger";
+
+const log = createLogger("web-server");
+
+export interface WebServerConfig {
+	port: number;
+	authToken: string;
+	maxUploadSize: number;
+	corsOrigin: string;
+}
+
+export interface WebServerResult {
+	httpServer: Server;
+	wss: ReturnType<typeof createWsHandler>;
+	port: number;
+	authToken: string;
+	close: () => Promise<void>;
+}
+
+export function getLocalIP(): string {
+	const nets = networkInterfaces();
+	for (const name of Object.keys(nets)) {
+		const interfaces = nets[name];
+		if (!interfaces) continue;
+		for (const net of interfaces) {
+			if (net.family === "IPv4" && !net.internal) {
+				return net.address;
+			}
+		}
+	}
+	return "127.0.0.1";
+}
+
+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);
+	});
+}
+
+export async function findAvailablePort(startPort: number, maxRetries = 10): Promise<number> {
+	for (let port = startPort; port < startPort + maxRetries; port++) {
+		try {
+			await checkPort(port);
+			return port;
+		} catch {
+			continue;
+		}
+	}
+	throw new Error(`No available port found after ${maxRetries} retries starting from ${startPort}`);
+}
+
+function getFreePort(): Promise<number> {
+	return new Promise((resolve, reject) => {
+		const s = createServer();
+		s.listen(0, () => {
+			const addr = s.address();
+			s.close(() => {
+				if (typeof addr === "object" && addr) {
+					resolve(addr.port);
+				} else {
+					reject(new Error("Failed to allocate port"));
+				}
+			});
+		});
+		s.on("error", reject);
+	});
+}
+
+export async function createWebServer(config: WebServerConfig): Promise<WebServerResult> {
+	const port = config.port === 0 ? await getFreePort() : await findAvailablePort(config.port);
+
+	const httpServer = createServer();
+
+	const wss = createWsHandler(httpServer, {
+		config: {
+			port,
+			authToken: config.authToken,
+			maxUploadSize: config.maxUploadSize,
+		},
+	});
+
+	httpServer.on(
+		"request",
+		createHttpHandler({
+			config: {
+				port,
+				authToken: config.authToken,
+				maxUploadSize: config.maxUploadSize,
+				corsOrigin: config.corsOrigin,
+			},
+			getWebSocketClientCount: () => wss.clients.size,
+		})
+	);
+
+	return new Promise((resolve, reject) => {
+		httpServer.listen(port, () => {
+			log.info("Web server started", { port, corsOrigin: config.corsOrigin });
+
+			resolve({
+				httpServer,
+				wss,
+				port,
+				authToken: config.authToken,
+				close: () =>
+					new Promise<void>((res) => {
+						wss.clients.forEach((ws) => ws.close());
+						wss.close(() => {
+							httpServer.close(() => res());
+						});
+					}),
+			});
+		});
+		httpServer.on("error", reject);
+	});
+}

package/templates/chat/src/shared/modules/debug.ts

@@ -0,0 +1,8 @@
+export interface DebugMethods {
+	"debug.subscriptions": {
+		params: {};
+		result: {
+			subscriptions: Array<{ id: string; eventType: string; filter: Record<string, unknown> }>;
+		};
+	};
+}

package/templates/chat/src/shared/rpc-schema.ts

@@ -1,11 +1,12 @@
 import type { AnyMethods } from "@dyyz1993/rpc-core";
 import type { SystemMethods } from "./modules/system";
 import type { ChatMethods, ChatEvents } from "./modules/chat";
+import type { DebugMethods } from "./modules/debug";
 
-export interface RPCMethods extends AnyMethods, SystemMethods, ChatMethods {}
+export interface RPCMethods extends AnyMethods, SystemMethods, ChatMethods, DebugMethods {}
 
 export interface RPCEvents extends ChatEvents {}
 
 export interface HandlerOptions {
-  platform: "desktop" | "web";
+	platform: "desktop" | "web";
 }

package/templates/chat/tsconfig.ipc.json

@@ -0,0 +1,14 @@
+{
+	"extends": "./tsconfig.json",
+	"compilerOptions": {
+		"noUnusedLocals": false,
+		"noUnusedParameters": false,
+		"skipLibCheck": true,
+		"noUncheckedIndexedAccess": true,
+		"noImplicitReturns": true,
+		"noFallthroughCasesInSwitch": true,
+		"strict": true
+	},
+	"include": ["src/bun", "src/gateway/ipc-transport.ts", "src/shared"],
+	"exclude": ["node_modules", "dist", "build", "**/__tests__/**", "**/*.test.ts", "**/*.test.tsx"]
+}

package/templates/chat/tsconfig.json

@@ -19,8 +19,18 @@
 		"paths": {
 			"@dyyz1993/rpc-core": ["../packages/rpc-core/src/index.ts"],
 			"@shared/*": ["../shared/*"]
-		}
+		},
+		"noUncheckedIndexedAccess": true,
+		"noImplicitReturns": true
 	},
 	"include": ["src", "../shared"],
-	"exclude": ["node_modules", "dist", "build", "../../package/dist", "**/__tests__/**", "**/*.test.ts", "**/*.test.tsx"]
+	"exclude": [
+		"node_modules",
+		"dist",
+		"build",
+		"../../package/dist",
+		"**/__tests__/**",
+		"**/*.test.ts",
+		"**/*.test.tsx"
+	]
 }

package/templates/general/eslint.config.mjs

@@ -1,6 +1,9 @@
 import js from '@eslint/js';
 import tseslint from 'typescript-eslint';
-import rpcPlugin from './eslint-plugin-rpc/index.js';
+import rpcPlugin from '@dyyz1993/eslint-plugin-rpc';
+import reactHooks from 'eslint-plugin-react-hooks';
+import reactRefresh from 'eslint-plugin-react-refresh';
+import jsxA11y from 'eslint-plugin-jsx-a11y';
 
 export default tseslint.config(
   js.configs.recommended,
@@ -10,7 +13,6 @@ export default tseslint.config(
       'node_modules/**',
       'build/**',
       'dist/**',
-      'eslint-plugin-rpc/**',
       'postcss.config.js',
       'tailwind.config.js',
     ],
@@ -19,8 +21,19 @@ export default tseslint.config(
     files: ['src/**/*.{ts,tsx}'],
     plugins: {
       rpc: rpcPlugin,
+      'react-hooks': reactHooks,
+      'react-refresh': reactRefresh,
+      'jsx-a11y': jsxA11y,
     },
     rules: {
+      ...reactHooks.configs.recommended.rules,
+      'react-hooks/rules-of-hooks': 'warn',
+      'react-hooks/exhaustive-deps': 'warn',
+      'react-refresh/only-export-components': ['warn', { allowConstantExport: true }],
+      ...jsxA11y.configs.recommended.rules,
+      'jsx-a11y/click-events-have-key-events': 'warn',
+      'jsx-a11y/no-static-element-interactions': 'warn',
+      'jsx-a11y/no-autofocus': 'warn',
       // TS 严格规则
       '@typescript-eslint/no-explicit-any': 'error',
       '@typescript-eslint/no-empty-object-type': ['error', { allowObjectTypes: 'always', allowInterfaces: 'with-single-extends' }],

package/templates/general/package.json

@@ -9,6 +9,9 @@
 		"dev:server": "bun src/server.ts",
 		"build": "vite build",
 		"build:canary": "vite build && electrobun build --env=canary",
+		"build:mac": "vite build && electrobun build --env=canary",
+		"build:win": "vite build && electrobun build --env=canary",
+		"build:linux": "vite build && electrobun build --env=canary",
 		"lint": "eslint .",
 		"lint:fix": "eslint . --fix",
 		"prepare": "husky",
@@ -19,7 +22,7 @@
 	"dependencies": {
 		"@dyyz1993/rpc-core": "^1.2.0",
 		"@tanstack/react-virtual": "^3.13.24",
-		"electrobun": "1.13.1",
+		"electrobun": "1.18.1",
 		"i18next": "^24.2.2",
 		"i18next-browser-languagedetector": "^8.0.4",
 		"lucide-react": "^1.9.0",
@@ -33,7 +36,8 @@
 		"zustand": "^5.0.12"
 	},
 	"devDependencies": {
-			"@eslint/js": "^9.0.0",
+		"@dyyz1993/eslint-plugin-rpc": "workspace:*",
+		"@eslint/js": "^9.0.0",
 		"@testing-library/jest-dom": "^6.9.1",
 		"@testing-library/react": "^16.3.2",
 		"@testing-library/user-event": "^14.6.1",
@@ -41,10 +45,14 @@
 		"@types/react": "^18.3.12",
 		"@types/react-dom": "^18.3.1",
 		"@types/ws": "^8.18.1",
+		"ws": "^8.18.0",
 		"@vitejs/plugin-react": "^4.3.4",
 		"autoprefixer": "^10.4.20",
 		"concurrently": "^9.1.0",
 		"eslint": "^9.0.0",
+		"eslint-plugin-jsx-a11y": "^6.10.0",
+		"eslint-plugin-react-hooks": "^5.2.0",
+		"eslint-plugin-react-refresh": "^0.4.20",
 		"happy-dom": "^20.9.0",
 		"husky": "^9.1.0",
 		"jsdom": "^29.1.1",
@@ -54,5 +62,8 @@
 		"typescript-eslint": "^8.0.0",
 		"vite": "^6.0.3",
 		"vitest": "^4.1.5"
+	},
+	"overrides": {
+		"minimatch": "^10.0.1"
 	}
 }

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

@@ -0,0 +1,125 @@
+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();
+		expect(ip).toMatch(/^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/);
+	});
+});

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

@@ -2,58 +2,60 @@ 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 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 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 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 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 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 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 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);
-  });
+	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();
-  });
+	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("enableWebService");
+		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.enableWebService).toBe("boolean");
+		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();
+	});
 });