@dyyz1993/create-agent 1.9.0

package/templates/agent/src/mainview/lib/rpc-cache.ts

@@ -0,0 +1,94 @@
+interface CacheEntry<T> {
+  data: T;
+  timestamp: number;
+}
+
+class RpcCache {
+  private cache = new Map<string, CacheEntry<unknown>>();
+  private defaultTTL: number;
+  private pruneTimer: ReturnType<typeof setInterval> | null = null;
+
+  constructor(defaultTTL = 2000) {
+    this.defaultTTL = defaultTTL;
+  }
+
+  private key(method: string, params: unknown): string {
+    return `${method}:${JSON.stringify(params)}`;
+  }
+
+  get<T>(method: string, params: unknown, ttl?: number): T | null {
+    const k = this.key(method, params);
+    const entry = this.cache.get(k);
+    if (!entry) return null;
+
+    const effectiveTTL = ttl ?? this.defaultTTL;
+    if (Date.now() - entry.timestamp > effectiveTTL) {
+      this.cache.delete(k);
+      return null;
+    }
+
+    return entry.data as T;
+  }
+
+  set<T>(method: string, params: unknown, data: T): void {
+    const k = this.key(method, params);
+    this.cache.set(k, { data, timestamp: Date.now() });
+    if (!this.pruneTimer) this.startPruneTimer();
+  }
+
+  invalidate(method: string): void {
+    const prefix = `${method}:`;
+    for (const key of this.cache.keys()) {
+      if (key.startsWith(prefix)) {
+        this.cache.delete(key);
+      }
+    }
+  }
+
+  invalidateAll(methods: string[]): void {
+    for (const m of methods) {
+      this.invalidate(m);
+    }
+  }
+
+  clear(): void {
+    this.cache.clear();
+    if (this.pruneTimer) {
+      clearInterval(this.pruneTimer);
+      this.pruneTimer = null;
+    }
+  }
+
+  prune(): void {
+    const threshold = this.defaultTTL * 10;
+    const now = Date.now();
+    for (const [key, entry] of this.cache) {
+      if (now - entry.timestamp > threshold) {
+        this.cache.delete(key);
+      }
+    }
+    if (this.cache.size === 0 && this.pruneTimer) {
+      clearInterval(this.pruneTimer);
+      this.pruneTimer = null;
+    }
+  }
+
+  private startPruneTimer(): void {
+    if (this.pruneTimer) return;
+    this.pruneTimer = setInterval(() => this.prune(), this.defaultTTL * 5);
+  }
+}
+
+export const CACHEABLE_METHODS: Record<string, number> = {
+  "file.listDir": 2000,
+  "file.readFile": 3000,
+  "git.status": 2000,
+  "git.branches": 5000,
+  "git.log": 3000,
+  "git.diff": 3000,
+  "git.commitFiles": 3000,
+  "git.commitFileDiff": 3000,
+  "git.worktreeList": 5000,
+};
+
+export const rpcCache = new RpcCache(2000);

package/templates/agent/src/mainview/main.tsx

@@ -0,0 +1,24 @@
+import "./lib/i18n";
+import { StrictMode } from "react";
+import { createRoot } from "react-dom/client";
+import { apiClient } from "./lib/api-client";
+import "./index.css";
+import App from "./App";
+
+const isElectrobun = typeof window !== "undefined" && !!window.__electrobunBunBridge;
+
+if (isElectrobun) {
+  // 桌面端：同步初始化 IPC（Electrobun 要求桥接在页面加载时同步设置）
+  apiClient.initSyncForDesktop();
+}
+// Web 端 WS 初始化由 App.tsx 统一管理，避免竞争
+
+if (import.meta.env.DEV) {
+  console.warn("[Main] Application starting, isElectrobun:", isElectrobun);
+}
+
+createRoot(document.getElementById("root")!).render(
+  <StrictMode>
+    <App />
+  </StrictMode>
+);

package/templates/agent/src/mainview/stores/__tests__/use-app-store.test.ts

