@dyyz1993/create-agent 2.1.0 → 2.1.2

package/templates/cowork/src/shared/lib/__tests__/web-server.test.ts

@@ -0,0 +1,203 @@
+import { describe, it, expect, afterEach } from "vitest";
+import http from "http";
+import {
+	createWebServer,
+	getLocalIP,
+	findAvailablePort,
+	type WebServerResult,
+} from "../web-server";
+
+function httpGet(url: string, headers?: Record<string, string>): Promise<{ status: number; body: string }> {
+	return new Promise((resolve, reject) => {
+		const req = http.get(url, { headers }, (res) => {
+			let data = "";
+			res.on("data", (chunk) => {
+				data += chunk;
+			});
+			res.on("end", () => resolve({ status: res.statusCode ?? 0, body: data }));
+		});
+		req.on("error", reject);
+	});
+}
+
+describe("createWebServer 工厂函数", () => {
+	let webServer: WebServerResult | null = null;
+
+	afterEach(async () => {
+		if (webServer) {
+			await webServer.close();
+			webServer = null;
+		}
+	});
+
+	it("应返回 httpServer + sse + port + authToken", async () => {
+		webServer = await createWebServer({
+			port: 0,
+			authToken: "test-token-001",
+			maxUploadSize: 1024,
+			corsOrigin: "*",
+		});
+
+		expect(webServer.httpServer).toBeDefined();
+		expect(webServer.sse).toBeDefined();
+		expect(webServer.port).toBeGreaterThan(0);
+		expect(webServer.authToken).toBe("test-token-001");
+		expect(typeof webServer.close).toBe("function");
+	});
+
+	it("应启动 HTTP 服务并监听指定端口", async () => {
+		const testServer = http.createServer();
+		const port = await new Promise<number>((resolve) => {
+			testServer.listen(0, () => {
+				const addr = testServer.address();
+				resolve(typeof addr === "object" && addr ? addr.port : 3100);
+			});
+		});
+		await new Promise<void>((resolve) => testServer.close(() => resolve()));
+
+		webServer = await createWebServer({
+			port,
+			authToken: "test-token-002",
+			maxUploadSize: 1024,
+			corsOrigin: "*",
+		});
+
+		expect(webServer.port).toBe(port);
+
+		const { status, body } = await httpGet(`http://localhost:${webServer.port}/health`);
+		expect(status).toBe(200);
+		const json = JSON.parse(body);
+		expect(json.status).toBe("ok");
+	});
+
+	it("端口冲突时应自动递增到可用端口", async () => {
+		const blocker = http.createServer();
+		const blockerPort = await new Promise<number>((resolve) => {
+			blocker.listen(0, () => {
+				const addr = blocker.address();
+				resolve(typeof addr === "object" && addr ? addr.port : 3100);
+			});
+		});
+
+		webServer = await createWebServer({
+			port: blockerPort,
+			authToken: "test-token-003",
+			maxUploadSize: 1024,
+			corsOrigin: "*",
+		});
+
+		expect(webServer.port).not.toBe(blockerPort);
+		expect(webServer.port).toBeGreaterThan(blockerPort);
+
+		await new Promise<void>((resolve) => blocker.close(() => resolve()));
+	});
+
+	it("SSE 连接需要 token 才能访问 /api/events", async () => {
+		webServer = await createWebServer({
+			port: 0,
+			authToken: "test-token-004",
+			maxUploadSize: 1024,
+			corsOrigin: "*",
+		});
+
+		// 无 token → 401
+		const { status } = await httpGet(`http://localhost:${webServer.port}/api/events`);
+		expect(status).toBe(401);
+	});
+
+	it("带 token 的 SSE 连接应返回 200 + text/event-stream", async () => {
+		webServer = await createWebServer({
+			port: 0,
+			authToken: "test-token-005",
+			maxUploadSize: 1024,
+			corsOrigin: "*",
+		});
+
+		// SSE is a long-lived stream — read just enough to verify headers + ready event
+		const result = await new Promise<{ status: number; headers: Record<string, string>; body: string }>((resolve, reject) => {
+			const req = http.get(
+				`http://localhost:${webServer!.port}/api/events?token=${webServer!.authToken}`,
+				(res) => {
+					let body = "";
+					const timer = setTimeout(() => {
+						req.destroy();
+						resolve({ status: res.statusCode ?? 0, headers: res.headers as Record<string, string>, body });
+					}, 300);
+					res.on("data", (chunk) => {
+						body += chunk;
+						// Once we have the ready event, we can close
+						if (body.includes("event: ready")) {
+							clearTimeout(timer);
+							req.destroy();
+							resolve({ status: res.statusCode ?? 0, headers: res.headers as Record<string, string>, body });
+						}
+					});
+				}
+			);
+			req.on("error", (err) => {
+				if (!err.message.includes("aborted")) reject(err);
+			});
+		});
+
+		expect(result.status).toBe(200);
+		expect(result.body).toContain("event: ready");
+	});
+
+	it("HTTP 请求需要 token 才能访问文件路由", async () => {
+		webServer = await createWebServer({
+			port: 0,
+			authToken: "test-token-006",
+			maxUploadSize: 1024,
+			corsOrigin: "*",
+		});
+
+		const { status } = await httpGet(`http://localhost:${webServer.port}/info/some/path`);
+		expect(status).toBe(401);
+	});
+
+	it("health 端点不需要 token", async () => {
+		webServer = await createWebServer({
+			port: 0,
+			authToken: "test-token-007",
+			maxUploadSize: 1024,
+			corsOrigin: "*",
+		});
+
+		const { status, body } = await httpGet(`http://localhost:${webServer.port}/health`);
+		expect(status).toBe(200);
+		const json = JSON.parse(body);
+		expect(json).toHaveProperty("status", "ok");
+		expect(json).toHaveProperty("clients");
+	});
+
+	it("关闭 webServer 应停止 HTTP 服务", async () => {
+		webServer = await createWebServer({
+			port: 0,
+			authToken: "test-token-008",
+			maxUploadSize: 1024,
+			corsOrigin: "*",
+		});
+
+		const port = webServer.port;
+		await webServer.close();
+		webServer = null;
+
+		await expect(httpGet(`http://localhost:${port}/health`)).rejects.toThrow();
+	});
+});
+
+describe("getLocalIP", () => {
+	it("应返回非空字符串", () => {
+		const ip = getLocalIP();
+		expect(typeof ip).toBe("string");
+		expect(ip.length).toBeGreaterThan(0);
+		expect(ip).toMatch(/^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/);
+	});
+});
+
+describe("findAvailablePort", () => {
+	it("应返回一个可用端口", async () => {
+		const port = await findAvailablePort(40000);
+		expect(port).toBeGreaterThanOrEqual(40000);
+	});
+});

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

