@dyyz1993/create-agent 2.0.0 → 2.1.0

package/templates/agent/src/shared/lib/logger.ts

@@ -1,130 +1,152 @@
-import { appendFile, mkdir as mkdirAsync, readdir as readdirAsync, unlink as unlinkAsync, stat as statAsync } from "fs/promises";
+import {
+	appendFile,
+	mkdir as mkdirAsync,
+	readdir as readdirAsync,
+	unlink as unlinkAsync,
+	stat as statAsync,
+} from "fs/promises";
 import { mkdirSync, existsSync } from "fs";
 import { join } from "path";
 
-export type LogModule = "server" | "gateway" | "system" | "chat" | "file" | "timer" | "git" | "feed";
+export type LogModule =
+	| "server"
+	| "gateway"
+	| "system"
+	| "chat"
+	| "file"
+	| "timer"
+	| "git"
+	| "feed"
+	| "web-server";
 type LogLevel = "debug" | "info" | "warn" | "error";
 
 interface LogEntry {
-  timestamp: string;
-  level: LogLevel;
-  module: LogModule;
-  message: string;
-  data?: Record<string, unknown>;
+	timestamp: string;
+	level: LogLevel;
+	module: LogModule;
+	message: string;
+	data?: Record<string, unknown>;
 }
 
 let _logDir: string | null = null;
 let _maxAgeDays = 30;
 
-export async function configureLogDir(dir: string, options?: { maxAgeDays?: number }): Promise<void> {
-  _logDir = dir;
-  if (options?.maxAgeDays !== undefined) {
-    _maxAgeDays = options.maxAgeDays;
-  }
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
-  }
-  await cleanOldLogs(dir, _maxAgeDays);
+export async function configureLogDir(
+	dir: string,
+	options?: { maxAgeDays?: number }
+): Promise<void> {
+	_logDir = dir;
+	if (options?.maxAgeDays !== undefined) {
+		_maxAgeDays = options.maxAgeDays;
+	}
+	if (!existsSync(dir)) {
+		mkdirSync(dir, { recursive: true });
+	}
+	await cleanOldLogs(dir, _maxAgeDays);
 }
 
 function getLogDir(): string {
-  if (!_logDir) {
-    _logDir = "logs";
-    if (!existsSync(_logDir)) {
-      mkdirSync(_logDir, { recursive: true });
-    }
-  }
-  return _logDir;
+	if (!_logDir) {
+		_logDir = "logs";
+		if (!existsSync(_logDir)) {
+			mkdirSync(_logDir, { recursive: true });
+		}
+	}
+	return _logDir;
 }
 
 async function cleanOldLogs(dir: string, maxAgeDays: number): Promise<void> {
-  try {
-    if (!existsSync(dir)) return;
-    const files = await readdirAsync(dir);
-    const cutoff = Date.now() - maxAgeDays * 86400000;
-    for (const f of files) {
-      if (!f.endsWith(".log")) continue;
-      const filePath = join(dir, f);
-      const s = await statAsync(filePath);
-      if (s.mtimeMs < cutoff) {
-        await unlinkAsync(filePath);
-      }
-    }
-  } catch { /* ignore */ }
+	try {
+		if (!existsSync(dir)) return;
+		const files = await readdirAsync(dir);
+		const cutoff = Date.now() - maxAgeDays * 86400000;
+		for (const f of files) {
+			if (!f.endsWith(".log")) continue;
+			const filePath = join(dir, f);
+			const s = await statAsync(filePath);
+			if (s.mtimeMs < cutoff) {
+				await unlinkAsync(filePath);
+			}
+		}
+	} catch {
+		/* ignore */
+	}
 }
 
 function formatLine(entry: LogEntry): string {
-  const base = `[${entry.timestamp}] [${entry.level.toUpperCase()}] [${entry.module}] ${entry.message}`;
-  return entry.data ? `${base} ${JSON.stringify(entry.data)}` : base;
+	const base = `[${entry.timestamp}] [${entry.level.toUpperCase()}] [${entry.module}] ${entry.message}`;
+	return entry.data ? `${base} ${JSON.stringify(entry.data)}` : base;
 }
 
 let writeQueue: Promise<void> = Promise.resolve();
 
 function writeToFile(line: string): void {
-  writeQueue = writeQueue.then(async () => {
-    try {
-      const date = new Date().toISOString().slice(0, 10);
-      const dir = getLogDir();
-      if (!existsSync(dir)) {
-        await mkdirAsync(dir, { recursive: true });
-      }
-      await appendFile(join(dir, `${date}.log`), `${line}\n`);
-    } catch { /* ignore */ }
-  });
+	writeQueue = writeQueue.then(async () => {
+		try {
+			const date = new Date().toISOString().slice(0, 10);
+			const dir = getLogDir();
+			if (!existsSync(dir)) {
+				await mkdirAsync(dir, { recursive: true });
+			}
+			await appendFile(join(dir, `${date}.log`), `${line}\n`);
+		} catch {
+			/* ignore */
+		}
+	});
 }
 
 export function flushLogs(): Promise<void> {
-  return writeQueue;
+	return writeQueue;
 }
 
 export class Logger {
-  private readonly module: LogModule;
-
-  constructor(module: LogModule) {
-    this.module = module;
-  }
-
-  debug(message: string, data?: Record<string, unknown>): void {
-    this.write("debug", message, data);
-  }
-
-  info(message: string, data?: Record<string, unknown>): void {
-    this.write("info", message, data);
-  }
-
-  warn(message: string, data?: Record<string, unknown>): void {
-    this.write("warn", message, data);
-  }
-
-  error(message: string, data?: Record<string, unknown>): void {
-    this.write("error", message, data);
-  }
-
-  private write(level: LogLevel, message: string, data?: Record<string, unknown>): void {
-    const entry: LogEntry = {
-      timestamp: new Date().toISOString(),
-      level,
-      module: this.module,
-      message,
-      ...(data ? { data } : {}),
-    };
-
-    const line = formatLine(entry);
-
-    if (level === "error") {
-      console.error(line);
-    } else if (level === "warn") {
-      console.warn(line);
-    } else {
-      console.log(line);
-    }
-
-    if (process.env.NODE_ENV !== "production" || level !== "debug") {
-      writeToFile(line);
-    }
-  }
+	private readonly module: LogModule;
+
+	constructor(module: LogModule) {
+		this.module = module;
+	}
+
+	debug(message: string, data?: Record<string, unknown>): void {
+		this.write("debug", message, data);
+	}
+
+	info(message: string, data?: Record<string, unknown>): void {
+		this.write("info", message, data);
+	}
+
+	warn(message: string, data?: Record<string, unknown>): void {
+		this.write("warn", message, data);
+	}
+
+	error(message: string, data?: Record<string, unknown>): void {
+		this.write("error", message, data);
+	}
+
+	private write(level: LogLevel, message: string, data?: Record<string, unknown>): void {
+		const entry: LogEntry = {
+			timestamp: new Date().toISOString(),
+			level,
+			module: this.module,
+			message,
+			...(data ? { data } : {}),
+		};
+
+		const line = formatLine(entry);
+
+		if (level === "error") {
+			console.error(line);
+		} else if (level === "warn") {
+			console.warn(line);
+		} else {
+			console.log(line);
+		}
+
+		if (process.env.NODE_ENV !== "production" || level !== "debug") {
+			writeToFile(line);
+		}
+	}
 }
 
 export function createLogger(module: LogModule): Logger {
-  return new Logger(module);
+	return new Logger(module);
 }

