@dyyz1993/create-agent 2.1.0 → 2.1.2

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

@@ -0,0 +1,72 @@
+import type { RPCServer } from "@dyyz1993/rpc-core";
+import type { MethodParams, MethodResult } from "@dyyz1993/rpc-core";
+import type { RPCMethods, HandlerOptions } from "../rpc-schema";
+import type { ContextFolder, Connector, WorkingFile } from "../modules/context";
+
+type RegisterFn = <K extends keyof RPCMethods & string>(
+	method: K,
+	handler: (params: MethodParams<RPCMethods, K>) => Promise<MethodResult<RPCMethods, K>>,
+) => void;
+
+// 内存存储
+const folders: ContextFolder[] = [
+	{ path: "/Users/simon/blog-drafts", name: "blog-drafts" },
+];
+const connectors: Connector[] = [
+	{ id: "web-search", name: "Web search", type: "web_search", enabled: true },
+	{ id: "github-api", name: "GitHub API", type: "api", enabled: false },
+];
+const workingFiles: WorkingFile[] = [
+	{ path: "/Users/simon/blog-drafts/llm-digest-october-2025.md", name: "llm-digest-october-2025.md", size: 12400 },
+	{ path: "/Users/simon/blog-drafts/tests-not-optional-coding-agents.md", name: "tests-not-optional-coding-agen...", size: 8200 },
+	{ path: "/Users/simon/blog-drafts/digest-november-2025.md", name: "digest-november-2025.md", size: 15600 },
+];
+
+export function register(server: RPCServer, _options: HandlerOptions): void {
+	const r: RegisterFn = (method, handler) => {
+		server.register(method, handler as (params: unknown) => Promise<unknown>);
+	};
+
+	r("context.listFolders", async () => ({ folders: [...folders] }));
+
+	r("context.addFolder", async (params) => {
+		const folder: ContextFolder = {
+			path: params.path,
+			name: params.path.split("/").pop() ?? params.path,
+		};
+		folders.push(folder);
+		return { folder };
+	});
+
+	r("context.removeFolder", async (params) => {
+		const idx = folders.findIndex((f) => f.path === params.path);
+		if (idx >= 0) folders.splice(idx, 1);
+		return { ok: true };
+	});
+
+	r("context.listConnectors", async () => ({ connectors: [...connectors] }));
+
+	r("context.toggleConnector", async (params) => {
+		const conn = connectors.find((c) => c.id === params.id);
+		if (!conn) throw new Error(`Connector not found: ${params.id}`);
+		conn.enabled = params.enabled;
+		return { connector: conn };
+	});
+
+	r("context.listWorkingFiles", async () => ({ files: [...workingFiles] }));
+
+	r("context.addWorkingFile", async (params) => {
+		const file: WorkingFile = {
+			path: params.path,
+			name: params.path.split("/").pop() ?? params.path,
+		};
+		workingFiles.push(file);
+		return { file };
+	});
+
+	r("context.removeWorkingFile", async (params) => {
+		const idx = workingFiles.findIndex((f) => f.path === params.path);
+		if (idx >= 0) workingFiles.splice(idx, 1);
+		return { ok: true };
+	});
+}

package/templates/cowork/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/cowork/src/shared/handlers/index.ts

@@ -0,0 +1,9 @@
+// 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 task } from './task';
+export { register as context } from './context';
+export { register as output } from './output';
+export { register as preview } from './preview';

package/templates/cowork/src/shared/handlers/output.ts