@@ -0,0 +1,86 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+vi.mock("../../lib/api-client", () => ({
+  apiClient: {
+    call: vi.fn().mockResolvedValue({ pong: true, timestamp: Date.now(), platform: "web" }),
+    subscribe: vi.fn().mockResolvedValue("sub-id"),
+    unsubscribe: vi.fn(),
+  },
+}));
+
+vi.mock("./use-log-store", () => ({
+  useLogStore: {
+    getState: () => ({ addLog: vi.fn() }),
+  },
+}));
+
+describe("useAppStore", () => {
+  beforeEach(async () => {
+    vi.resetModules();
+  });
+
+  it("should have initial state", async () => {
+    const { useAppStore } = await import("../use-app-store");
+    const state = useAppStore.getState();
+    expect(state.method).toBe("system.ping");
+    expect(state.result).toBeNull();
+    expect(state.tickEvents).toEqual([]);
+    expect(state.tickCount).toBe(0);
+    expect(state.subscriptionId).toBeNull();
+    expect(state.timerRunning).toBe(false);
+  });
+
+  it("should set method", async () => {
+    const { useAppStore } = await import("../use-app-store");
+    useAppStore.getState().setMethod("system.hello");
+    expect(useAppStore.getState().method).toBe("system.hello");
+  });
+
+  it("should callRPC and store result for system.ping", async () => {
+    const { useAppStore } = await import("../use-app-store");
+    await useAppStore.getState().callRPC("test");
+    expect(useAppStore.getState().result).toEqual(
+      expect.objectContaining({ pong: true }),
+    );
+  });
+
+  it("should handleSubscribe and start timer", async () => {
+    const { apiClient } = await import("../../lib/api-client");
+    const { useAppStore } = await import("../use-app-store");
+
+    await useAppStore.getState().handleSubscribe();
+    expect(apiClient.call).toHaveBeenCalledWith("timer.start", {});
+    expect(useAppStore.getState().timerRunning).toBe(true);
+    expect(apiClient.subscribe).toHaveBeenCalledWith(
+      "timer.tick",
+      expect.any(Function),
+      {},
+    );
+    expect(useAppStore.getState().subscriptionId).toBe("sub-id");
+  });
+
+  it("should handleUnsubscribe and stop timer", async () => {
+    const { apiClient } = await import("../../lib/api-client");
+    const { useAppStore } = await import("../use-app-store");
+
+    await useAppStore.getState().handleSubscribe();
+    await useAppStore.getState().handleUnsubscribe();
+
+    expect(apiClient.unsubscribe).toHaveBeenCalledWith("sub-id");
+    expect(useAppStore.getState().timerRunning).toBe(false);
+    expect(useAppStore.getState().subscriptionId).toBeNull();
+  });
+
+  it("should stop timer even without subscription", async () => {
+    const { apiClient } = await import("../../lib/api-client");
+    const { useAppStore } = await import("../use-app-store");
+
+    (apiClient.unsubscribe as ReturnType<typeof vi.fn>).mockClear();
+    (apiClient.call as ReturnType<typeof vi.fn>).mockClear();
+
+    await useAppStore.getState().handleUnsubscribe();
+    expect(apiClient.unsubscribe).not.toHaveBeenCalled();
+    expect(apiClient.call).toHaveBeenCalledWith("timer.stop", {});
+    expect(useAppStore.getState().timerRunning).toBe(false);
+  });
+});

package/templates/agent/src/mainview/stores/__tests__/use-bash-store.test.ts

