@dyyz1993/create-agent 1.9.0

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

@@ -0,0 +1,161 @@
+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("useGitStore", () => {
+  beforeEach(async () => {
+    vi.resetModules();
+  });
+
+  it("should have correct initial state", async () => {
+    const { useGitStore } = await import("../use-git-store");
+    const state = useGitStore.getState();
+    expect(state.branch).toBe("");
+    expect(state.ahead).toBe(0);
+    expect(state.behind).toBe(0);
+    expect(state.staged).toEqual([]);
+    expect(state.changed).toEqual([]);
+    expect(state.untracked).toEqual([]);
+    expect(state.commits).toEqual([]);
+    expect(state.loadingCommits).toBe(false);
+    expect(state.currentDiff).toBeNull();
+    expect(state.loadingDiff).toBe(false);
+    expect(state.branches).toEqual([]);
+    expect(state.worktrees).toEqual([]);
+    expect(state.loadingAction).toBeNull();
+  });
+
+  it("should fetch status", async () => {
+    const { apiClient } = await import("../../lib/api-client");
+    const { useGitStore } = await import("../use-git-store");
+    (apiClient.call as ReturnType<typeof vi.fn>).mockResolvedValueOnce({
+      branch: "main",
+      ahead: 2,
+      behind: 1,
+      staged: [{ path: "a.ts", status: "modified" }],
+      changed: [{ path: "b.ts", status: "added" }],
+      untracked: ["c.ts"],
+    });
+
+    await useGitStore.getState().fetchStatus("/repo");
+    const state = useGitStore.getState();
+    expect(state.branch).toBe("main");
+    expect(state.ahead).toBe(2);
+    expect(state.behind).toBe(1);
+    expect(state.staged).toHaveLength(1);
+    expect(state.untracked).toEqual(["c.ts"]);
+  });
+
+  it("should fetch diff", async () => {
+    const { apiClient } = await import("../../lib/api-client");
+    const { useGitStore } = await import("../use-git-store");
+    (apiClient.call as ReturnType<typeof vi.fn>).mockResolvedValueOnce({
+      filePath: "a.ts",
+      diff: "+hello",
+      oldContent: "",
+      newContent: "hello",
+    });
+
+    await useGitStore.getState().fetchDiff("/repo", "a.ts");
+    const state = useGitStore.getState();
+    expect(state.currentDiff).not.toBeNull();
+    expect(state.currentDiff!.filePath).toBe("a.ts");
+    expect(state.loadingDiff).toBe(false);
+  });
+
+  it("should clear diff", async () => {
+    const { useGitStore } = await import("../use-git-store");
+    useGitStore.setState({ currentDiff: { filePath: "a.ts", diff: "", oldContent: "", newContent: "" } });
+    useGitStore.getState().clearDiff();
+    expect(useGitStore.getState().currentDiff).toBeNull();
+  });
+
+  it("should fetch log", async () => {
+    const { apiClient } = await import("../../lib/api-client");
+    const { useGitStore } = await import("../use-git-store");
+    const commits = [
+      { hash: "abc123", shortHash: "abc1234", message: "init", author: "user", date: "2024-01-01" },
+    ];
+    (apiClient.call as ReturnType<typeof vi.fn>).mockResolvedValueOnce({ commits });
+
+    await useGitStore.getState().fetchLog("/repo");
+    expect(useGitStore.getState().commits).toHaveLength(1);
+    expect(useGitStore.getState().loadingCommits).toBe(false);
+  });
+
+  it("should stage files and refresh", async () => {
+    const { apiClient } = await import("../../lib/api-client");
+    const { useGitStore } = await import("../use-git-store");
+    const callMock = apiClient.call as ReturnType<typeof vi.fn>;
+    callMock.mockResolvedValueOnce(undefined);
+    callMock.mockResolvedValueOnce({
+      branch: "main", ahead: 0, behind: 0, staged: [], changed: [], untracked: [],
+    });
+
+    await useGitStore.getState().stageFiles("/repo", ["a.ts"]);
+    expect(callMock).toHaveBeenCalledWith("git.add", { repoPath: "/repo", paths: ["a.ts"] });
+    expect(useGitStore.getState().loadingAction).toBeNull();
+  });
+
+  it("should unstage files and refresh", async () => {
+    const { apiClient } = await import("../../lib/api-client");
+    const { useGitStore } = await import("../use-git-store");
+    const callMock = apiClient.call as ReturnType<typeof vi.fn>;
+    callMock.mockResolvedValueOnce(undefined);
+    callMock.mockResolvedValueOnce({
+      branch: "main", ahead: 0, behind: 0, staged: [], changed: [], untracked: [],
+    });
+
+    await useGitStore.getState().unstageFiles("/repo", ["a.ts"]);
+    expect(callMock).toHaveBeenCalledWith("git.reset", { repoPath: "/repo", paths: ["a.ts"] });
+    expect(useGitStore.getState().loadingAction).toBeNull();
+  });
+
+  it("should commit and refresh", async () => {
+    const { apiClient } = await import("../../lib/api-client");
+    const { useGitStore } = await import("../use-git-store");
+    const callMock = apiClient.call as ReturnType<typeof vi.fn>;
+    callMock.mockResolvedValueOnce({ shortHash: "abc1234" });
+    callMock.mockResolvedValueOnce({
+      branch: "main", ahead: 0, behind: 0, staged: [], changed: [], untracked: [],
+    });
+
+    await useGitStore.getState().commit("/repo", "init commit");
+    expect(callMock).toHaveBeenCalledWith("git.commit", { repoPath: "/repo", message: "init commit" });
+    expect(useGitStore.getState().loadingAction).toBeNull();
+  });
+
+  it("should toggle commit expand and load files", async () => {
+    const { apiClient } = await import("../../lib/api-client");
+    const { useGitStore } = await import("../use-git-store");
+    (apiClient.call as ReturnType<typeof vi.fn>).mockResolvedValueOnce({
+      files: [{ path: "a.ts", status: "modified" }],
+    });
+
+    await useGitStore.getState().toggleCommitExpand("/repo", "abc123");
+    const state = useGitStore.getState();
+    expect(state.expandedCommits.has("abc123")).toBe(true);
+    expect(state.commitFiles["abc123"]).toHaveLength(1);
+  });
+
+  it("should fetch branches", async () => {
+    const { apiClient } = await import("../../lib/api-client");
+    const { useGitStore } = await import("../use-git-store");
+    (apiClient.call as ReturnType<typeof vi.fn>).mockResolvedValueOnce({
+      branches: [
+        { name: "main", isCurrent: true, isRemote: false },
+        { name: "dev", isCurrent: false, isRemote: false },
+      ],
+    });
+
+    await useGitStore.getState().fetchBranches("/repo");
+    expect(useGitStore.getState().branches).toHaveLength(2);
+    expect(useGitStore.getState().loadingBranches).toBe(false);
+  });
+});

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

