@dyyz1993/create-agent 2.0.0 → 2.0.1

package/templates/agent/src/mainview/lib/api-client.ts

@@ -1,5 +1,11 @@
 import { createTypedClient, WebSocketTransport, IPCTransport } from "@dyyz1993/rpc-core";
-import type { TypedClient, MethodParams, MethodResult, EventPayload, EventMetadata } from "@dyyz1993/rpc-core";
+import type {
+	TypedClient,
+	MethodParams,
+	MethodResult,
+	EventPayload,
+	EventMetadata,
+} from "@dyyz1993/rpc-core";
 import type { RPCMethods, RPCEvents } from "../../shared/rpc-schema";
 import { rpcCache, CACHEABLE_METHODS } from "./rpc-cache";
 
@@ -10,182 +16,186 @@ import { rpcCache, CACHEABLE_METHODS } from "./rpc-cache";
  * 3. 默认值（开发用）
  */
 function resolveAuthToken(): string {
-  if (typeof window !== "undefined") {
-    const fromQuery = new URLSearchParams(window.location.search).get("token");
-    if (fromQuery) return fromQuery;
-    const fromStorage = localStorage.getItem("rpc-auth-token");
-    if (fromStorage) return fromStorage;
-  }
-  return "pi-agent-template-token";
+	if (typeof window !== "undefined") {
+		const fromQuery = new URLSearchParams(window.location.search).get("token");
+		if (fromQuery) return fromQuery;
+		const fromStorage = localStorage.getItem("rpc-auth-token");
+		if (fromStorage) return fromStorage;
+	}
+	return "pi-agent-template-token";
 }
 
 const AUTH_TOKEN = resolveAuthToken();
 
 class APIClientImpl {
-  private client: TypedClient<RPCMethods, RPCEvents> | null = null;
-  private initPromise: Promise<void> | null = null;
-  private _transport: "ipc" | "websocket" = "websocket";
-  private _baseUrl: string | null = null;
-  private wsTransport: WebSocketTransport | null = null;
-
-  /**
-   * 桌面端同步初始化：通过 executeJavascript 接收 + __electrobunBunBridge 发送
-   */
-  initSyncForDesktop(): void {
-    if (this.client) return;
-
-    const ipcTransport = new IPCTransport();
-    this._transport = "ipc";
-    this._baseUrl = null; // 桌面端不走 HTTP
-    this.client = createTypedClient<RPCMethods, RPCEvents>(ipcTransport);
-    this.setupElectrobunBridge(ipcTransport);
-    if (import.meta.env.DEV) {
-      console.warn("[APIClient] Desktop (IPC) initialized synchronously");
-    }
-  }
-
-  /**
-   * 异步初始化：Web 端使用（连接 WebSocket）
-   */
-  async initialize(): Promise<void> {
-    // 已连接且 transport 正常 → 直接返回
-    if (this.client && (this._transport === "ipc" || this.wsTransport?.isConnected())) {
-      return;
-    }
-
-    // client 存在但 WS 断开了 → 清理后重连
-    if (this.client && this.wsTransport && !this.wsTransport.isConnected()) {
-      this.wsTransport.close();
-      this.wsTransport = null;
-      this.client = null;
-      this.initPromise = null;
-    }
-
-    if (this.initPromise) return this.initPromise;
-
-    this.initPromise = (async () => {
-      const env = this.detectEnvironment();
-
-      if (env === "electrobun") {
-        // 不应走到这里，桌面端应通过 initSyncForDesktop() 初始化
-        this.initSyncForDesktop();
-      } else {
-        this._transport = "websocket";
-        const wsUrl = this.getWebSocketUrl();
-        this.wsTransport = new WebSocketTransport(wsUrl);
-        await this.wsTransport.connect();
-        this.client = createTypedClient<RPCMethods, RPCEvents>(this.wsTransport);
-
-        const wsUrlObj = new URL(wsUrl);
-        this._baseUrl = `http://${wsUrlObj.host}`;
-      }
-    })();
-
-    return this.initPromise;
-  }
-
-  private detectEnvironment(): "electrobun" | "browser" {
-    if (typeof window === "undefined") return "browser";
-    if (window.__electrobunBunBridge) return "electrobun";
-    return "browser";
-  }
-
-  private getWebSocketUrl(): string {
-    if (typeof window === "undefined") return `ws://localhost:3100?token=${AUTH_TOKEN}`;
-    const customUrl = (
-      new URLSearchParams(window.location.search).get("ws") ||
-      localStorage.getItem("rpc-websocket-url")
-    );
-    if (customUrl) return customUrl.includes("token=") ? customUrl : `${customUrl}?token=${AUTH_TOKEN}`;
-    return `ws://${window.location.host}/ws?token=${AUTH_TOKEN}`;
-  }
-
-  /**
-   * 桌面端 IPC 桥接：
-   * - Bun → Browser: 通过 executeJavascript 调用 window.__piAgentIPC()
-   * - Browser → Bun: 通过 __electrobunBunBridge.postMessage 发送 Electrobun 消息格式
-   */
-  private setupElectrobunBridge(ipcTransport: IPCTransport): void {
-    if (typeof window === "undefined") return;
-
-    const win = window;
-
-    // 1. 注册接收函数：Bun 通过 executeJavascript 调用此函数发送消息到 Browser
-    win.__piAgentIPC = (msg: unknown) => {
-      ipcTransport.simulateMessage(msg);
-    };
-
-    // 2. 覆写 send：将 RPC-core 消息包装成 Electrobun 消息格式，通过原生桥接发送
-    const bridge = win.__electrobunBunBridge;
-
-    if (bridge) {
-      ipcTransport.send = async (message: unknown) => {
-        // 包装成 Electrobun message packet，bun 端 defineRPC 注册了 "rpc-message" handler
-        const electrobunPacket = {
-          type: "message",
-          id: "rpc-message",
-          payload: JSON.stringify(message),
-        };
-        bridge.postMessage(JSON.stringify(electrobunPacket));
-      };
-    }
-  }
-
-  getTransport(): "ipc" | "websocket" {
-    return this._transport;
-  }
-
-  /** Web 端 HTTP 基础 URL（如 http://localhost:3100），桌面端返回 null */
-  getBaseUrl(): string | null {
-    return this._baseUrl;
-  }
-
-  /** 获取当前 auth token（用于需要直接调 HTTP 的场景） */
-  getAuthToken(): string {
-    return AUTH_TOKEN;
-  }
-
-  async call<K extends keyof RPCMethods>(
-    method: K,
-    params: MethodParams<RPCMethods, K>
-  ): Promise<MethodResult<RPCMethods, K>> {
-    const methodStr = method as string;
-    const ttl = CACHEABLE_METHODS[methodStr];
-    if (ttl !== undefined) {
-      const cached = rpcCache.get<MethodResult<RPCMethods, K>>(methodStr, params, ttl);
-      if (cached !== null) return cached;
-    }
-
-    await this.initialize();
-    const result = await this.client!.call(method, params);
-
-    if (ttl !== undefined) {
-      rpcCache.set(methodStr, params, result);
-    }
-
-    return result;
-  }
-
-  async subscribe<K extends keyof RPCEvents>(
-    eventType: K,
-    handler: (payload: EventPayload<RPCEvents[K]>, metadata: EventMetadata<RPCEvents[K]>) => void,
-    filter?: Record<string, unknown>
-  ): Promise<string> {
-    await this.initialize();
-    return this.client!.subscribe(eventType, handler, filter);
-  }
-
-  unsubscribe(subscriptionId: string): void {
-    this.client?.unsubscribe(subscriptionId);
-  }
-
-  isConnected(): boolean {
-    return this.client !== null;
-  }
-
-  close(): void {
-    this.client?.close();
-  }
+	private client: TypedClient<RPCMethods, RPCEvents> | null = null;
+	private initPromise: Promise<void> | null = null;
+	private _transport: "ipc" | "websocket" = "websocket";
+	private _baseUrl: string | null = null;
+	private wsTransport: WebSocketTransport | null = null;
+
+	/**
+	 * 桌面端同步初始化：通过 executeJavascript 接收 + __electrobunBunBridge 发送
+	 */
+	initSyncForDesktop(): void {
+		if (this.client) return;
+
+		const ipcTransport = new IPCTransport();
+		this._transport = "ipc";
+		this._baseUrl = null; // 桌面端不走 HTTP
+		this.client = createTypedClient<RPCMethods, RPCEvents>(ipcTransport);
+		this.setupElectrobunBridge(ipcTransport);
+		if (import.meta.env.DEV) {
+			console.warn("[APIClient] Desktop (IPC) initialized synchronously");
+		}
+	}
+
+	/**
+	 * 异步初始化：Web 端使用（连接 WebSocket）
+	 */
+	async initialize(): Promise<void> {
+		// 已连接且 transport 正常 → 直接返回
+		if (this.client && (this._transport === "ipc" || this.wsTransport?.isConnected())) {
+			return;
+		}
+
+		// client 存在但 WS 断开了 → 清理后重连
+		if (this.client && this.wsTransport && !this.wsTransport.isConnected()) {
+			this.wsTransport.close();
+			this.wsTransport = null;
+			this.client = null;
+			this.initPromise = null;
+		}
+
+		if (this.initPromise) return this.initPromise;
+
+		this.initPromise = (async () => {
+			const env = this.detectEnvironment();
+
+			if (env === "electrobun") {
+				// 不应走到这里，桌面端应通过 initSyncForDesktop() 初始化
+				this.initSyncForDesktop();
+			} else {
+				this._transport = "websocket";
+				const wsUrl = this.getWebSocketUrl();
+				this.wsTransport = new WebSocketTransport({
+					url: wsUrl,
+					authToken: AUTH_TOKEN,
+					reconnect: true,
+				});
+				await this.wsTransport.connect();
+				this.client = createTypedClient<RPCMethods, RPCEvents>(this.wsTransport);
+
+				const wsUrlObj = new URL(wsUrl);
+				this._baseUrl = `http://${wsUrlObj.host}`;
+			}
+		})();
+
+		return this.initPromise;
+	}
+
+	private detectEnvironment(): "electrobun" | "browser" {
+		if (typeof window === "undefined") return "browser";
+		if (window.__electrobunBunBridge) return "electrobun";
+		return "browser";
+	}
+
+	private getWebSocketUrl(): string {
+		if (typeof window === "undefined") return `ws://localhost:3100?token=${AUTH_TOKEN}`;
+		const customUrl =
+			new URLSearchParams(window.location.search).get("ws") ||
+			localStorage.getItem("rpc-websocket-url");
+		if (customUrl)
+			return customUrl.includes("token=") ? customUrl : `${customUrl}?token=${AUTH_TOKEN}`;
+		return `ws://${window.location.host}/ws?token=${AUTH_TOKEN}`;
+	}
+
+	/**
+	 * 桌面端 IPC 桥接：
+	 * - Bun → Browser: 通过 executeJavascript 调用 window.__piAgentIPC()
+	 * - Browser → Bun: 通过 __electrobunBunBridge.postMessage 发送 Electrobun 消息格式
+	 */
+	private setupElectrobunBridge(ipcTransport: IPCTransport): void {
+		if (typeof window === "undefined") return;
+
+		const win = window;
+
+		// 1. 注册接收函数：Bun 通过 executeJavascript 调用此函数发送消息到 Browser
+		win.__piAgentIPC = (msg: unknown) => {
+			ipcTransport.simulateMessage(msg);
+		};
+
+		// 2. 覆写 send：将 RPC-core 消息包装成 Electrobun 消息格式，通过原生桥接发送
+		const bridge = win.__electrobunBunBridge;
+
+		if (bridge) {
+			ipcTransport.send = async (message: unknown) => {
+				// 包装成 Electrobun message packet，bun 端 defineRPC 注册了 "rpc-message" handler
+				const electrobunPacket = {
+					type: "message",
+					id: "rpc-message",
+					payload: JSON.stringify(message),
+				};
+				bridge.postMessage(JSON.stringify(electrobunPacket));
+			};
+		}
+	}
+
+	getTransport(): "ipc" | "websocket" {
+		return this._transport;
+	}
+
+	/** Web 端 HTTP 基础 URL（如 http://localhost:3100），桌面端返回 null */
+	getBaseUrl(): string | null {
+		return this._baseUrl;
+	}
+
+	/** 获取当前 auth token（用于需要直接调 HTTP 的场景） */
+	getAuthToken(): string {
+		return AUTH_TOKEN;
+	}
+
+	async call<K extends keyof RPCMethods>(
+		method: K,
+		params: MethodParams<RPCMethods, K>
+	): Promise<MethodResult<RPCMethods, K>> {
+		const methodStr = method as string;
+		const ttl = CACHEABLE_METHODS[methodStr];
+		if (ttl !== undefined) {
+			const cached = rpcCache.get<MethodResult<RPCMethods, K>>(methodStr, params, ttl);
+			if (cached !== null) return cached;
+		}
+
+		await this.initialize();
+		const result = await this.client!.call(method, params);
+
+		if (ttl !== undefined) {
+			rpcCache.set(methodStr, params, result);
+		}
+
+		return result;
+	}
+
+	async subscribe<K extends keyof RPCEvents>(
+		eventType: K,
+		handler: (payload: EventPayload<RPCEvents[K]>, metadata: EventMetadata<RPCEvents[K]>) => void,
+		filter?: Record<string, unknown>
+	): Promise<string> {
+		await this.initialize();
+		return this.client!.subscribe(eventType, handler, filter);
+	}
+
+	unsubscribe(subscriptionId: string): void {
+		this.client?.unsubscribe(subscriptionId);
+	}
+
+	isConnected(): boolean {
+		return this.client !== null;
+	}
+
+	close(): void {
+		this.client?.close();
+	}
 }
 
 export const apiClient = new APIClientImpl();