@@ -0,0 +1,59 @@
+import type { RPCServer } from "@dyyz1993/rpc-core";
+import type { MethodParams, MethodResult } from "@dyyz1993/rpc-core";
+import type { RPCMethods, HandlerOptions } from "../rpc-schema";
+import type { Output } from "../modules/output";
+
+type RegisterFn = <K extends keyof RPCMethods & string>(
+	method: K,
+	handler: (params: MethodParams<RPCMethods, K>) => Promise<MethodResult<RPCMethods, K>>,
+) => void;
+
+// 内存存储
+let outputIdCounter = 0;
+const outputs: Map<string, Output> = new Map();
+
+// ── Mock 预填充数据 ──
+const mockOutputs: Output[] = [
+	{
+		id: "output-1",
+		name: "publish-encouragement.html",
+		kind: "file",
+		path: "/Users/simon/blog-drafts/publish-encouragement.html",
+		size: 3200,
+		taskId: "task-1",
+		createdAt: Date.now() - 1800000,
+	},
+];
+for (const o of mockOutputs) {
+	outputs.set(o.id, o);
+	outputIdCounter = Math.max(outputIdCounter, parseInt(o.id.replace("output-", ""), 10));
+}
+
+export function register(server: RPCServer, _options: HandlerOptions): void {
+	const r: RegisterFn = (method, handler) => {
+		server.register(method, handler as (params: unknown) => Promise<unknown>);
+	};
+
+	r("output.list", async () => ({
+		outputs: [...outputs.values()].sort((a, b) => b.createdAt - a.createdAt),
+	}));
+
+	r("output.add", async (params) => {
+		const output: Output = {
+			id: `output-${++outputIdCounter}`,
+			name: params.name,
+			kind: params.kind,
+			path: params.path,
+			content: params.content,
+			taskId: params.taskId,
+			createdAt: Date.now(),
+		};
+		outputs.set(output.id, output);
+		return { output };
+	});
+
+	r("output.remove", async (params) => {
+		outputs.delete(params.id);
+		return { ok: true };
+	});
+}

package/templates/cowork/src/shared/handlers/preview.ts