@@ -0,0 +1,152 @@
+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"
+	| "web-server";
+type LogLevel = "debug" | "info" | "warn" | "error";
+
+interface LogEntry {
+	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);
+}
+
+function getLogDir(): string {
+	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 */
+	}
+}
+
+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;
+}
+
+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 */
+		}
+	});
+}
+
+export function flushLogs(): Promise<void> {
+	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);
+		}
+	}
+}
+
+export function createLogger(module: LogModule): Logger {
+	return new Logger(module);
+}

package/templates/cowork/src/shared/lib/path-security.ts

@@ -0,0 +1,38 @@
+import { resolve } from "path";
+
+let allowedRoots: string[] = [process.cwd()];
+
+export function setAllowedRoots(roots: string[]): void {
+  allowedRoots = roots.map((r) => resolve(r));
+}
+
+export function isRpcPathAllowed(requestedPath: string): boolean {
+  try {
+    if (requestedPath.includes("\0")) return false;
+
+    const decoded = decodeURIComponent(requestedPath);
+    const resolved = resolve(decoded);
+    return allowedRoots.some(
+      (root) => resolved === root || resolved.startsWith(root + "/")
+    );
+  } catch {
+    return false;
+  }
+}
+
+export function validatePath(requestedPath: string): string {
+  if (requestedPath.includes("\0")) {
+    throw new Error(`Access denied: path contains null bytes`);
+  }
+
+  const decoded = decodeURIComponent(requestedPath);
+  const resolved = resolve(decoded);
+
+  if (!isRpcPathAllowed(resolved)) {
+    throw new Error(
+      `Access denied: path "${requestedPath}" is outside allowed roots`
+    );
+  }
+
+  return resolved;
+}

package/templates/cowork/src/shared/lib/port-registry.ts