@@ -0,0 +1,32 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+
+describe("useLocaleStore", () => {
+  beforeEach(async () => {
+    vi.resetModules();
+    localStorage.clear();
+  });
+
+  it("should default to English", async () => {
+    const { useLocaleStore } = await import("../use-locale-store");
+    expect(useLocaleStore.getState().locale).toBe("en");
+  });
+
+  it("should change locale", async () => {
+    const { useLocaleStore } = await import("../use-locale-store");
+    useLocaleStore.getState().setLocale("zh");
+    expect(useLocaleStore.getState().locale).toBe("zh");
+  });
+
+  it("should persist locale to localStorage", async () => {
+    const { useLocaleStore } = await import("../use-locale-store");
+    useLocaleStore.getState().setLocale("zh");
+    expect(localStorage.getItem("locale")).toBe("zh");
+  });
+
+  it("should restore locale from localStorage", async () => {
+    localStorage.setItem("locale", "zh");
+    vi.resetModules();
+    const { useLocaleStore } = await import("../use-locale-store");
+    expect(useLocaleStore.getState().locale).toBe("zh");
+  });
+});

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

@@ -0,0 +1,28 @@
+import { describe, it, expect, beforeEach } from "vitest";
+
+describe("useLogStore", () => {
+  beforeEach(async () => {
+    vi.resetModules();
+  });
+
+  it("should start with empty logs", async () => {
+    const { useLogStore } = await import("../use-log-store");
+    expect(useLogStore.getState().logs).toEqual([]);
+  });
+
+  it("should add log entries", async () => {
+    const { useLogStore } = await import("../use-log-store");
+    useLogStore.getState().addLog("test message");
+    const logs = useLogStore.getState().logs;
+    expect(logs).toHaveLength(1);
+    expect(logs[0]).toContain("test message");
+  });
+
+  it("should limit log entries", async () => {
+    const { useLogStore } = await import("../use-log-store");
+    for (let i = 0; i < 200; i++) {
+      useLogStore.getState().addLog(`log ${i}`);
+    }
+    expect(useLogStore.getState().logs.length).toBeLessThanOrEqual(100);
+  });
+});

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

