@dyyz1993/create-agent 2.1.0 → 2.1.2

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

@@ -0,0 +1,384 @@
+/**
+ * Agent — 基于 pi SDK RpcClient 的浏览器自动化 Agent
+ *
+ * 架构（对应 PRD §6）：
+ *   RpcClient（子进程 pi --mode rpc）
+ *     ├── onEvent()     → 流式事件推送
+ *     ├── getMessages() → 完整历史消息（JSONL 持久化）
+ *     ├── promptAndWait() → 发送消息触发 Agent 循环
+ *     └── setActiveTools() → 激活浏览器工具
+ *
+ *   每次 prompt 前注入 <browser-context> XML + 选中的插件提示
+ */
+
+import { RpcClient } from "@dyyz1993/pi-coding-agent";
+import { spawn } from "child_process";
+
+const XBROWSER_CMD = "/usr/local/bin/xbrowser";
+const CDP_ENDPOINT = process.env.CDP_ENDPOINT || "http://localhost:9221";
+
+/** Agent 轮次上限 */
+const MAX_TURNS = Math.max(1, parseInt(process.env.AGENT_MAX_TURNS || "30", 10));
+export const MAX_TURNS_CONFIG = MAX_TURNS;
+
+/** Agent 整体超时 */
+const AGENT_TIMEOUT_MS = Math.max(
+	30_000,
+	parseInt(process.env.AGENT_TIMEOUT_MS || String(5 * 60 * 1000), 10),
+);
+
+// ===== xbrowser 命令执行 =====
+
+export async function execXbrowser(args: string[]): Promise<any> {
+	const allArgs = [...args, "--cdp", CDP_ENDPOINT, "--json"];
+	return new Promise((resolve, reject) => {
+		const child = spawn(XBROWSER_CMD, allArgs, {
+			stdio: ["ignore", "pipe", "pipe"],
+			env: { ...process.env, NODE_OPTIONS: "" },
+		});
+		const chunks: Buffer[] = [];
+		child.stdout.on("data", (d: Buffer) => chunks.push(d));
+		const timeout = setTimeout(() => {
+			child.kill("SIGTERM");
+			reject(new Error("timeout"));
+		}, 60000);
+		child.on("error", (e) => {
+			clearTimeout(timeout);
+			reject(e);
+		});
+		child.on("close", () => {
+			clearTimeout(timeout);
+			const out = Buffer.concat(chunks as any).toString("utf8");
+			const m = out.match(/\{[\s\S]*\}/);
+			try {
+				resolve(m ? JSON.parse(m[0]) : { success: false });
+			} catch {
+				resolve({ success: false });
+			}
+		});
+	});
+}
+
+/**
+ * 带自定义超时的 xbrowser 执行。
+ * 用于 record start 这类后台命令——超时后不杀进程（keepAlive=true），
+ * 因为录制命令需要持续运行。
+ */
+export async function execXbrowserTimed(
+	args: string[],
+	timeoutMs: number,
+	keepAlive = false,
+): Promise<any> {
+	const allArgs = [...args, "--cdp", CDP_ENDPOINT, "--json"];
+	return new Promise((resolve, reject) => {
+		const child = spawn(XBROWSER_CMD, allArgs, {
+			stdio: ["ignore", "pipe", "pipe"],
+			env: { ...process.env, NODE_OPTIONS: "" },
+		});
+		const chunks: Buffer[] = [];
+		let resolved = false;
+
+		child.stdout.on("data", (d: Buffer) => chunks.push(d));
+
+		const timer = setTimeout(() => {
+			if (resolved) return;
+			resolved = true;
+			if (!keepAlive) child.kill("SIGTERM");
+			// 超时：如果有输出就解析返回，否则 reject
+			const out = Buffer.concat(chunks as any).toString("utf8").trim();
+			if (out) {
+				const m = out.match(/\{[\s\S]*\}/);
+				try {
+					resolve(m ? JSON.parse(m[0]) : { success: true, timeout: true });
+				} catch {
+					resolve({ success: true, timeout: true });
+				}
+			} else {
+				resolve({ success: true, timeout: true });
+			}
+		}, timeoutMs);
+
+		child.on("error", (e) => {
+			if (resolved) return;
+			resolved = true;
+			clearTimeout(timer);
+			reject(e);
+		});
+
+		child.on("close", () => {
+			if (resolved) return;
+			resolved = true;
+			clearTimeout(timer);
+			const out = Buffer.concat(chunks as any).toString("utf8");
+			const m = out.match(/\{[\s\S]*\}/);
+			try {
+				resolve(m ? JSON.parse(m[0]) : { success: false });
+			} catch {
+				resolve({ success: false });
+			}
+		});
+	});
+}
+
+// ===== 浏览器上下文注入 =====
+
+async function getBrowserContext(): Promise<string> {
+	try {
+		const tabsResult = await execXbrowser(["tab", "list"]);
+		const tabs = tabsResult?.data?.tabs || [];
+		const activeIndex = tabsResult?.data?.activeIndex ?? 0;
+
+		let currentUrl = "";
+		let currentTitle = "";
+		try {
+			currentUrl =
+				(await execXbrowser(["eval", "location.href"]))?.data?.result || "";
+		} catch {}
+		try {
+			currentTitle =
+				(await execXbrowser(["eval", "document.title"]))?.data?.result || "";
+		} catch {}
+
+		const tabLines = tabs
+			.map((t: any, i: number) => {
+				const url = t.url || (i === activeIndex ? currentUrl : "");
+				if (!url || url === "about:blank") return null;
+				const title = t.title || (i === activeIndex ? currentTitle : "");
+				const marker = i === activeIndex ? ' current="true"' : "";
+				return `    <tab index="${i}" url="${url}" title="${title}"${marker} />`;
+			})
+			.filter(Boolean)
+			.join("\n");
+
+		return `<browser-context>
+  <tabs total="${tabs.length}" active="${activeIndex}">
+${tabLines || "    (无标签页)"}
+  </tabs>
+  <current_page url="${currentUrl}" title="${currentTitle}" />
+</browser-context>`;
+	} catch {
+		return `<browser-context><error>无法获取浏览器状态</error></browser-context>`;
+	}
+}
+
+// ===== RPC Client 管理（每个 sessionId 一个独立持久化 session） =====
+
+const _clients = new Map<string, RpcClient>();
+
+export async function getClient(sessionId: string): Promise<RpcClient | null> {
+	if (_clients.has(sessionId)) return _clients.get(sessionId)!;
+
+	try {
+		const client = new RpcClient({
+			cliPath: "node_modules/.bin/pi",
+			args: ["--mode", "rpc"],
+		});
+
+		await client.start();
+
+		try {
+			await client.newSession(`browser-agent-${sessionId}`);
+			console.log(`[Agent] New persistent session for ${sessionId}`);
+		} catch (e: any) {
+			console.log("[Agent] newSession warning:", e.message);
+		}
+
+		await client.setActiveTools([
+			"xbrowser",
+			"web_search",
+			"fetch_content",
+			"todo",
+		]);
+
+		_clients.set(sessionId, client);
+		return client;
+	} catch (e: any) {
+		console.error("[Agent] RPC client init failed:", e.message);
+		return null;
+	}
+}
+
+/** 清理 Agent session */
+export function disposeAgentSession(sessionId: string): void {
+	const client = _clients.get(sessionId);
+	if (client) {
+		try {
+			client.stop();
+		} catch {}
+		_clients.delete(sessionId);
+	}
+}
+
+/** 获取 Agent session 的完整历史消息 */
+export async function getAgentMessages(sessionId: string): Promise<any[]> {
+	const client = _clients.get(sessionId);
+	if (!client) return [];
+	try {
+		return (await client.getMessages()) || [];
+	} catch {
+		return [];
+	}
+}
+
+// ===== Agent 事件类型 =====
+
+export interface AgentEvent {
+	type: string;
+	text?: string;
+	thinking?: string;
+	toolName?: string;
+	toolInput?: string;
+	toolOutput?: string;
+	toolCallId?: string;
+	turn?: number;
+}
+
+export interface AgentReply {
+	text: string;
+	steps?: { tool: string; input: string; output: string }[];
+	usedScrape?: boolean;
+	messages?: any[];
+}
+
+/**
+ * Agent 对话入口
+ * @param message 用户消息
+ * @param sessionId 会话 ID
+ * @param onEvent 实时事件回调
+ * @param activePlugins 选中插件列表
+ */
+export async function agentChat(
+	message: string,
+	sessionId: string,
+	onEvent?: (event: AgentEvent) => void,
+	activePlugins?: string[],
+): Promise<AgentReply> {
+	const client = await getClient(sessionId);
+	if (!client) {
+		return { text: "Agent 初始化失败" };
+	}
+
+	// 注入浏览器上下文 + 选中插件提示
+	const browserContext = await getBrowserContext();
+	let pluginHint = "";
+	if (activePlugins && activePlugins.length > 0) {
+		// 把工具 ID 映射成 Agent 能理解的描述
+		const toolDescs: Record<string, string> = {
+			scrape: "采集当前页面内容转 Markdown（xbrowser scrape）",
+			crawl: "批量爬取网站多个页面（xbrowser crawl）",
+			map: "发现网站所有 URL 结构（xbrowser map）",
+			screenshot: "截取当前页面（xbrowser screenshot）",
+			search: "搜索引擎搜索关键词（xbrowser search）",
+			"scrape-xhs": "采集小红书笔记（scrapeXhs 专用流程）",
+			xiaohongshu: "采集小红书内容（xiaohongshu 插件）",
+		};
+		const toolList = activePlugins.map((p) => {
+			const desc = toolDescs[p];
+			return desc ? `  - ${p}: ${desc}` : `  - ${p}`;
+		}).join("\n");
+		pluginHint = `\n<active-plugins>\n  用户选择了以下工具/插件，请优先使用它们完成任务。根据用户的需求自动编排执行顺序：\n${toolList}\n</active-plugins>`;
+	}
+	const fullMessage = `${browserContext}${pluginHint}\n\n用户请求: ${message}`;
+
+	const steps: { tool: string; input: string; output: string }[] = [];
+	let fullText = "";
+	let usedScrape = false;
+	let turnCount = 0;
+	let hitTurnLimit = false;
+
+	const unsub = client.onEvent((event: any) => {
+		// 工具开始
+		if (event.type === "tool_execution_start") {
+			const toolName = event.toolName || "";
+			const args = event.args || event.input || event.arguments || {};
+			if (toolName === "xbrowser") {
+				const inputStr = JSON.stringify(args).toLowerCase();
+				if (inputStr.includes("scrape") || inputStr.includes("crawl"))
+					usedScrape = true;
+			}
+			const input = JSON.stringify(args).slice(0, 300);
+			steps.push({ tool: toolName, input, output: "" });
+			onEvent?.({
+				type: "tool_call",
+				toolName,
+				toolInput: input,
+				toolCallId: event.toolCallId,
+			});
+		}
+		// 工具结束
+		if (event.type === "tool_execution_end") {
+			const last = steps[steps.length - 1];
+			const output = (
+				event.result?.content?.[0]?.text || event.text || ""
+			).slice(0, 300);
+			if (last) last.output = output;
+			onEvent?.({
+				type: "tool_result",
+				toolName: last?.tool || event.toolName,
+				toolOutput: output,
+				toolCallId: event.toolCallId,
+			});
+		}
+		// turn 结束
+		if (event.type === "turn_end") {
+			turnCount++;
+			if (turnCount >= MAX_TURNS && !hitTurnLimit) {
+				hitTurnLimit = true;
+				try {
+					client.abort();
+				} catch {}
+			}
+			onEvent?.({ type: "turn", turn: turnCount });
+		}
+		// 消息更新
+		if (event.type === "message_update") {
+			const ae = event.assistantMessageEvent;
+			if (ae?.type === "text_delta" && ae.delta) {
+				fullText += ae.delta;
+				onEvent?.({ type: "text", text: ae.delta });
+			} else if (ae?.type === "thinking_delta" && ae.delta) {
+				onEvent?.({ type: "thinking", text: ae.delta });
+			}
+		}
+	});
+
+	let timedOut = false;
+	const timer = setTimeout(() => {
+		timedOut = true;
+		try {
+			client.abort();
+		} catch {}
+	}, AGENT_TIMEOUT_MS);
+
+	try {
+		await client.promptAndWait(fullMessage, undefined, AGENT_TIMEOUT_MS);
+	} catch (e: any) {
+		if (!fullText && !timedOut && !hitTurnLimit)
+			fullText = "⚠️ " + e.message;
+	} finally {
+		clearTimeout(timer);
+	}
+
+	// 轮次上限总结
+	if (hitTurnLimit) {
+		const summaryPrompt = `已达到工具调用轮次上限（${MAX_TURNS} 轮）。请根据以上操作历史，用简短要点总结：\n1. 已经完成了什么；\n2. 当前卡在哪一步；\n3. 如果用户想继续，下一步该做什么。\n不要再调用任何工具，直接给出总结。`;
+		try {
+			await client.promptAndWait(summaryPrompt, undefined, 60_000);
+		} catch {}
+		fullText += `\n\n_(已达轮次上限 ${MAX_TURNS}，以上为进展总结)_`;
+	}
+
+	if (typeof unsub === "function") unsub();
+
+	let messages: any[] = [];
+	try {
+		messages = (await client.getMessages()) || [];
+	} catch {}
+
+	return {
+		text: fullText.trim() || "(无回复)",
+		steps: steps.length > 0 ? steps : undefined,
+		usedScrape,
+		messages,
+	};
+}