@@ -0,0 +1,99 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+vi.mock("../../lib/api-client", () => ({
+  apiClient: { call: vi.fn() },
+}));
+
+vi.mock("../use-log-store", () => ({
+  useLogStore: { getState: () => ({ addLog: vi.fn() }) },
+}));
+
+describe("useBashStore", () => {
+  beforeEach(async () => {
+    vi.resetModules();
+  });
+
+  it("should have correct initial state", async () => {
+    const { useBashStore } = await import("../use-bash-store");
+    const state = useBashStore.getState();
+    expect(state.processes.size).toBe(0);
+    expect(state.activePid).toBeNull();
+  });
+
+  it("should add a process", async () => {
+    const { useBashStore } = await import("../use-bash-store");
+    useBashStore.getState().addProcess(1234, "ls -la");
+    const state = useBashStore.getState();
+    expect(state.processes.has(1234)).toBe(true);
+    expect(state.processes.get(1234)!.command).toBe("ls -la");
+    expect(state.processes.get(1234)!.running).toBe(true);
+    expect(state.processes.get(1234)!.output).toBe("");
+    expect(state.activePid).toBe(1234);
+  });
+
+  it("should update output", async () => {
+    const { useBashStore } = await import("../use-bash-store");
+    useBashStore.getState().addProcess(1234, "echo hello");
+    useBashStore.getState().updateOutput(1234, "hello\n");
+    expect(useBashStore.getState().processes.get(1234)!.output).toBe("hello\n");
+  });
+
+  it("should remove (stop) a process", async () => {
+    const { useBashStore } = await import("../use-bash-store");
+    useBashStore.getState().addProcess(1234, "ls");
+    useBashStore.getState().removeProcess(1234);
+    expect(useBashStore.getState().processes.get(1234)!.running).toBe(false);
+  });
+
+  it("should set active pid", async () => {
+    const { useBashStore } = await import("../use-bash-store");
+    useBashStore.getState().setActive(999);
+    expect(useBashStore.getState().activePid).toBe(999);
+    useBashStore.getState().setActive(null);
+    expect(useBashStore.getState().activePid).toBeNull();
+  });
+
+  it("should execute command via apiClient", async () => {
+    const { apiClient } = await import("../../lib/api-client");
+    const { useBashStore } = await import("../use-bash-store");
+    (apiClient.call as ReturnType<typeof vi.fn>).mockResolvedValueOnce({
+      pid: 5678,
+      output: "hello world\n",
+    });
+
+    await useBashStore.getState().executeCommand("echo hello world", "/home");
+    expect(apiClient.call).toHaveBeenCalledWith("bash.execute", { command: "echo hello world", cwd: "/home" });
+    const state = useBashStore.getState();
+    expect(state.processes.has(5678)).toBe(true);
+    expect(state.processes.get(5678)!.output).toBe("hello world\n");
+  });
+
+  it("should kill process via apiClient", async () => {
+    const { apiClient } = await import("../../lib/api-client");
+    const { useBashStore } = await import("../use-bash-store");
+    useBashStore.getState().addProcess(1234, "sleep 100");
+    (apiClient.call as ReturnType<typeof vi.fn>).mockResolvedValueOnce(undefined);
+
+    await useBashStore.getState().killProcess(1234);
+    expect(apiClient.call).toHaveBeenCalledWith("bash.kill", { pid: 1234 });
+    expect(useBashStore.getState().processes.get(1234)!.running).toBe(false);
+  });
+
+  it("should fetch processes", async () => {
+    const { apiClient } = await import("../../lib/api-client");
+    const { useBashStore } = await import("../use-bash-store");
+    (apiClient.call as ReturnType<typeof vi.fn>).mockResolvedValueOnce({
+      processes: [
+        { pid: 100, command: "ls", running: true },
+        { pid: 200, command: "pwd", running: false },
+      ],
+    });
+
+    await useBashStore.getState().fetchProcesses();
+    const state = useBashStore.getState();
+    expect(state.processes.size).toBe(2);
+    expect(state.processes.get(100)!.command).toBe("ls");
+    expect(state.processes.get(100)!.running).toBe(true);
+    expect(state.processes.get(200)!.running).toBe(false);
+  });
+});

package/templates/agent/src/mainview/stores/__tests__/use-connection-store.test.ts

