@dyyz1993/create-agent 1.9.0

package/templates/agent/src/shared/handlers/__tests__/feed-handler.test.ts

@@ -0,0 +1,108 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import type { RPCServer } from "@dyyz1993/rpc-core";
+
+vi.mock("../../lib/logger", () => ({
+  createLogger: () => ({
+    info: vi.fn(),
+    error: vi.fn(),
+    warn: vi.fn(),
+    debug: vi.fn(),
+  }),
+}));
+
+describe("Feed Handler", () => {
+  let registeredHandlers: Record<string, Function>;
+  let mockServer: {
+    register: ReturnType<typeof vi.fn>;
+    emitEvent: ReturnType<typeof vi.fn>;
+  };
+
+  beforeEach(async () => {
+    vi.resetModules();
+    registeredHandlers = {};
+    mockServer = {
+      register: vi.fn((method: string, handler: Function) => {
+        registeredHandlers[method] = handler;
+      }),
+      emitEvent: vi.fn(),
+    };
+    const { register } = await import("../feed");
+    register(mockServer as unknown as RPCServer, { platform: "web" });
+  });
+
+  it("should register feed.post and feed.list", () => {
+    expect(registeredHandlers["feed.post"]).toBeDefined();
+    expect(registeredHandlers["feed.list"]).toBeDefined();
+  });
+
+  it("feed.post should create a post and return id", async () => {
+    const result = await registeredHandlers["feed.post"]({
+      content: "Hello feed",
+      category: "tech",
+      author: "tester",
+    });
+    expect(result).toHaveProperty("id");
+    expect(result.id).toMatch(/^feed-/);
+  });
+
+  it("feed.post should default author to anonymous", async () => {
+    await registeredHandlers["feed.post"]({
+      content: "test",
+      category: "general",
+    });
+    expect(mockServer.emitEvent).toHaveBeenCalledWith(
+      "feed.update",
+      expect.objectContaining({ author: "anonymous" }),
+      expect.objectContaining({ author: "anonymous" }),
+    );
+  });
+
+  it("feed.post should emit feed.update event", async () => {
+    await registeredHandlers["feed.post"]({
+      content: "event test",
+      category: "news",
+      author: "reporter",
+    });
+    expect(mockServer.emitEvent).toHaveBeenCalledWith(
+      "feed.update",
+      expect.objectContaining({
+        content: "event test",
+        category: "news",
+        author: "reporter",
+      }),
+      { category: "news", author: "reporter" },
+    );
+  });
+
+  it("feed.list should return all posts by default", async () => {
+    await registeredHandlers["feed.post"]({ content: "post 1", category: "tech" });
+    await registeredHandlers["feed.post"]({ content: "post 2", category: "general" });
+
+    const result = await registeredHandlers["feed.list"]({});
+    expect(result.posts).toHaveLength(2);
+  });
+
+  it("feed.list should filter by category", async () => {
+    await registeredHandlers["feed.post"]({ content: "tech post", category: "tech" });
+    await registeredHandlers["feed.post"]({ content: "news post", category: "news" });
+    await registeredHandlers["feed.post"]({ content: "general post", category: "general" });
+
+    const result = await registeredHandlers["feed.list"]({ category: "tech" });
+    expect(result.posts).toHaveLength(1);
+    expect(result.posts[0].category).toBe("tech");
+  });
+
+  it("feed.list should respect limit param", async () => {
+    for (let i = 0; i < 5; i++) {
+      await registeredHandlers["feed.post"]({ content: `post ${i}`, category: "tech" });
+    }
+
+    const result = await registeredHandlers["feed.list"]({ limit: 3 });
+    expect(result.posts).toHaveLength(3);
+  });
+
+  it("feed.list should default limit to 50", async () => {
+    const result = await registeredHandlers["feed.list"]({});
+    expect(result.posts.length).toBeLessThanOrEqual(50);
+  });
+});

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

@@ -0,0 +1,89 @@
+import type { RPCServer } from "@dyyz1993/rpc-core";
+import type { MethodParams, MethodResult } from "@dyyz1993/rpc-core";
+import type { RPCMethods, HandlerOptions } from "../rpc-schema";
+import { validateCommand, setCommandPolicy } from "../lib/bash-security";
+
+type RegisterFn = <K extends keyof RPCMethods & string>(
+  method: K,
+  handler: (params: MethodParams<RPCMethods, K>) => Promise<MethodResult<RPCMethods, K>>,
+) => void;
+
+interface TrackedProcess {
+  pid: number;
+  command: string;
+  running: boolean;
+}
+
+const processes = new Map<number, TrackedProcess>();
+let pidCounter = 1;
+
+export function register(server: RPCServer, _options: HandlerOptions): void {
+  setCommandPolicy({
+    enabled: _options.enableBash !== false,
+    blockedPatterns: [
+      /rm\s+-rf\s+(.*\s)?\/($|\s)/,
+      /rm\s+-rf\s+--no-preserve-root/,
+      /mkfs/,
+      /dd\s+if=/,
+      />\s*\/dev\//,
+      /:()\s*\{.*\|.*&\s*\}/,
+      /shutdown/,
+      /reboot/,
+    ],
+    allowedCommands: null,
+  });
+
+  const r: RegisterFn = (method, handler) => {
+    server.register(method, handler as (params: unknown) => Promise<unknown>);
+  };
+
+  r("bash.execute", async (params) => {
+    const safeCommand = validateCommand(params.command);
+    const pid = pidCounter++;
+    const proc: TrackedProcess = { pid, command: safeCommand, running: true };
+    processes.set(pid, proc);
+
+    try {
+      const subprocess = Bun.spawn(safeCommand.split(" "), {
+        cwd: params.cwd || process.cwd(),
+        stdout: "pipe",
+        stderr: "pipe",
+      });
+
+      proc.pid = subprocess.pid;
+
+      const stdout = await new Response(subprocess.stdout).text();
+      const stderr = await new Response(subprocess.stderr).text();
+      const exitCode = await subprocess.exited;
+
+      proc.running = false;
+
+      const output = stdout + (stderr ? `\n[stderr]\n${stderr}` : "");
+
+      server.emitEvent("bash.output", { pid, data: output, stream: "stdout" }, {});
+      server.emitEvent("bash.exit", { pid, code: exitCode }, {});
+
+      return { pid, output };
+    } catch (err) {
+      proc.running = false;
+      const output = `Error: ${err instanceof Error ? err.message : String(err)}`;
+      server.emitEvent("bash.output", { pid, data: output, stream: "stderr" }, {});
+      server.emitEvent("bash.exit", { pid, code: 1 }, {});
+      return { pid, output };
+    }
+  });
+
+  r("bash.kill", async (params) => {
+    const proc = processes.get(params.pid);
+    if (proc) {
+      proc.running = false;
+      processes.delete(params.pid);
+      return { success: true };
+    }
+    return { success: false };
+  });
+
+  r("bash.listProcesses", async () => ({
+    processes: Array.from(processes.values()),
+  }));
+}

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