@@ -0,0 +1,102 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+describe("useNotificationStore", () => {
+  beforeEach(async () => {
+    vi.resetModules();
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("should have correct initial state", async () => {
+    const { useNotificationStore } = await import("../use-notification-store");
+    const state = useNotificationStore.getState();
+    expect(state.notifications).toEqual([]);
+    expect(state.panelOpen).toBe(false);
+  });
+
+  it("should push a notification", async () => {
+    const { useNotificationStore } = await import("../use-notification-store");
+    useNotificationStore.getState().push({ message: "hello", level: "info" });
+    const state = useNotificationStore.getState();
+    expect(state.notifications).toHaveLength(1);
+    expect(state.notifications[0].message).toBe("hello");
+    expect(state.notifications[0].level).toBe("info");
+    expect(state.notifications[0].read).toBe(false);
+    expect(state.notifications[0].id).toMatch(/^notif-/);
+  });
+
+  it("should auto-dismiss info notifications after 5s", async () => {
+    const { useNotificationStore } = await import("../use-notification-store");
+    useNotificationStore.getState().push({ message: "temp", level: "info" });
+    expect(useNotificationStore.getState().notifications).toHaveLength(1);
+
+    vi.advanceTimersByTime(5000);
+    expect(useNotificationStore.getState().notifications).toHaveLength(0);
+  });
+
+  it("should not auto-dismiss warning/error notifications", async () => {
+    const { useNotificationStore } = await import("../use-notification-store");
+    useNotificationStore.getState().push({ message: "warn", level: "warning" });
+    useNotificationStore.getState().push({ message: "err", level: "error" });
+
+    vi.advanceTimersByTime(10000);
+    expect(useNotificationStore.getState().notifications).toHaveLength(2);
+  });
+
+  it("should mark a notification as read", async () => {
+    const { useNotificationStore } = await import("../use-notification-store");
+    useNotificationStore.getState().push({ message: "test", level: "warning" });
+    const id = useNotificationStore.getState().notifications[0].id;
+
+    useNotificationStore.getState().markRead(id);
+    expect(useNotificationStore.getState().notifications[0].read).toBe(true);
+  });
+
+  it("should mark all notifications as read", async () => {
+    const { useNotificationStore } = await import("../use-notification-store");
+    useNotificationStore.getState().push({ message: "a", level: "warning" });
+    useNotificationStore.getState().push({ message: "b", level: "error" });
+
+    useNotificationStore.getState().markAllRead();
+    const state = useNotificationStore.getState();
+    expect(state.notifications.every((n) => n.read)).toBe(true);
+  });
+
+  it("should dismiss a notification", async () => {
+    const { useNotificationStore } = await import("../use-notification-store");
+    useNotificationStore.getState().push({ message: "bye", level: "warning" });
+    const id = useNotificationStore.getState().notifications[0].id;
+
+    useNotificationStore.getState().dismiss(id);
+    expect(useNotificationStore.getState().notifications).toHaveLength(0);
+  });
+
+  it("should clear all notifications", async () => {
+    const { useNotificationStore } = await import("../use-notification-store");
+    useNotificationStore.getState().push({ message: "a", level: "error" });
+    useNotificationStore.getState().push({ message: "b", level: "error" });
+
+    useNotificationStore.getState().clearAll();
+    expect(useNotificationStore.getState().notifications).toHaveLength(0);
+  });
+
+  it("should toggle panel", async () => {
+    const { useNotificationStore } = await import("../use-notification-store");
+    expect(useNotificationStore.getState().panelOpen).toBe(false);
+    useNotificationStore.getState().togglePanel();
+    expect(useNotificationStore.getState().panelOpen).toBe(true);
+    useNotificationStore.getState().togglePanel();
+    expect(useNotificationStore.getState().panelOpen).toBe(false);
+  });
+
+  it("should set panel open explicitly", async () => {
+    const { useNotificationStore } = await import("../use-notification-store");
+    useNotificationStore.getState().setPanelOpen(true);
+    expect(useNotificationStore.getState().panelOpen).toBe(true);
+    useNotificationStore.getState().setPanelOpen(false);
+    expect(useNotificationStore.getState().panelOpen).toBe(false);
+  });
+});

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

@@ -0,0 +1,75 @@
+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("useRulesStore", () => {
+  beforeEach(async () => {
+    vi.resetModules();
+  });
+
+  it("should have correct initial state", async () => {
+    const { useRulesStore } = await import("../use-rules-store");
+    expect(useRulesStore.getState().rules).toEqual([]);
+  });
+
+  it("should fetch rules", async () => {
+    const { apiClient } = await import("../../lib/api-client");
+    const { useRulesStore } = await import("../use-rules-store");
+    const rules = [
+      { id: "r1", name: "no-console", pattern: "**/*.ts", enabled: true },
+    ];
+    (apiClient.call as ReturnType<typeof vi.fn>).mockResolvedValueOnce({ rules });
+
+    await useRulesStore.getState().fetchRules();
+    expect(useRulesStore.getState().rules).toHaveLength(1);
+    expect(useRulesStore.getState().rules[0].name).toBe("no-console");
+  });
+
+  it("should add a rule", async () => {
+    const { apiClient } = await import("../../lib/api-client");
+    const { useRulesStore } = await import("../use-rules-store");
+    const newRule = { id: "r2", name: "test-rule", pattern: "*.js", enabled: true };
+    (apiClient.call as ReturnType<typeof vi.fn>).mockResolvedValueOnce({ rule: newRule });
+
+    await useRulesStore.getState().addRule("test-rule", "*.js");
+    expect(useRulesStore.getState().rules).toHaveLength(1);
+    expect(useRulesStore.getState().rules[0].id).toBe("r2");
+    expect(apiClient.call).toHaveBeenCalledWith("rules.add", { name: "test-rule", pattern: "*.js" });
+  });
+
+  it("should toggle a rule", async () => {
+    const { apiClient } = await import("../../lib/api-client");
+    const { useRulesStore } = await import("../use-rules-store");
+    useRulesStore.setState({
+      rules: [{ id: "r1", name: "rule", pattern: "*.ts", enabled: true }],
+    });
+    (apiClient.call as ReturnType<typeof vi.fn>).mockResolvedValueOnce({
+      rule: { id: "r1", name: "rule", pattern: "*.ts", enabled: false },
+    });
+
+    await useRulesStore.getState().toggleRule("r1");
+    expect(useRulesStore.getState().rules[0].enabled).toBe(false);
+  });
+
+  it("should remove a rule", async () => {
+    const { apiClient } = await import("../../lib/api-client");
+    const { useRulesStore } = await import("../use-rules-store");
+    useRulesStore.setState({
+      rules: [
+        { id: "r1", name: "a", pattern: "*.ts", enabled: true },
+        { id: "r2", name: "b", pattern: "*.js", enabled: false },
+      ],
+    });
+    (apiClient.call as ReturnType<typeof vi.fn>).mockResolvedValueOnce({ success: true });
+
+    await useRulesStore.getState().removeRule("r1");
+    expect(useRulesStore.getState().rules).toHaveLength(1);
+    expect(useRulesStore.getState().rules[0].id).toBe("r2");
+  });
+});

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

@@ -0,0 +1,59 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+
+describe("useThemeStore", () => {
+  beforeEach(async () => {
+    vi.resetModules();
+    localStorage.clear();
+    document.documentElement.classList.remove("dark");
+  });
+
+  it("should default to dark theme", async () => {
+    const { useThemeStore } = await import("../use-theme-store");
+    const state = useThemeStore.getState();
+    expect(state.theme).toBe("dark");
+  });
+
+  it("should toggle between light and dark", async () => {
+    const { useThemeStore } = await import("../use-theme-store");
+    const store = useThemeStore.getState();
+
+    expect(store.theme).toBe("dark");
+    store.toggleTheme();
+    expect(useThemeStore.getState().theme).toBe("light");
+
+    useThemeStore.getState().toggleTheme();
+    expect(useThemeStore.getState().theme).toBe("dark");
+  });
+
+  it("should set theme explicitly", async () => {
+    const { useThemeStore } = await import("../use-theme-store");
+    useThemeStore.getState().setTheme("light");
+    expect(useThemeStore.getState().theme).toBe("light");
+  });
+
+  it("should persist theme to localStorage", async () => {
+    const { useThemeStore } = await import("../use-theme-store");
+    useThemeStore.getState().setTheme("light");
+
+    expect(localStorage.getItem("theme")).toBe("light");
+  });
+
+  it("should restore theme from localStorage", async () => {
+    localStorage.setItem("theme", "light");
+
+    vi.resetModules();
+    const { useThemeStore } = await import("../use-theme-store");
+
+    expect(useThemeStore.getState().theme).toBe("light");
+  });
+
+  it("should apply dark class to document element", async () => {
+    const { useThemeStore } = await import("../use-theme-store");
+    useThemeStore.getState().setTheme("dark");
+
+    expect(document.documentElement.classList.contains("dark")).toBe(true);
+
+    useThemeStore.getState().setTheme("light");
+    expect(document.documentElement.classList.contains("dark")).toBe(false);
+  });
+});

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

@@ -0,0 +1,75 @@
+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("useTodoStore", () => {
+  beforeEach(async () => {
+    vi.resetModules();
+  });
+
+  it("should have correct initial state", async () => {
+    const { useTodoStore } = await import("../use-todo-store");
+    expect(useTodoStore.getState().items).toEqual([]);
+  });
+
+  it("should fetch items", async () => {
+    const { apiClient } = await import("../../lib/api-client");
+    const { useTodoStore } = await import("../use-todo-store");
+    const items = [
+      { id: "t1", content: "task 1", status: "pending", createdAt: Date.now() },
+    ];
+    (apiClient.call as ReturnType<typeof vi.fn>).mockResolvedValueOnce({ items });
+
+    await useTodoStore.getState().fetchItems();
+    expect(useTodoStore.getState().items).toHaveLength(1);
+    expect(useTodoStore.getState().items[0].content).toBe("task 1");
+  });
+
+  it("should add an item", async () => {
+    const { apiClient } = await import("../../lib/api-client");
+    const { useTodoStore } = await import("../use-todo-store");
+    const newItem = { id: "t2", content: "new task", status: "pending" as const, createdAt: Date.now() };
+    (apiClient.call as ReturnType<typeof vi.fn>).mockResolvedValueOnce({ item: newItem });
+
+    await useTodoStore.getState().addItem("new task");
+    expect(useTodoStore.getState().items).toHaveLength(1);
+    expect(useTodoStore.getState().items[0].id).toBe("t2");
+    expect(apiClient.call).toHaveBeenCalledWith("todo.add", { content: "new task" });
+  });
+
+  it("should update an item status", async () => {
+    const { apiClient } = await import("../../lib/api-client");
+    const { useTodoStore } = await import("../use-todo-store");
+    useTodoStore.setState({
+      items: [{ id: "t1", content: "task", status: "pending", createdAt: Date.now() }],
+    });
+    (apiClient.call as ReturnType<typeof vi.fn>).mockResolvedValueOnce({
+      item: { id: "t1", content: "task", status: "completed", createdAt: Date.now() },
+    });
+
+    await useTodoStore.getState().updateItem("t1", "completed");
+    expect(useTodoStore.getState().items[0].status).toBe("completed");
+  });
+
+  it("should remove an item", async () => {
+    const { apiClient } = await import("../../lib/api-client");
+    const { useTodoStore } = await import("../use-todo-store");
+    useTodoStore.setState({
+      items: [
+        { id: "t1", content: "a", status: "pending", createdAt: Date.now() },
+        { id: "t2", content: "b", status: "completed", createdAt: Date.now() },
+      ],
+    });
+    (apiClient.call as ReturnType<typeof vi.fn>).mockResolvedValueOnce({ success: true });
+
+    await useTodoStore.getState().removeItem("t1");
+    expect(useTodoStore.getState().items).toHaveLength(1);
+    expect(useTodoStore.getState().items[0].id).toBe("t2");
+  });
+});

package/templates/agent/src/mainview/stores/message-batcher.ts

@@ -0,0 +1,25 @@
+type Update = { sessionId: string; apply: () => void };
+
+let queue: Update[] = [];
+let rafId: number | null = null;
+
+function flush() {
+  rafId = null;
+  const batch = queue;
+  queue = [];
+  for (const u of batch) u.apply();
+}
+
+export function batchMessageUpdate(sessionId: string, apply: () => void) {
+  queue.push({ sessionId, apply });
+  if (!rafId) {
+    rafId = requestAnimationFrame(flush);
+  }
+}
+
+export function flushNow() {
+  if (rafId) {
+    cancelAnimationFrame(rafId);
+    flush();
+  }
+}

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

@@ -0,0 +1,99 @@
+import { create } from "zustand";
+import { apiClient } from "../lib/api-client";
+import type { RPCMethods } from "../lib/api-client";
+import type { MethodResult } from "@dyyzz1993/rpc-core";
+import type { DemoMethod } from "../types";
+import { useLogStore } from "./use-log-store";
+
+type DemoResult = MethodResult<RPCMethods, "system.ping">
+  | MethodResult<RPCMethods, "system.hello">
+  | MethodResult<RPCMethods, "system.echo">
+  | MethodResult<RPCMethods, "chat.send">;
+
+interface AppState {
+  method: DemoMethod;
+  result: DemoResult | null;
+  tickEvents: string[];
+  tickCount: number;
+  subscriptionId: string | null;
+  timerRunning: boolean;
+
+  setMethod: (method: DemoMethod) => void;
+  callRPC: (inputText: string) => Promise<void>;
+  handleSubscribe: () => Promise<void>;
+  handleUnsubscribe: () => Promise<void>;
+}
+
+export const useAppStore = create<AppState>((set, get) => ({
+  method: "system.ping",
+  result: null,
+  tickEvents: [],
+  tickCount: 0,
+  subscriptionId: null,
+  timerRunning: false,
+
+  setMethod: (method) => set({ method }),
+
+  callRPC: async (inputText: string) => {
+    const { method } = get();
+    const addLog = useLogStore.getState().addLog;
+    addLog(`RPC call: ${method}`);
+    try {
+      addLog(`Calling: ${method}...`);
+      let res: DemoResult;
+      if (method === "system.ping") {
+        res = await apiClient.call("system.ping", {});
+      } else if (method === "system.hello") {
+        res = await apiClient.call("system.hello", {});
+      } else if (method === "system.echo") {
+        res = await apiClient.call("system.echo", {});
+      } else if (method === "chat.send") {
+        const content = inputText.trim() || "Hello from RPC";
+        res = await apiClient.call("chat.send", { content });
+      }
+      set({ result: res });
+      addLog(`Result: ${JSON.stringify(res)}`);
+    } catch (err) {
+      addLog(`Error: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  },
+
+  handleSubscribe: async () => {
+    const addLog = useLogStore.getState().addLog;
+    try {
+      addLog("Subscribing to tick events...");
+      await apiClient.call("timer.start", {});
+      set({ timerRunning: true });
+      addLog("Timer started");
+
+      const subId = await apiClient.subscribe("timer.tick", (payload) => {
+        const time = new Date(payload.timestamp).toLocaleTimeString();
+        set((s) => ({
+          tickEvents: [...s.tickEvents.slice(-19), `#${payload.count} @ ${time}`],
+          tickCount: s.tickCount + 1,
+        }));
+      }, {});
+      set({ subscriptionId: subId });
+      addLog(`Subscribed: ${subId}`);
+    } catch (err) {
+      addLog(`Subscribe error: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  },
+
+  handleUnsubscribe: async () => {
+    const { subscriptionId } = get();
+    const addLog = useLogStore.getState().addLog;
+    try {
+      if (subscriptionId) {
+        apiClient.unsubscribe(subscriptionId);
+        set({ subscriptionId: null });
+        addLog("Unsubscribed");
+      }
+      await apiClient.call("timer.stop", {});
+      set({ timerRunning: false });
+      addLog("Timer stopped");
+    } catch (err) {
+      addLog(`Unsubscribe error: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  },
+}));