@@ -0,0 +1,26 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+describe("useConnectionStore", () => {
+  beforeEach(async () => {
+    vi.resetModules();
+  });
+
+  it("should have initial state", async () => {
+    const { useConnectionStore } = await import("../use-connection-store");
+    const state = useConnectionStore.getState();
+    expect(state.mode).toBe("web");
+    expect(state.ready).toBe(false);
+  });
+
+  it("should set ready state", async () => {
+    const { useConnectionStore } = await import("../use-connection-store");
+    useConnectionStore.getState().setReady(true);
+    expect(useConnectionStore.getState().ready).toBe(true);
+  });
+
+  it("should set mode", async () => {
+    const { useConnectionStore } = await import("../use-connection-store");
+    useConnectionStore.getState().setMode("desktop");
+    expect(useConnectionStore.getState().mode).toBe("desktop");
+  });
+});

package/templates/agent/src/mainview/stores/__tests__/use-explorer-store.test.ts

@@ -0,0 +1,130 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+vi.mock("../../lib/api-client", () => ({
+  apiClient: {
+    call: vi.fn(),
+    getBaseUrl: vi.fn(() => "http://localhost:3000"),
+    getAuthToken: vi.fn(() => "test-token"),
+  },
+}));
+
+vi.mock("../use-log-store", () => ({
+  useLogStore: { getState: () => ({ addLog: vi.fn() }) },
+}));
+
+vi.mock("../use-connection-store", () => ({
+  useConnectionStore: { getState: () => ({ mode: "desktop" }) },
+}));
+
+describe("useExplorerStore", () => {
+  beforeEach(async () => {
+    vi.resetModules();
+  });
+
+  it("should have correct initial state", async () => {
+    const { useExplorerStore } = await import("../use-explorer-store");
+    const state = useExplorerStore.getState();
+    expect(state.treeNodes).toEqual([]);
+    expect(state.currentPath).toBe("");
+    expect(state.selectedPath).toBeNull();
+    expect(state.filePreview).toBeNull();
+    expect(state.loadingFile).toBe(false);
+    expect(state.editingNode).toBeNull();
+  });
+
+  it("should set currentPath", async () => {
+    const { useExplorerStore } = await import("../use-explorer-store");
+    useExplorerStore.getState().setCurrentPath("/home/user");
+    expect(useExplorerStore.getState().currentPath).toBe("/home/user");
+  });
+
+  it("should list root directory", async () => {
+    const { apiClient } = await import("../../lib/api-client");
+    const { useExplorerStore } = await import("../use-explorer-store");
+    const mockEntries = [
+      { name: "src", path: "/src", type: "directory" as const, size: 0 },
+      { name: "readme.md", path: "/readme.md", type: "file" as const, size: 100 },
+    ];
+    (apiClient.call as ReturnType<typeof vi.fn>).mockResolvedValueOnce({
+      entries: mockEntries,
+      basePath: "/root",
+    });
+
+    useExplorerStore.getState().setCurrentPath("/");
+    await useExplorerStore.getState().listRootDir();
+
+    const state = useExplorerStore.getState();
+    expect(state.treeNodes).toHaveLength(2);
+    expect(state.treeNodes[0].name).toBe("src");
+    expect(state.treeNodes[0].expanded).toBe(false);
+    expect(state.treeNodes[0].loaded).toBe(false);
+    expect(state.treeNodes[1].name).toBe("readme.md");
+    expect(state.currentPath).toBe("/root");
+  });
+
+  it("should toggle node to expand and load children", async () => {
+    const { apiClient } = await import("../../lib/api-client");
+    const { useExplorerStore } = await import("../use-explorer-store");
+
+    const rootNodes = [
+      { name: "src", path: "/src", type: "directory" as const, size: 0 },
+    ];
+    (apiClient.call as ReturnType<typeof vi.fn>).mockResolvedValueOnce({
+      entries: rootNodes,
+      basePath: "/",
+    });
+    await useExplorerStore.getState().listRootDir();
+
+    const childEntries = [
+      { name: "index.ts", path: "/src/index.ts", type: "file" as const, size: 50 },
+    ];
+    (apiClient.call as ReturnType<typeof vi.fn>).mockResolvedValueOnce({
+      entries: childEntries,
+    });
+
+    await useExplorerStore.getState().toggleNode("/src");
+
+    const state = useExplorerStore.getState();
+    expect(state.treeNodes[0].expanded).toBe(true);
+    expect(state.treeNodes[0].loaded).toBe(true);
+    expect(state.treeNodes[0].children).toHaveLength(1);
+    expect(state.treeNodes[0].children![0].name).toBe("index.ts");
+  });
+
+  it("should collapse an expanded node", async () => {
+    const { apiClient } = await import("../../lib/api-client");
+    const { useExplorerStore } = await import("../use-explorer-store");
+
+    (apiClient.call as ReturnType<typeof vi.fn>).mockResolvedValueOnce({
+      entries: [{ name: "src", path: "/src", type: "directory" as const, size: 0 }],
+      basePath: "/",
+    });
+    await useExplorerStore.getState().listRootDir();
+
+    (apiClient.call as ReturnType<typeof vi.fn>).mockResolvedValueOnce({
+      entries: [],
+    });
+    await useExplorerStore.getState().toggleNode("/src");
+    expect(useExplorerStore.getState().treeNodes[0].expanded).toBe(true);
+
+    await useExplorerStore.getState().toggleNode("/src");
+    expect(useExplorerStore.getState().treeNodes[0].expanded).toBe(false);
+  });
+
+  it("should start and cancel editing", async () => {
+    const { useExplorerStore } = await import("../use-explorer-store");
+    useExplorerStore.getState().startEditing("/src", "file");
+    expect(useExplorerStore.getState().editingNode).toEqual({ path: "/src", type: "file" });
+
+    useExplorerStore.getState().cancelEditing();
+    expect(useExplorerStore.getState().editingNode).toBeNull();
+  });
+
+  it("should close preview", async () => {
+    const { useExplorerStore } = await import("../use-explorer-store");
+    useExplorerStore.setState({ selectedPath: "/file.ts", filePreview: { path: "/file.ts", name: "file.ts" } as any });
+    useExplorerStore.getState().closePreview();
+    expect(useExplorerStore.getState().selectedPath).toBeNull();
+    expect(useExplorerStore.getState().filePreview).toBeNull();
+  });
+});