package/templates/agent/src/server-config.ts

@@ -3,41 +3,43 @@
  * Values are read from environment variables with sensible defaults.
  */
 
+import { randomUUID } from "crypto";
+
+if (process.env.NODE_ENV === "production" && !process.env.AUTH_TOKEN) {
+	throw new Error(
+		"[FATAL] AUTH_TOKEN environment variable must be set in production mode. " +
+			"Example: AUTH_TOKEN=$(openssl rand -hex 32) bun src/server.ts"
+	);
+}
+
 export function parseEnvInt(
-  key: string,
-  value: string | undefined,
-  defaultValue: number,
-  min: number,
-  max: number,
+	key: string,
+	value: string | undefined,
+	defaultValue: number,
+	min: number,
+	max: number
 ): number {
-  if (value === undefined || value === "") return defaultValue;
-  const parsed = parseInt(value, 10);
-  if (isNaN(parsed) || parsed < min || parsed > max) {
-    console.warn(
-      `[config] Invalid ${key}: "${value}", using default: ${defaultValue}`,
-    );
-    return defaultValue;
-  }
-  return parsed;
+	if (value === undefined || value === "") return defaultValue;
+	const parsed = parseInt(value, 10);
+	if (isNaN(parsed) || parsed < min || parsed > max) {
+		console.warn(`[config] Invalid ${key}: "${value}", using default: ${defaultValue}`);
+		return defaultValue;
+	}
+	return parsed;
 }
 
 export const config = {
-  port: parseEnvInt("PORT", process.env.PORT, 3100, 1024, 65535),
-  authToken: process.env.AUTH_TOKEN || "pi-agent-template-token",
-  maxUploadSize: parseEnvInt(
-    "MAX_UPLOAD_SIZE",
-    process.env.MAX_UPLOAD_SIZE,
-    50 * 1024 * 1024,
-    0,
-    1024 * 1024 * 1024,
-  ),
-  logDir: process.env.LOG_DIR || "logs",
-  enableBash: process.env.ENABLE_BASH !== "false",
-  corsOrigin: process.env.CORS_ORIGIN || "http://localhost:5173",
+	port: parseEnvInt("PORT", process.env.PORT, 3100, 1024, 65535),
+	authToken: process.env.AUTH_TOKEN || `dev-${randomUUID()}`,
+	maxUploadSize: parseEnvInt(
+		"MAX_UPLOAD_SIZE",
+		process.env.MAX_UPLOAD_SIZE,
+		50 * 1024 * 1024,
+		0,
+		1024 * 1024 * 1024
+	),
+	logDir: process.env.LOG_DIR || "logs",
+	enableBash: process.env.ENABLE_BASH !== "false",
+	enableWebService: process.env.ENABLE_WEB_SERVICE === "true",
+	corsOrigin: process.env.CORS_ORIGIN || "http://localhost:5173",
 } as const;
