@dyyz1993/create-agent 1.9.0

package/templates/general/src/shared/handlers/__tests__/timer.test.ts

@@ -0,0 +1,113 @@
+import { describe, test, expect, beforeEach } from "vitest";
+import type { RPCServer } from "@dyyz1993/rpc-core";
+import { register } from "../timer";
+
+type Handler = (params: unknown) => Promise<unknown>;
+type EmittedEvent = { event: string; payload: unknown; filter: unknown };
+
+function createMockServer() {
+  const handlers = new Map<string, Handler>();
+  const events: EmittedEvent[] = [];
+  return {
+    register: (method: string, handler: Handler) => {
+      handlers.set(method, handler);
+    },
+    emitEvent: (event: string, payload: unknown, filter?: unknown) => {
+      events.push({ event, payload, filter });
+    },
+    get: (method: string) => handlers.get(method),
+    has: (method: string) => handlers.has(method),
+    getEvents: () => events,
+    clearEvents: () => { events.length = 0; },
+  };
+}
+
+describe("timer handler", () => {
+  let server: ReturnType<typeof createMockServer>;
+
+  beforeEach(() => {
+    server = createMockServer();
+    register(server as unknown as RPCServer, { platform: "desktop" });
+  });
+
+  test("registers timer.start", () => {
+    expect(server.has("timer.start")).toBe(true);
+  });
+
+  test("registers timer.stop", () => {
+    expect(server.has("timer.stop")).toBe(true);
+  });
+
+  test("timer.start returns { started: true }", async () => {
+    const result = await server.get("timer.start")!({}) as Record<string, unknown>;
+    expect(result.started).toBe(true);
+    expect(result.alreadyRunning).toBeUndefined();
+  });
+
+  test("timer.start when already running returns { alreadyRunning: true }", async () => {
+    await server.get("timer.start")!({});
+    const result = await server.get("timer.start")!({}) as Record<string, unknown>;
+    expect(result.alreadyRunning).toBe(true);
+    expect(result.started).toBeUndefined();
+  });
+
+  test("timer.start emits timer.tick events", async () => {
+    await server.get("timer.start")!({});
+    await new Promise((r) => setTimeout(r, 1200));
+
+    const tickEvents = server.getEvents().filter((e) => e.event === "timer.tick");
+    expect(tickEvents.length).toBeGreaterThanOrEqual(1);
+
+    const payload = tickEvents[0].payload as Record<string, unknown>;
+    expect(payload.count).toBeDefined();
+    expect(payload.timestamp).toBeDefined();
+  });
+
+  test("timer.tick payload has incrementing count", async () => {
+    await server.get("timer.start")!({});
+    await new Promise((r) => setTimeout(r, 2200));
+
+    const tickEvents = server.getEvents().filter((e) => e.event === "timer.tick");
+    const counts = tickEvents.map((e) => (e.payload as Record<string, unknown>).count);
+    for (let i = 1; i < counts.length; i++) {
+      expect(Number(counts[i])).toBeGreaterThan(Number(counts[i - 1]));
+    }
+  });
+
+  test("timer.stop returns { stopped: true }", async () => {
+    const result = await server.get("timer.stop")!({}) as Record<string, unknown>;
+    expect(result.stopped).toBe(true);
+  });
+
+  test("timer.stop then start restarts the timer", async () => {
+    const r1 = await server.get("timer.start")!({}) as Record<string, unknown>;
+    expect(r1.started).toBe(true);
+
+    await server.get("timer.stop")!({});
+
+    const r2 = await server.get("timer.start")!({}) as Record<string, unknown>;
+    expect(r2.started).toBe(true);
+  });
+
+  test("timer.stop stops tick events", async () => {
+    await server.get("timer.start")!({});
+    await new Promise((r) => setTimeout(r, 1100));
+    await server.get("timer.stop")!({});
+
+    server.clearEvents();
+    await new Promise((r) => setTimeout(r, 1200));
+
+    const tickEvents = server.getEvents().filter((e) => e.event === "timer.tick");
+    expect(tickEvents.length).toBe(0);
+  });
+
+  test("timer.tick events include filter with channel", async () => {
+    await server.get("timer.start")!({});
+    await new Promise((r) => setTimeout(r, 1100));
+
+    const tickEvents = server.getEvents().filter((e) => e.event === "timer.tick");
+    if (tickEvents.length > 0) {
+      expect(tickEvents[0].filter).toEqual({ channel: "default" });
+    }
+  });
+});

package/templates/general/src/shared/handlers/chat.ts

@@ -0,0 +1,179 @@
+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");
+
+function getStoragePath(): string {
+  const dir = join(homedir(), ".pi-agent");
+  return join(dir, "chat-history.json");
+}
+
+type ChatMessage = { id: string; role: "user" | "assistant"; content: string; timestamp: number };
+
+async function loadMessages(): Promise<ChatMessage[]> {
+  const filePath = getStoragePath();
+  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 saveMessages(messages: ChatMessage[]): Promise<void> {
+  const filePath = getStoragePath();
+  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 });
+  }
+}
+
+type RegisterFn = <K extends keyof RPCMethods & string>(
+  method: K,
+  handler: (params: MethodParams<RPCMethods, K>) => Promise<MethodResult<RPCMethods, K>>,
+) => void;
+
+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 r: RegisterFn = (method, handler) => {
+    server.register(method, handler as (params: unknown) => Promise<unknown>);
+  };
+
+  r("chat.list", async (params) => {
+    const all = await loadMessages();
+    const limit = params.limit ?? 50;
+    const messages = all.slice(-limit);
+    return {
+      messages,
+      hasMore: all.length > limit,
+    };
+  });
+
+  r("chat.send", async (params) => {
+    const all = await loadMessages();
+
+    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 saveMessages(all);
+
+    return { ok: true };
+  });
+}

package/templates/general/src/shared/handlers/feed.ts

@@ -0,0 +1,53 @@
+import type { RPCServer } from "@dyyz1993/rpc-core";
+import type { MethodParams, MethodResult } from "@dyyz1993/rpc-core";
+import type { RPCMethods, HandlerOptions } from "../rpc-schema";
+import type { FeedPost, FeedCategory } from "../modules/feed";
+import { createLogger } from "../lib/logger";
+
+const log = createLogger("feed");
+
+// 内存存储
+const posts: FeedPost[] = [];
+
+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("feed.post", async (params) => {
+    const category = params.category as FeedCategory;
+    const author = (params.author as string) || "anonymous";
+
+    const post: FeedPost = {
+      id: `feed-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+      content: params.content,
+      category,
+      author,
+      timestamp: Date.now(),
+    };
+
+    posts.push(post);
+    log.info(`New post: ${post.id} [${category}] by ${author}`);
+
+    // 发送事件 — metadata 用于过滤
+    server.emitEvent("feed.update", post, { category, author });
+
+    return { id: post.id };
+  });
+
+  r("feed.list", async (params) => {
+    const limit = params.limit ?? 50;
+    let filtered = posts;
+
+    if (params.category) {
+      filtered = posts.filter((p) => p.category === params.category);
+    }
+
+    return { posts: filtered.slice(-limit) };
+  });
+}

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