package/templates/agent/src/mainview/stores/__tests__/use-feed-store.test.ts

@@ -0,0 +1,132 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+vi.mock("../../lib/api-client", () => ({
+  apiClient: {
+    call: vi.fn(),
+    subscribe: vi.fn(() => "sub-id"),
+    unsubscribe: vi.fn(),
+  },
+}));
+
+describe("useFeedStore", () => {
+  beforeEach(async () => {
+    vi.resetModules();
+  });
+
+  it("should have correct initial state", async () => {
+    const { useFeedStore } = await import("../use-feed-store");
+    const state = useFeedStore.getState();
+    expect(state.posts).toEqual([]);
+    expect(state.author).toBe("alice");
+    expect(state.category).toBe("tech");
+    expect(state.content).toBe("");
+    expect(state.loading).toBe(false);
+  });
+
+  it("should set author, category, content", async () => {
+    const { useFeedStore } = await import("../use-feed-store");
+    const store = useFeedStore.getState();
+    store.setAuthor("bob");
+    store.setCategory("news");
+    store.setContent("hello world");
+    const state = useFeedStore.getState();
+    expect(state.author).toBe("bob");
+    expect(state.category).toBe("news");
+    expect(state.content).toBe("hello world");
+  });
+
+  it("should create post and clear content", async () => {
+    const { apiClient } = await import("../../lib/api-client");
+    const { useFeedStore } = await import("../use-feed-store");
+    (apiClient.call as ReturnType<typeof vi.fn>).mockResolvedValueOnce({ id: "post-1" });
+    useFeedStore.getState().setContent("  new post  ");
+
+    await useFeedStore.getState().createPost();
+    expect(apiClient.call).toHaveBeenCalledWith("feed.post", {
+      content: "new post",
+      category: "tech",
+      author: "alice",
+    });
+    expect(useFeedStore.getState().content).toBe("");
+    expect(useFeedStore.getState().loading).toBe(false);
+  });
+
+  it("should not create post with empty content", async () => {
+    const { apiClient } = await import("../../lib/api-client");
+    const { useFeedStore } = await import("../use-feed-store");
+
+    useFeedStore.setState({ content: "   " });
+    (apiClient.call as ReturnType<typeof vi.fn>).mockClear();
+
+    await useFeedStore.getState().createPost();
+    expect(apiClient.call).not.toHaveBeenCalled();
+  });
+
+  it("should load posts", async () => {
+    const { apiClient } = await import("../../lib/api-client");
+    const { useFeedStore } = await import("../use-feed-store");
+    const posts = [
+      { id: "1", content: "hello", category: "tech", author: "alice", timestamp: Date.now() },
+    ];
+    (apiClient.call as ReturnType<typeof vi.fn>).mockResolvedValueOnce({ posts });
+
+    await useFeedStore.getState().loadPosts();
+    expect(useFeedStore.getState().posts).toHaveLength(1);
+  });
+
+  it("should add a post locally", async () => {
+    const { useFeedStore } = await import("../use-feed-store");
+    const post = { id: "p1", content: "hi", category: "tech" as const, author: "alice", timestamp: Date.now() };
+    useFeedStore.getState().addPost(post);
+    expect(useFeedStore.getState().posts).toHaveLength(1);
+    expect(useFeedStore.getState().posts[0].id).toBe("p1");
+  });
+});
+
+describe("useEventStreamStore", () => {
+  beforeEach(async () => {
+    vi.resetModules();
+  });
+
+  it("should have correct initial state", async () => {
+    const { useEventStreamStore } = await import("../use-feed-store");
+    const state = useEventStreamStore.getState();
+    expect(state.entries).toEqual([]);
+    expect(state.activeEventType).toBe("feed.update");
+    expect(state.activeFilter).toBe("");
+    expect(state.subscriptionId).toBeNull();
+    expect(state.subscribed).toBe(false);
+  });
+
+  it("should set active event type and filter", async () => {
+    const { useEventStreamStore } = await import("../use-feed-store");
+    useEventStreamStore.getState().setActiveEventType("chat.message");
+    useEventStreamStore.getState().setActiveFilter('{"key":"val"}');
+    const state = useEventStreamStore.getState();
+    expect(state.activeEventType).toBe("chat.message");
+    expect(state.activeFilter).toBe('{"key":"val"}');
+  });
+
+  it("should subscribe and unsubscribe", async () => {
+    const { apiClient } = await import("../../lib/api-client");
+    const { useEventStreamStore } = await import("../use-feed-store");
+
+    await useEventStreamStore.getState().handleSubscribe();
+    expect(apiClient.subscribe).toHaveBeenCalled();
+    expect(useEventStreamStore.getState().subscribed).toBe(true);
+    expect(useEventStreamStore.getState().subscriptionId).toBe("sub-id");
+
+    useEventStreamStore.getState().handleUnsubscribe();
+    expect(apiClient.unsubscribe).toHaveBeenCalledWith("sub-id");
+    expect(useEventStreamStore.getState().subscribed).toBe(false);
+    expect(useEventStreamStore.getState().subscriptionId).toBeNull();
+  });
+
+  it("should add entries keeping max 50", async () => {
+    const { useEventStreamStore } = await import("../use-feed-store");
+    for (let i = 0; i < 55; i++) {
+      useEventStreamStore.getState().addEntry("feed.update", { i }, {});
+    }
+    expect(useEventStreamStore.getState().entries.length).toBeLessThanOrEqual(50);
+  });
+});