-
-if (process.env.NODE_ENV === "production" && !process.env.AUTH_TOKEN) {
-  console.warn(
-    "[security] WARNING: Using default AUTH_TOKEN in production. Set AUTH_TOKEN environment variable.",
-  );
-}

package/templates/agent/src/server.ts

@@ -4,12 +4,10 @@
  * 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 +20,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); });
+process.on("SIGINT", () => {
+	cleanupPortFile();
+	process.exit(0);
+});
+process.on("SIGTERM", () => {
+	cleanupPortFile();
+	process.exit(0);
+});
 
-const httpServer = createServer();
-const wss = createWsHandler(httpServer, { config });
+async function start() {
+	const { port, close } = await createWebServer({
+		port: config.port,
+		authToken: config.authToken,
+		maxUploadSize: config.maxUploadSize,
+		corsOrigin: config.corsOrigin,
+	});
 
-httpServer.on("request", createHttpHandler({
-  config,
-  getWebSocketClientCount: () => wss.clients.size,
-}));
+	process.on("SIGINT", () => {
+		close();
+		cleanupPortFile();
+		process.exit(0);
+	});
+	process.on("SIGTERM", () => {
+		close();
+		cleanupPortFile();
+		process.exit(0);
+	});
 
-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);
-  });
-}
+	writePortFile(port);
+	registerPort(PROJECT_ROOT, port, PROJECT_NAME);
 
-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`);
-}
-
-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);
 });