package/templates/agent/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/agent/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/agent/src/shared/rpc-schema.ts

@@ -8,6 +8,7 @@ import type { FeedMethods, FeedEvents } from "./modules/feed";
 import type { BashMethods, BashEvents } from "./modules/bash";
 import type { RulesMethods } from "./modules/rules";
 import type { TodoMethods } from "./modules/todo";
+import type { DebugMethods } from "./modules/debug";
 
 /**
  * RPC 方法定义 — 前后端共享的唯一类型入口
@@ -19,7 +20,19 @@ import type { TodoMethods } from "./modules/todo";
  * handlers/ 自动发现，无需修改 register-all-handlers.ts
  * 入口文件（bun/index.ts, server.ts）无需修改
  */
-export interface RPCMethods extends AnyMethods, SystemMethods, FileMethods, TimerMethods, ChatMethods, GitMethods, FeedMethods, BashMethods, RulesMethods, TodoMethods {}
+export interface RPCMethods
+	extends
+		AnyMethods,
+		SystemMethods,
+		FileMethods,
+		TimerMethods,
+		ChatMethods,
+		GitMethods,
+		FeedMethods,
+		BashMethods,
+		RulesMethods,
+		TodoMethods,
+		DebugMethods {}
 
 /**
  * RPC 事件定义 — 合并所有模块事件
@@ -30,6 +43,6 @@ export interface RPCEvents extends TimerEvents, ChatEvents, FeedEvents, BashEven
  * Handler 注册选项
  */
 export interface HandlerOptions {
-  platform: "desktop" | "web";
-  enableBash?: boolean;
+	platform: "desktop" | "web";
+	enableBash?: boolean;
 }

package/templates/agent/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/agent/tsconfig.json

@@ -17,10 +17,20 @@
 		"noFallthroughCasesInSwitch": true,
 		"baseUrl": ".",
 		"paths": {
-			"@dyyz1993/rpc-core": ["../packages/rpc-core/src/index.ts"],
+			"@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/chat/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/chat/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",
@@ -32,7 +35,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",
@@ -40,10 +44,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",
@@ -53,5 +61,8 @@
 		"typescript-eslint": "^8.0.0",
 		"vite": "^6.0.3",
 		"vitest": "^4.1.5"
+	},
+	"overrides": {
+		"minimatch": "^10.0.1"
 	}
 }

package/templates/chat/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}$/);
+	});
+});