@dyyz1993/create-agent 2.1.0 → 2.1.2

package/templates/cowork/src/shared/handlers/__tests__/chat-handler.test.ts

@@ -0,0 +1,77 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+vi.mock("../../lib/logger", () => ({
+  createLogger: () => ({
+    info: vi.fn(),
+    error: vi.fn(),
+    warn: vi.fn(),
+    debug: vi.fn(),
+  }),
+}));
+
+describe("Chat Handler", () => {
+  beforeEach(() => {
+    vi.resetModules();
+  });
+
+  describe("generateReply logic", () => {
+    it("should handle greeting patterns", () => {
+      const greetingPattern = /^(hi|hello|hey|howdy|hola|yo|sup)\b/i;
+      expect(greetingPattern.test("hello")).toBe(true);
+      expect(greetingPattern.test("hi there")).toBe(true);
+      expect(greetingPattern.test("what is this")).toBe(false);
+    });
+
+    it("should match time/date queries", () => {
+      const timePattern = /what('?s| is) the (time|date|day)|current (time|date)|what time|today'?s date/i;
+      expect(timePattern.test("what's the time")).toBe(true);
+      expect(timePattern.test("what is the date")).toBe(true);
+      expect(timePattern.test("current time")).toBe(true);
+      expect(timePattern.test("hello world")).toBe(false);
+    });
+
+    it("should match math expressions", () => {
+      const mathPattern = /(?:what(?:'s| is)\s+)?(\d+(?:\.\d+)?)\s*([+\-*/x×÷^])\s*(\d+(?:\.\d+)?)/;
+      expect(mathPattern.test("12 * 8")).toBe(true);
+      expect(mathPattern.test("what is 100 / 4")).toBe(true);
+      expect(mathPattern.test("3 + 5")).toBe(true);
+      expect(mathPattern.test("hello")).toBe(false);
+    });
+
+    it("should compute math correctly", () => {
+      const compute = (a: number, op: string, b: number): number => {
+        switch (op) {
+          case "+": return a + b;
+          case "-": return a - b;
+          case "*": return a * b;
+          case "/": return b !== 0 ? a / b : NaN;
+          default: return NaN;
+        }
+      };
+
+      expect(compute(3, "+", 5)).toBe(8);
+      expect(compute(10, "-", 4)).toBe(6);
+      expect(compute(6, "*", 7)).toBe(42);
+      expect(compute(20, "/", 4)).toBe(5);
+      expect(compute(1, "/", 0)).toBeNaN();
+    });
+  });
+
+  describe("register", () => {
+    it("should register chat.list and chat.send methods", async () => {
+      const registeredMethods: string[] = [];
+      const mockServer = {
+        register: vi.fn((method: string) => {
+          registeredMethods.push(method);
+        }),
+        emitEvent: vi.fn(),
+      };
+
+      const { register } = await import("../chat");
+      register(mockServer as any, { platform: "web" });
+
+      expect(registeredMethods).toContain("chat.list");
+      expect(registeredMethods).toContain("chat.send");
+    });
+  });
+});

package/templates/cowork/src/shared/handlers/__tests__/file-handler.test.ts

@@ -0,0 +1,100 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+vi.mock("../../lib/logger", () => ({
+  createLogger: () => ({
+    info: vi.fn(),
+    error: vi.fn(),
+    warn: vi.fn(),
+    debug: vi.fn(),
+  }),
+}));
+
+describe("File Handler", () => {
+  beforeEach(() => {
+    vi.resetModules();
+  });
+
+  describe("path-security integration", () => {
+    it("validatePath should reject null bytes", async () => {
+      const { validatePath } = await import("../../lib/path-security");
+      expect(() => validatePath("/some/path\0/evil")).toThrow(
+        "Access denied: path contains null bytes",
+      );
+    });
+
+    it("validatePath should reject paths outside allowed roots", async () => {
+      const { validatePath, setAllowedRoots } = await import("../../lib/path-security");
+      setAllowedRoots(["/safe/dir"]);
+      expect(() => validatePath("/etc/passwd")).toThrow(
+        "Access denied",
+      );
+    });
+
+    it("validatePath should accept paths within allowed roots", async () => {
+      const { validatePath, setAllowedRoots } = await import("../../lib/path-security");
+      setAllowedRoots(["/tmp"]);
+      const result = validatePath("/tmp/test.txt");
+      expect(result).toContain("/tmp");
+    });
+
+    it("isRpcPathAllowed should return false for null bytes", async () => {
+      const { isRpcPathAllowed } = await import("../../lib/path-security");
+      expect(isRpcPathAllowed("/some\0path")).toBe(false);
+    });
+  });
+
+  describe("register", () => {
+    it("should register all file.* methods", async () => {
+      const registeredMethods: string[] = [];
+      const mockServer = {
+        register: vi.fn((method: string) => {
+          registeredMethods.push(method);
+        }),
+      };
+
+      vi.doMock("fs/promises", async (importOriginal) => {
+        const actual = await importOriginal() as Record<string, unknown>;
+        return {
+          ...actual,
+          readdir: vi.fn().mockResolvedValue([]),
+          stat: vi.fn().mockResolvedValue({ isDirectory: () => true, size: 0 }),
+          writeFile: vi.fn().mockResolvedValue(undefined),
+          readFile: vi.fn().mockResolvedValue(Buffer.from("")),
+          mkdir: vi.fn().mockResolvedValue(undefined),
+          rename: vi.fn().mockResolvedValue(undefined),
+          rm: vi.fn().mockResolvedValue(undefined),
+          cp: vi.fn().mockResolvedValue(undefined),
+        };
+      });
+
+      vi.doMock("fs", async (importOriginal) => {
+        const actual = await importOriginal() as Record<string, unknown>;
+        return {
+          ...actual,
+          existsSync: vi.fn().mockReturnValue(true),
+        };
+      });
+
+      const { setAllowedRoots } = await import("../../lib/path-security");
+      setAllowedRoots(["/tmp"]);
+
+      const { register } = await import("../file");
+      register(mockServer as any, { platform: "web" });
+
+      const expectedMethods = [
+        "file.findProjectRoot",
+        "file.listDir",
+        "file.createFile",
+        "file.createDir",
+        "file.rename",
+        "file.delete",
+        "file.copy",
+        "file.readFile",
+      ];
+
+      for (const method of expectedMethods) {
+        expect(registeredMethods).toContain(method);
+      }
+    });
+  });
+});

package/templates/cowork/src/shared/handlers/__tests__/preview-handler.test.ts

@@ -0,0 +1,172 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { RPCServer } from '@dyyz1993/rpc-core';
+
+describe('Preview Handler', () => {
+	let registeredHandlers: Record<string, (params: unknown) => Promise<unknown>>;
+	let emittedEvents: { event: string; payload: unknown }[];
+
+	beforeEach(async () => {
+		vi.resetModules();
+		registeredHandlers = {};
+		emittedEvents = [];
+
+		const mockServer = {
+			register: vi.fn((method: string, handler: Function) => {
+				registeredHandlers[method] = handler as (params: unknown) => Promise<unknown>;
+			}),
+			emitEvent: vi.fn((event: string, payload: unknown) => {
+				emittedEvents.push({ event, payload });
+			}),
+		};
+
+		const { register } = await import('../preview');
+		register(mockServer as unknown as RPCServer, { platform: 'web' });
+	});
+
+	it('should register all preview methods', () => {
+		expect(registeredHandlers['preview.open']).toBeDefined();
+		expect(registeredHandlers['preview.navigate']).toBeDefined();
+		expect(registeredHandlers['preview.close']).toBeDefined();
+		expect(registeredHandlers['preview.list']).toBeDefined();
+		expect(registeredHandlers['preview.history']).toBeDefined();
+	});
+
+	it('preview.open should return a tab with useIframe=true on web platform', async () => {
+		const result = (await registeredHandlers['preview.open']({
+			url: 'http://localhost:5173',
+		})) as { tab: { id: string; url: string; state: string }; useIframe: boolean };
+
+		expect(result.tab).toBeDefined();
+		expect(result.tab.url).toBe('http://localhost:5173');
+		expect(result.tab.state).toBe('ready');
+		expect(result.useIframe).toBe(true);
+		expect(result.tab.id).toMatch(/^preview-/);
+	});
+
+	it('preview.open should emit navState event', async () => {
+		await registeredHandlers['preview.open']({ url: 'http://localhost:5173' });
+
+		expect(emittedEvents.length).toBeGreaterThan(0);
+		expect(emittedEvents[0].event).toBe('preview.navState');
+		const payload = emittedEvents[0].payload as { url: string; state: string };
+		expect(payload.url).toBe('http://localhost:5173');
+	});
+
+	it('preview.open should accept custom tabId', async () => {
+		const result = (await registeredHandlers['preview.open']({
+			url: 'http://localhost:3000',
+			tabId: 'custom-tab-1',
+		})) as { tab: { id: string } };
+
+		expect(result.tab.id).toBe('custom-tab-1');
+	});
+
+	it('preview.open should record URL in history', async () => {
+		await registeredHandlers['preview.open']({ url: 'http://localhost:5173' });
+		const historyResult = (await registeredHandlers['preview.history']({})) as {
+			urls: string[];
+		};
+		expect(historyResult.urls).toContain('http://localhost:5173');
+	});
+
+	it('preview.navigate should emit loading then ready', async () => {
+		const openResult = (await registeredHandlers['preview.open']({
+			url: 'http://localhost:5173',
+		})) as { tab: { id: string } };
+		const tabId = openResult.tab.id;
+
+		emittedEvents.length = 0;
+		await registeredHandlers['preview.navigate']({ tabId, action: 'reload' });
+
+		// Should emit loading immediately
+		expect(emittedEvents[0].payload).toMatchObject({ state: 'loading' });
+
+		// Wait for setTimeout to fire ready state
+		await new Promise((resolve) => setTimeout(resolve, 400));
+		const readyEvent = emittedEvents.find(
+			(e) => (e.payload as { state: string }).state === 'ready',
+		);
+		expect(readyEvent).toBeDefined();
+	});
+
+	it('preview.navigate should throw for unknown tabId', async () => {
+		await expect(
+			registeredHandlers['preview.navigate']({ tabId: 'nonexistent', action: 'reload' }),
+		).rejects.toThrow('Tab not found');
+	});
+
+	it('preview.close should remove the tab', async () => {
+		const openResult = (await registeredHandlers['preview.open']({
+			url: 'http://localhost:5173',
+		})) as { tab: { id: string } };
+		const tabId = openResult.tab.id;
+
+		const closeResult = (await registeredHandlers['preview.close']({ tabId })) as {
+			ok: boolean;
+		};
+		expect(closeResult.ok).toBe(true);
+
+		const listResult = (await registeredHandlers['preview.list']({})) as {
+			tabs: { id: string }[];
+		};
+		expect(listResult.tabs.find((t) => t.id === tabId)).toBeUndefined();
+	});
+
+	it('preview.list should return all open tabs', async () => {
+		await registeredHandlers['preview.open']({ url: 'http://localhost:5173' });
+		await registeredHandlers['preview.open']({ url: 'http://localhost:3000' });
+
+		const result = (await registeredHandlers['preview.list']({})) as {
+			tabs: { id: string; url: string }[];
+		};
+		expect(result.tabs).toHaveLength(2);
+	});
+
+	it('preview.history should not exceed 20 entries', async () => {
+		for (let i = 0; i < 25; i++) {
+			await registeredHandlers['preview.open']({ url: `http://localhost:${3000 + i}` });
+		}
+		const result = (await registeredHandlers['preview.history']({})) as {
+			urls: string[];
+		};
+		expect(result.urls.length).toBeLessThanOrEqual(20);
+	});
+
+	it('preview.history should deduplicate URLs', async () => {
+		await registeredHandlers['preview.open']({ url: 'http://localhost:5173' });
+		await registeredHandlers['preview.open']({ url: 'http://localhost:5173' });
+		await registeredHandlers['preview.open']({ url: 'http://localhost:5173' });
+
+		const result = (await registeredHandlers['preview.history']({})) as {
+			urls: string[];
+		};
+		expect(result.urls.filter((u) => u === 'http://localhost:5173')).toHaveLength(1);
+	});
+});
+
+describe('Preview Handler (Desktop Platform)', () => {
+	let registeredHandlers: Record<string, (params: unknown) => Promise<unknown>>;
+
+	beforeEach(async () => {
+		vi.resetModules();
+		registeredHandlers = {};
+
+		const mockServer = {
+			register: vi.fn((method: string, handler: Function) => {
+				registeredHandlers[method] = handler as (params: unknown) => Promise<unknown>;
+			}),
+			emitEvent: vi.fn(),
+		};
+
+		const { register } = await import('../preview');
+		register(mockServer as unknown as RPCServer, { platform: 'desktop' });
+	});
+
+	it('preview.open should return useIframe=false on desktop platform', async () => {
+		const result = (await registeredHandlers['preview.open']({
+			url: 'http://localhost:5173',
+		})) as { useIframe: boolean };
+
+		expect(result.useIframe).toBe(false);
+	});
+});

package/templates/cowork/src/shared/handlers/__tests__/system-handler.test.ts

@@ -0,0 +1,55 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import type { RPCServer } from "@dyyz1993/rpc-core";
+
+describe("System Handler", () => {
+  let mockServer: { register: ReturnType<typeof vi.fn> };
+  let registeredHandlers: Record<string, Function>;
+
+  beforeEach(async () => {
+    vi.resetModules();
+    registeredHandlers = {};
+    mockServer = {
+      register: vi.fn((method: string, handler: Function) => {
+        registeredHandlers[method] = handler;
+      }),
+    };
+    const { register } = await import("../system");
+    register(mockServer as unknown as RPCServer, { platform: "web" });
+  });
+
+  it("should register system methods", () => {
+    expect(registeredHandlers["system.ping"]).toBeDefined();
+    expect(registeredHandlers["system.hello"]).toBeDefined();
+    expect(registeredHandlers["system.echo"]).toBeDefined();
+  });
+
+  it("system.ping should return pong with timestamp and platform", async () => {
+    const result = await registeredHandlers["system.ping"]({});
+    expect(result).toHaveProperty("pong", true);
+    expect(result).toHaveProperty("timestamp");
+    expect(result).toHaveProperty("platform", "web");
+    expect(typeof result.timestamp).toBe("number");
+  });
+
+  it("system.hello should return greeting with provided name", async () => {
+    const result = await registeredHandlers["system.hello"]({ name: "World" });
+    expect(result.message).toContain("World");
+    expect(result.message).toBe("Hello World!");
+    expect(result).toHaveProperty("timestamp");
+  });
+
+  it("system.hello should default to 'World'", async () => {
+    const result = await registeredHandlers["system.hello"]({});
+    expect(result.message).toBe("Hello World!");
+  });
+
+  it("system.echo should return input params", async () => {
+    const result = await registeredHandlers["system.echo"]({ data: "test", num: 42 });
+    expect(result).toEqual({ data: "test", num: 42 });
+  });
+
+  it("system.echo should return empty object for empty params", async () => {
+    const result = await registeredHandlers["system.echo"]({});
+    expect(result).toEqual({});
+  });
+});

package/templates/cowork/src/shared/handlers/__tests__/timer-handler.test.ts

@@ -0,0 +1,77 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import type { RPCServer } from "@dyyz1993/rpc-core";
+
+describe("Timer Handler", () => {
+  let registeredHandlers: Record<string, Function>;
+  let mockServer: {
+    register: ReturnType<typeof vi.fn>;
+    emitEvent: ReturnType<typeof vi.fn>;
+  };
+
+  beforeEach(async () => {
+    vi.useFakeTimers();
+    vi.resetModules();
+    registeredHandlers = {};
+    mockServer = {
+      register: vi.fn((method: string, handler: Function) => {
+        registeredHandlers[method] = handler;
+      }),
+      emitEvent: vi.fn(),
+    };
+    const { register } = await import("../timer");
+    register(mockServer as unknown as RPCServer, { platform: "web" });
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("should register timer.start and timer.stop", () => {
+    expect(registeredHandlers["timer.start"]).toBeDefined();
+    expect(registeredHandlers["timer.stop"]).toBeDefined();
+  });
+
+  it("timer.start should return started: true", async () => {
+    const result = await registeredHandlers["timer.start"]({});
+    expect(result).toEqual({ started: true });
+  });
+
+  it("timer.start should return alreadyRunning: true if called twice", async () => {
+    await registeredHandlers["timer.start"]({});
+    const result = await registeredHandlers["timer.start"]({});
+    expect(result).toEqual({ alreadyRunning: true });
+  });
+
+  it("timer.start should emit timer.tick events on interval", async () => {
+    await registeredHandlers["timer.start"]({});
+    vi.advanceTimersByTime(3500);
+    expect(mockServer.emitEvent).toHaveBeenCalledTimes(3);
+    expect(mockServer.emitEvent).toHaveBeenCalledWith(
+      "timer.tick",
+      expect.objectContaining({ count: expect.any(Number), timestamp: expect.any(Number) }),
+      { channel: "default" },
+    );
+  });
+
+  it("timer.stop should return stopped: true", async () => {
+    await registeredHandlers["timer.start"]({});
+    const result = await registeredHandlers["timer.stop"]({});
+    expect(result).toEqual({ stopped: true });
+  });
+
+  it("timer.stop should stop emitting tick events", async () => {
+    await registeredHandlers["timer.start"]({});
+    vi.advanceTimersByTime(1500);
+    const ticksBefore = mockServer.emitEvent.mock.calls.length;
+
+    await registeredHandlers["timer.stop"]({});
+    vi.advanceTimersByTime(3000);
+
+    expect(mockServer.emitEvent.mock.calls.length).toBe(ticksBefore);
+  });
+
+  it("timer.stop without start should still return stopped: true", async () => {
+    const result = await registeredHandlers["timer.stop"]({});
+    expect(result).toEqual({ stopped: true });
+  });
+});

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