@@ -0,0 +1,103 @@
+/**
+ * Global port registry — tracks all running pi-agent instances.
+ *
+ * File: ~/.pi-agent/ports.json
+ *
+ * Format:
+ * {
+ *   "/absolute/project/path": {
+ *     "port": 3101,
+ *     "pid": 12345,
+ *     "startedAt": "2026-04-29T08:00:00.000Z",
+ *     "name": "my-project"
+ *   }
+ * }
+ */
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join, basename } from "path";
+import { homedir } from "os";
+
+const REGISTRY_DIR = join(homedir(), ".pi-agent");
+const REGISTRY_FILE = join(REGISTRY_DIR, "ports.json");
+
+export interface PortEntry {
+  port: number;
+  pid: number;
+  startedAt: string;
+  name: string;
+}
+
+export type PortRegistry = Record<string, PortEntry>;
+
+function ensureDir() {
+  if (!existsSync(REGISTRY_DIR)) {
+    mkdirSync(REGISTRY_DIR, { recursive: true });
+  }
+}
+
+export function readRegistry(): PortRegistry {
+  try {
+    if (!existsSync(REGISTRY_FILE)) return {};
+    return JSON.parse(readFileSync(REGISTRY_FILE, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+
+function writeRegistry(registry: PortRegistry): void {
+  ensureDir();
+  writeFileSync(REGISTRY_FILE, JSON.stringify(registry, null, 2), "utf-8");
+}
+
+export function registerPort(projectPath: string, port: number, name: string): void {
+  const registry = readRegistry();
+  registry[projectPath] = {
+    port,
+    pid: process.pid,
+    startedAt: new Date().toISOString(),
+    name: name || basename(projectPath),
+  };
+  writeRegistry(registry);
+}
+
+export function unregisterPort(projectPath: string): void {
+  const registry = readRegistry();
+  delete registry[projectPath];
+  if (Object.keys(registry).length === 0) {
+    writeRegistry(registry);
+  } else {
+    writeRegistry(registry);
+  }
+}
+
+export function cleanupStaleEntries(): void {
+  const registry = readRegistry();
+  let changed = false;
+  for (const [path, entry] of Object.entries(registry)) {
+    try {
+      process.kill(entry.pid, 0);
+    } catch {
+      delete registry[path];
+      changed = true;
+    }
+  }
+  if (changed) writeRegistry(registry);
+}
+
+export function formatRegistryForOutput(): string {
+  cleanupStaleEntries();
+  const registry = readRegistry();
+  const entries = Object.entries(registry);
+  if (entries.length === 0) return "No active instances.";
+
+  const lines = entries.map(([path, entry]) => {
+    const uptime = Math.round((Date.now() - new Date(entry.startedAt).getTime()) / 1000);
+    const uptimeStr = uptime < 60 ? `${uptime}s` : uptime < 3600 ? `${Math.floor(uptime / 60)}m ${uptime % 60}s` : `${Math.floor(uptime / 3600)}h ${Math.floor((uptime % 3600) / 60)}m`;
+    return `  ${entry.name}  →  http://localhost:${entry.port}  (PID ${entry.pid}, up ${uptimeStr})\n  ${path}`;
+  });
+
+  return `Active pi-agent instances (${entries.length}):\n${lines.join("\n\n")}\n\nRegistry: ${REGISTRY_FILE}`;
+}
+
+export { REGISTRY_FILE };

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

@@ -0,0 +1,127 @@
+import { createServer, type Server } from "http";
+import { networkInterfaces } from "os";
+import { createHttpHandler } from "../http-routes";
+import { createSseHandler, type SseHandler } from "../../gateway/sse-transport";
+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;
+	sse: SseHandler;
+	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 sse = createSseHandler(httpServer, {
+		config: {
+			port,
+			authToken: config.authToken,
+			maxUploadSize: config.maxUploadSize,
+		},
+	});
+
+	httpServer.on(
+		"request",
+		createHttpHandler({
+			config: {
+				port,
+				authToken: config.authToken,
+				maxUploadSize: config.maxUploadSize,
+				corsOrigin: config.corsOrigin,
+			},
+			getSseClientCount: () => sse.clients.size,
+			sse,
+		})
+	);
+
+	return new Promise((resolve, reject) => {
+		httpServer.listen(port, () => {
+			log.info("Web server started", { port, corsOrigin: config.corsOrigin });
+
+			resolve({
+				httpServer,
+				sse,
+				port,
+				authToken: config.authToken,
+				close: () =>
+					new Promise<void>((res) => {
+						sse.close();
+						httpServer.close(() => res());
+					}),
+			});
+		});
+		httpServer.on("error", reject);
+	});
+}

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

@@ -0,0 +1,20 @@
+/**
+ * Chat 模块 — 聊天消息
+ */
+export interface ChatMethods {
+  "chat.list": {
+    params: { limit?: number; cursor?: string };
+    result: {
+      messages: { id: string; role: "user" | "assistant"; content: string; timestamp: number }[];
+      hasMore: boolean;
+    };
+  };
+  "chat.send": {
+    params: { content: string };
+    result: { ok: boolean };
+  };
+}
+
+export interface ChatEvents {
+  "chat.message": { id: string; role: "user" | "assistant"; content: string; timestamp: number };
+}

package/templates/cowork/src/shared/modules/context.ts

@@ -0,0 +1,32 @@
+/**
+ * Context 模块 — 上下文管理（文件夹 / 连接器 / 工作文件）
+ */
+
+export interface ContextFolder {
+	path: string;
+	name: string;
+}
+
+export interface Connector {
+	id: string;
+	name: string;
+	type: "web_search" | "api" | "database";
+	enabled: boolean;
+}
+
+export interface WorkingFile {
+	path: string;
+	name: string;
+	size?: number;
+}
+
+export interface ContextMethods {
+	"context.listFolders": { params: {}; result: { folders: ContextFolder[] } };
+	"context.addFolder": { params: { path: string }; result: { folder: ContextFolder } };
+	"context.removeFolder": { params: { path: string }; result: { ok: boolean } };
+	"context.listConnectors": { params: {}; result: { connectors: Connector[] } };
+	"context.toggleConnector": { params: { id: string; enabled: boolean }; result: { connector: Connector } };
+	"context.listWorkingFiles": { params: {}; result: { files: WorkingFile[] } };
+	"context.addWorkingFile": { params: { path: string }; result: { file: WorkingFile } };
+	"context.removeWorkingFile": { params: { path: string }; result: { ok: boolean } };
+}