@dyyz1993/create-agent 2.1.0 → 2.1.2

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