@@ -0,0 +1,81 @@
+import type { RPCServer } from '@dyyz1993/rpc-core';
+import type { MethodParams, MethodResult } from '@dyyz1993/rpc-core';
+import type { RPCMethods, HandlerOptions } from '../rpc-schema';
+import type { PreviewTab } from '../modules/preview';
+
+type RegisterFn = <K extends keyof RPCMethods & string>(
+	method: K,
+	handler: (params: MethodParams<RPCMethods, K>) => Promise<MethodResult<RPCMethods, K>>,
+) => void;
+
+// 内存存储
+const tabs = new Map<string, PreviewTab>();
+const history: string[] = [];
+const MAX_HISTORY = 20;
+
+export function register(server: RPCServer, options: HandlerOptions): void {
+	const isDesktop = options.platform === 'desktop';
+	const r: RegisterFn = (method, handler) => {
+		server.register(method, handler as (params: unknown) => Promise<unknown>);
+	};
+
+	r('preview.open', async (params) => {
+		let tabId =
+			params.tabId ??
+			`preview-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}`;
+		// Ensure unique tabId
+		while (tabs.has(tabId)) {
+			tabId = `preview-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+		}
+
+		const tab: PreviewTab = {
+			id: tabId,
+			url: params.url,
+			title: params.url,
+			state: 'loading',
+			canGoBack: false,
+			canGoForward: false,
+		};
+		tabs.set(tabId, tab);
+
+		// 记录历史（去重，保持最新 20 条）
+		if (!history.includes(params.url)) {
+			history.unshift(params.url);
+			if (history.length > MAX_HISTORY) history.pop();
+		}
+
+		// 模拟加载过程（MVP 阶段先用 iframe 兜底）
+		tab.state = 'ready';
+		server.emitEvent('preview.navState', tab);
+		return { tab, useIframe: !isDesktop };
+	});
+
+	r('preview.navigate', async (params) => {
+		const tab = tabs.get(params.tabId);
+		if (!tab) throw new Error(`Tab not found: ${params.tabId}`);
+
+		tab.state = 'loading';
+		server.emitEvent('preview.navState', tab);
+
+		// 模拟导航完成
+		setTimeout(() => {
+			tab.state = 'ready';
+			server.emitEvent('preview.navState', tab);
+		}, 300);
+
+		return { ok: true };
+	});
+
+	r('preview.close', async (params) => {
+		tabs.delete(params.tabId);
+		return { ok: true };
+	});
+
+	r('preview.list', async () => ({
+		tabs: [...tabs.values()],
+	}));
+
+	r('preview.history', async () => ({
+		urls: [...history],
+	}));
+}

package/templates/cowork/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/cowork/src/shared/handlers/task.ts

@@ -0,0 +1,101 @@
+import type { RPCServer } from "@dyyz1993/rpc-core";
+import type { MethodParams, MethodResult } from "@dyyz1993/rpc-core";
+import type { RPCMethods, HandlerOptions } from "../rpc-schema";
+import type { Task } from "../modules/task";
+
+type RegisterFn = <K extends keyof RPCMethods & string>(
+	method: K,
+	handler: (params: MethodParams<RPCMethods, K>) => Promise<MethodResult<RPCMethods, K>>,
+) => void;
+
+// 内存存储
+let taskIdCounter = 0;
+const tasks: Map<string, Task> = new Map();
+
+// ── Mock 预填充数据 ──
+function initMockData(): void {
+	const now = Date.now();
+	const mockTasks: Task[] = [
+		{
+			id: "task-1",
+			title: "Review unpublished drafts for publication",
+			status: "executing",
+			progress: {
+				steps: [
+					{ label: "Scan blog-drafts folder", status: "done", detail: "Found 46 draft files" },
+					{ label: "Check publication status", status: "done", detail: "Cross-referenced with simonwillison.net" },
+					{ label: "Analyze readiness", status: "running", detail: "Reading content of each draft..." },
+				],
+			},
+			createdAt: now - 3600000,
+			updatedAt: now - 1800000,
+		},
+		{
+			id: "task-2",
+			title: "Summarize latest AI research papers",
+			status: "completed",
+			progress: {
+				steps: [
+					{ label: "Search arxiv for recent papers", status: "done", detail: "Found 12 relevant papers" },
+					{ label: "Read and summarize", status: "done", detail: "Generated summaries for all papers" },
+					{ label: "Compile into digest", status: "done", detail: "Created llm-digest-october-2025.md" },
+				],
+			},
+			createdAt: now - 86400000,
+			updatedAt: now - 72000000,
+		},
+		{
+			id: "task-3",
+			title: "Generate monthly newsletter",
+			status: "queued",
+			createdAt: now - 7200000,
+			updatedAt: now - 7200000,
+		},
+	];
+	for (const t of mockTasks) {
+		tasks.set(t.id, t);
+		taskIdCounter = Math.max(taskIdCounter, parseInt(t.id.replace("task-", ""), 10));
+	}
+}
+
+// 首次加载时填充 mock 数据
+initMockData();
+
+export function register(server: RPCServer, _options: HandlerOptions): void {
+	const r: RegisterFn = (method, handler) => {
+		server.register(method, handler as (params: unknown) => Promise<unknown>);
+	};
+
+	r("task.list", async () => ({
+		tasks: [...tasks.values()].sort((a, b) => b.updatedAt - a.updatedAt),
+	}));
+
+	r("task.create", async (params) => {
+		const now = Date.now();
+		const task: Task = {
+			id: `task-${++taskIdCounter}`,
+			title: params.title,
+			status: "queued",
+			createdAt: now,
+			updatedAt: now,
+		};
+		tasks.set(task.id, task);
+		return { task };
+	});
+
+	r("task.get", async (params) => ({
+		task: tasks.get(params.id) ?? null,
+	}));
+
+	r("task.update", async (params) => {
+		const task = tasks.get(params.id);
+		if (!task) throw new Error(`Task not found: ${params.id}`);
+		Object.assign(task, params.patch, { updatedAt: Date.now() });
+		return { task };
+	});
+
+	r("task.delete", async (params) => {
+		tasks.delete(params.id);
+		return { ok: true };
+	});
+}

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