@dyyz1993/create-agent 2.1.1 → 2.1.2

package/templates/browser-agent/src/shared/handlers/chat.ts

@@ -0,0 +1,213 @@
+import type { RPCServer } from '@dyyz1993/rpc-core';
+import type { MethodParams, MethodResult } from '@dyyz1993/rpc-core';
+import type { RPCMethods, HandlerOptions } from '../rpc-schema';
+import { readFile, writeFile, mkdir } from 'fs/promises';
+import { existsSync } from 'fs';
+import { join, dirname } from 'path';
+import { homedir } from 'os';
+import { createLogger } from '../lib/logger';
+
+const log = createLogger('chat');
+
+type Platform = 'desktop' | 'web';
+
+export function getStoragePathFor(platform: Platform): string {
+	const dir = join(homedir(), '.pi-agent');
+	if (platform === 'desktop') {
+		return join(dir, 'chat-history-desktop.json');
+	}
+	const sessionId = Date.now().toString(36) + '-' + Math.random().toString(36).slice(2, 8);
+	return join(dir, `chat-history-web-${sessionId}.json`);
+}
+
+type ChatMessage = { id: string; role: 'user' | 'assistant'; content: string; timestamp: number };
+
+function createMessageStore(filePath: string) {
+	async function load(): Promise<ChatMessage[]> {
+		try {
+			if (!existsSync(filePath)) {
+				log.info(`No history file at ${filePath}`);
+				return [];
+			}
+			const raw = await readFile(filePath, 'utf-8');
+			const msgs = JSON.parse(raw) as ChatMessage[];
+			log.info(`Loaded ${msgs.length} messages from ${filePath}`);
+			return msgs;
+		} catch (err) {
+			log.error('Failed to load history', { error: err });
+			return [];
+		}
+	}
+
+	async function save(messages: ChatMessage[]): Promise<void> {
+		const dir = dirname(filePath);
+		try {
+			if (!existsSync(dir)) {
+				await mkdir(dir, { recursive: true });
+			}
+			await writeFile(filePath, JSON.stringify(messages, null, 2), 'utf-8');
+			log.info(`Saved ${messages.length} messages to ${filePath}`);
+		} catch (err) {
+			log.error('Failed to save history', { error: err });
+		}
+	}
+
+	return { load, save };
+}
+
+type RegisterFn = <K extends keyof RPCMethods & string>(
+	method: K,
+	handler: (params: MethodParams<RPCMethods, K>) => Promise<MethodResult<RPCMethods, K>>,
+) => void;
+
+export function generateReply(input: string): string {
+	const lower = input.toLowerCase().trim();
+
+	if (/^(hi|hello|hey|howdy|hola|yo|sup)\b/i.test(lower)) {
+		const greetings = [
+			'Hey there! How can I help you today?',
+			'Hello! Great to see you. What would you like to know?',
+			"Hi! I'm your desktop assistant. Ask me anything!",
+		];
+		return greetings[Math.floor(Math.random() * greetings.length)]!;
+	}
+
+	if (
+		/what('?s| is) the (time|date|day)|current (time|date)|what time|today'?s date/i.test(lower)
+	) {
+		const now = new Date();
+		const date = now.toLocaleDateString('en-US', {
+			weekday: 'long',
+			year: 'numeric',
+			month: 'long',
+			day: 'numeric',
+		});
+		const time = now.toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit' });
+		return `It's currently **${time}** on **${date}**.`;
+	}
+
+	const mathMatch = lower.match(
+		/(?:what(?:'s| is)\s+)?(\d+(?:\.\d+)?)\s*([+\-*/x×÷^])\s*(\d+(?:\.\d+)?)/,
+	);
+	if (mathMatch) {
+		const a = parseFloat(mathMatch[1]!);
+		const op = mathMatch[2]!;
+		const b = parseFloat(mathMatch[3]!);
+		let result: number;
+		switch (op) {
+			case '+':
+				result = a + b;
+				break;
+			case '-':
+				result = a - b;
+				break;
+			case '*':
+			case 'x':
+			case '×':
+				result = a * b;
+				break;
+			case '/':
+			case '÷':
+				result = b !== 0 ? a / b : NaN;
+				break;
+			case '^':
+				result = Math.pow(a, b);
+				break;
+			default:
+				result = NaN;
+		}
+		if (isNaN(result)) {
+			return "Hmm, I couldn't calculate that. Did you try dividing by zero?";
+		}
+		const niceResult = Number.isInteger(result)
+			? result.toString()
+			: result.toFixed(4).replace(/0+$/, '').replace(/\.$/, '');
+		return `That would be **${niceResult}**! Need help with anything else?`;
+	}
+
+	if (/file|folder|directory|browse|explorer|open file|read file/i.test(lower)) {
+		return (
+			'To browse and manage files, use the **File Explorer** panel on the left sidebar. ' +
+			'You can navigate directories, preview files, and open them for editing. ' +
+			'Try typing a file path or asking me about a specific directory!'
+		);
+	}
+
+	if (/git|commit|branch|push|pull|merge|status|diff|log/i.test(lower)) {
+		return (
+			'The **Git Panel** gives you full source control right inside the app. ' +
+			'You can view changes, stage files, commit, switch branches, push/pull, and see the commit log. ' +
+			'Look for the source control icon in the sidebar to get started.'
+		);
+	}
+
+	if (/^(help|commands|what can you|what do you|capabilities|features)/i.test(lower)) {
+		return (
+			"Here's what I can help with:\n\n" +
+			"- **Greetings** - Say hi and I'll say hi back!\n" +
+			'- **Time & Date** - Ask "what time is it?" or "what\'s today\'s date?"\n' +
+			'- **Math** - Give me an expression like "12 * 8" or "what is 100 / 4"\n' +
+			"- **Files** - Ask about file browsing and I'll explain the File Explorer\n" +
+			"- **Git** - Ask about version control and I'll walk you through it\n" +
+			'- **Help** - Show this message anytime!\n\n' +
+			'This is a demo assistant - try different things to see what sticks!'
+		);
+	}
+
+	const defaults = [
+		"That's an interesting question! I'm a demo assistant, so my knowledge is limited - but try asking about **time**, **math**, **files**, or **git**.",
+		"I wish I could help with that! For now I can answer questions about time, do simple math, and explain the app's features. Type **help** to see what I can do.",
+		"Hmm, I'm not sure about that one. But I *can* do math, tell you the time, and explain features. Give it a shot!",
+	];
+	return defaults[Math.floor(Math.random() * defaults.length)]!;
+}
+
+export function register(server: RPCServer, options: HandlerOptions): void {
+	const storagePath = getStoragePathFor(options.platform);
+	const store = createMessageStore(storagePath);
+
+	const r: RegisterFn = (method, handler) => {
+		server.register(method, handler as (params: unknown) => Promise<unknown>);
+	};
+
+	r('chat.list', async (params) => {
+		const all = await store.load();
+		const limit = params.limit ?? 50;
+		const messages = all.slice(-limit);
+		return {
+			messages,
+			hasMore: all.length > limit,
+		};
+	});
+
+	r('chat.send', async (params) => {
+		const all = await store.load();
+
+		const userMsg: ChatMessage = {
+			id: `msg-${Date.now()}-user`,
+			role: 'user',
+			content: params.content,
+			timestamp: Date.now(),
+		};
+		all.push(userMsg);
+
+		server.emitEvent('chat.message', userMsg, { role: userMsg.role });
+
+		const thinkDelay = 200 + Math.floor(Math.random() * 300);
+		await new Promise((r) => setTimeout(r, thinkDelay));
+
+		const reply: ChatMessage = {
+			id: `msg-${Date.now()}-assistant`,
+			role: 'assistant',
+			content: generateReply(params.content),
+			timestamp: Date.now(),
+		};
+		all.push(reply);
+
+		server.emitEvent('chat.message', reply, { role: reply.role });
+
+		await store.save(all);
+
+		return { ok: true };
+	});
+}

package/templates/browser-agent/src/shared/handlers/file.ts

@@ -0,0 +1,99 @@
+import type { RPCServer } from "@dyyz1993/rpc-core";
+import type { MethodParams, MethodResult } from "@dyyz1993/rpc-core";
+import type { RPCMethods, HandlerOptions } from "../rpc-schema";
+import { readdir, stat, writeFile, readFile, mkdir, rename, rm, cp } from "fs/promises";
+import { existsSync } from "fs";
+import { join, dirname } from "path";
+import { createLogger } from "../lib/logger";
+import { validatePath } from "../lib/path-security";
+
+const log = createLogger("file");
+
+type RegisterFn = <K extends keyof RPCMethods & string>(
+  method: K,
+  handler: (params: MethodParams<RPCMethods, K>) => Promise<MethodResult<RPCMethods, K>>,
+) => void;
+
+export function register(server: RPCServer, _options: HandlerOptions): void {
+  const r: RegisterFn = (method, handler) => {
+    server.register(method, handler as (params: unknown) => Promise<unknown>);
+  };
+
+  r("file.findProjectRoot", async () => {
+    let dir = process.cwd();
+    for (let i = 0; i < 20; i++) {
+      if (existsSync(join(dir, "package.json"))) return { path: dir };
+      const parent = dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+    return { path: process.cwd() };
+  });
+
+  r("file.listDir", async (params) => {
+    const basePath = validatePath(params.path || process.cwd());
+    const entries: { name: string; path: string; type: "file" | "directory"; size?: number }[] = [];
+    try {
+      const files = await readdir(basePath);
+      for (const name of files) {
+        const fullPath = join(basePath, name);
+        try {
+          const s = await stat(fullPath);
+          entries.push({
+            name,
+            path: fullPath,
+            type: s.isDirectory() ? "directory" : "file",
+            size: s.size,
+          });
+        } catch {
+          entries.push({ name, path: fullPath, type: "file" });
+        }
+      }
+    } catch (err) {
+      log.error("listDir error", { error: err });
+    }
+    return { entries, basePath };
+  });
+
+  r("file.createFile", async (params) => {
+    const dirPath = validatePath(params.dirPath);
+    const filePath = join(dirPath, params.name);
+    await writeFile(filePath, "");
+    return { path: filePath };
+  });
+
+  r("file.createDir", async (params) => {
+    const dirPath = validatePath(params.dirPath);
+    const fullDirPath = join(dirPath, params.name);
+    await mkdir(fullDirPath, { recursive: true });
+    return { path: fullDirPath };
+  });
+
+  r("file.rename", async (params) => {
+    const oldPath = validatePath(params.oldPath);
+    const newPath = join(dirname(oldPath), params.newName);
+    await rename(oldPath, newPath);
+    return { newPath };
+  });
+
+  r("file.delete", async (params) => {
+    const safePath = validatePath(params.path);
+    await rm(safePath, { recursive: true, force: true });
+    return { ok: true };
+  });
+
+  r("file.copy", async (params) => {
+    const srcPath = validatePath(params.srcPath);
+    const destDir = validatePath(params.destDir);
+    const name = srcPath.split("/").pop() || srcPath;
+    const destPath = join(destDir, name);
+    await cp(srcPath, destPath, { recursive: true });
+    return { path: destPath };
+  });
+
+  r("file.readFile", async (params) => {
+    const filePath = validatePath(params.path);
+    const content = await readFile(filePath);
+    return { content: content.toString(), size: content.length };
+  });
+}

package/templates/browser-agent/src/shared/handlers/index.ts

@@ -0,0 +1,7 @@
+// Handler barrel — 新增模块在此加一行 export
+export { register as system } from "./system";
+export { register as file } from "./file";
+export { register as timer } from "./timer";
+export { register as chat } from "./chat";
+export { register as browser } from "./browser";
+export { register as session } from "./session";

package/templates/browser-agent/src/shared/handlers/session.ts

@@ -0,0 +1,167 @@
+/**
+ * Session Handler — 会话 CRUD、消息、资源管理
+ *
+ * 对应 PRD §8 数据模型
+ * 使用内存存储（符合 PRD §10.1 "会话不持久化" 已知问题，预留 SQLite 接口）
+ */
+
+import type { RPCServer } from "@dyyz1993/rpc-core";
+import type { MethodParams, MethodResult } from "@dyyz1993/rpc-core";
+import type { RPCMethods, HandlerOptions } from "../rpc-schema";
+
+// ===== 类型定义 =====
+
+type SessionStatus = "idle" | "running" | "done" | "error";
+
+interface Message {
+	id: string;
+	role: "user" | "agent";
+	text: string;
+	steps?: { label: string; status: string; detail?: string }[];
+	toolCalls?: { tool: string; input: string; output: string; status: string }[];
+	summary?: { noteCount: number; imageCount: number; successRate: string; durationMs: number };
+	error?: string;
+	at: number;
+}
+
+interface Asset {
+	id: string;
+	kind: string;
+	name: string;
+	size?: number;
+	mime: string;
+	path?: string;
+	url?: string;
+	source: { sessionId: string; taskId: string; createdAt: number };
+}
+
+interface Session {
+	id: string;
+	title: string;
+	messages: Message[];
+	assets: Asset[];
+	createdAt: number;
+	status: SessionStatus;
+}
+
+// ===== 内存存储 =====
+
+class SessionStore {
+	private sessions = new Map<string, Session>();
+	private seq = 0;
+
+	private genId(prefix: string): string {
+		this.seq += 1;
+		return `${prefix}_${Date.now().toString(36)}${this.seq.toString(36)}`;
+	}
+
+	create(title?: string): Session {
+		const id = this.genId("sess");
+		const session: Session = {
+			id,
+			title: title || "新会话",
+			messages: [],
+			assets: [],
+			createdAt: Date.now(),
+			status: "idle",
+		};
+		this.sessions.set(id, session);
+		return session;
+	}
+
+	get(id: string): Session | undefined {
+		return this.sessions.get(id);
+	}
+
+	list(): Session[] {
+		return Array.from(this.sessions.values()).sort((a, b) => b.createdAt - a.createdAt);
+	}
+
+	addMessage(sessionId: string, msg: Omit<Message, "id" | "at"> & { id?: string }): Message | null {
+		const s = this.sessions.get(sessionId);
+		if (!s) return null;
+		const full: Message = { ...msg, id: msg.id || this.genId("msg"), at: Date.now() };
+		s.messages.push(full);
+		return full;
+	}
+
+	updateLastAgentMessage(sessionId: string, patch: Partial<Message>): boolean {
+		const s = this.sessions.get(sessionId);
+		if (!s) return false;
+		for (let i = s.messages.length - 1; i >= 0; i--) {
+			if (s.messages[i]?.role === "agent") {
+				s.messages[i] = { ...s.messages[i]!, ...patch };
+				return true;
+			}
+		}
+		return false;
+	}
+
+	setStatus(sessionId: string, status: SessionStatus): void {
+		const s = this.sessions.get(sessionId);
+		if (s) s.status = status;
+	}
+}
+
+const store = new SessionStore();
+
+// ===== Handler 注册 =====
+
+type RegisterFn = <K extends keyof RPCMethods & string>(
+	method: K,
+	handler: (params: MethodParams<RPCMethods, K>) => Promise<MethodResult<RPCMethods, K>>,
+) => void;
+
+export function register(server: RPCServer, _options: HandlerOptions): void {
+	const r: RegisterFn = (method, handler) => {
+		server.register(method, handler as (params: unknown) => Promise<unknown>);
+	};
+
+	r("session.create", async (params) => {
+		const session = store.create(params.title);
+		return { id: session.id, title: session.title, createdAt: session.createdAt };
+	});
+
+	r("session.get", async (params) => {
+		const s = store.get(params.id);
+		if (!s) return null;
+		return { ...s };
+	});
+
+	r("session.list", async () => {
+		const sessions = store.list().map((s) => ({
+			id: s.id,
+			title: s.title,
+			createdAt: s.createdAt,
+			status: s.status,
+			messageCount: s.messages.length,
+			assetCount: s.assets.length,
+		}));
+		return { sessions };
+	});
+
+	r("session.addMessage", async (params) => {
+		const msg = store.addMessage(params.sessionId, params.message as any);
+		return msg ? { id: msg.id } : null;
+	});
+
+	r("session.updateLastMessage", async (params) => {
+		const ok = store.updateLastAgentMessage(params.sessionId, params.patch);
+		return { ok };
+	});
+
+	r("session.setStatus", async (params) => {
+		store.setStatus(params.sessionId, params.status as SessionStatus);
+		return { ok: true };
+	});
+
+	r("session.getMessages", async (_params) => {
+		// 由 Agent handler 管理，此处返回空
+		return { messages: [] };
+	});
+
+	r("session.disposeAgent", async (_params) => {
+		// 清理由 browser handler 处理
+		return { ok: true };
+	});
+}

package/templates/browser-agent/src/shared/handlers/system.ts

@@ -0,0 +1,27 @@
+import type { RPCServer } from "@dyyz1993/rpc-core";
+import type { MethodParams, MethodResult } from "@dyyz1993/rpc-core";
+import type { RPCMethods, HandlerOptions } from "../rpc-schema";
+
+type RegisterFn = <K extends keyof RPCMethods & string>(
+  method: K,
+  handler: (params: MethodParams<RPCMethods, K>) => Promise<MethodResult<RPCMethods, K>>,
+) => void;
+
+export function register(server: RPCServer, options: HandlerOptions): void {
+  const r: RegisterFn = (method, handler) => {
+    server.register(method, handler as (params: unknown) => Promise<unknown>);
+  };
+
+  r("system.ping", async () => ({
+    pong: true,
+    timestamp: Date.now(),
+    platform: options.platform,
+  }));
+
+  r("system.hello", async (params) => ({
+    message: `Hello ${params.name || "World"}!`,
+    timestamp: Date.now(),
+  }));
+
+  r("system.echo", async (params) => params);
+}

package/templates/browser-agent/src/shared/handlers/timer.ts

@@ -0,0 +1,34 @@
+import type { RPCServer } from "@dyyz1993/rpc-core";
+import type { MethodParams, MethodResult } from "@dyyz1993/rpc-core";
+import type { RPCMethods, HandlerOptions } from "../rpc-schema";
+
+type RegisterFn = <K extends keyof RPCMethods & string>(
+  method: K,
+  handler: (params: MethodParams<RPCMethods, K>) => Promise<MethodResult<RPCMethods, K>>,
+) => void;
+
+export function register(server: RPCServer, _options: HandlerOptions): void {
+  const r: RegisterFn = (method, handler) => {
+    server.register(method, handler as (params: unknown) => Promise<unknown>);
+  };
+
+  let timerId: ReturnType<typeof setInterval> | null = null;
+
+  r("timer.start", async () => {
+    if (timerId !== null) return { alreadyRunning: true };
+    let count = 0;
+    timerId = setInterval(() => {
+      count++;
+      server.emitEvent("timer.tick", { count, timestamp: Date.now() }, { channel: "default" });
+    }, 1000);
+    return { started: true };
+  });
+
+  r("timer.stop", async () => {
+    if (timerId !== null) {
+      clearInterval(timerId);
+      timerId = null;
+    }
+    return { stopped: true };
+  });
+}