@nextclaw/ui 0.20.3 → 0.21.0

package/src/features/chat/managers/__tests__/chat-thread-deletion.manager.test.ts

@@ -0,0 +1,125 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { appQueryClient } from "@/app-query-client";
+import { ChatThreadManager } from "@/features/chat/managers/chat-thread.manager";
+import { useChatSessionListStore } from "@/features/chat/stores/chat-session-list.store";
+import { useChatThreadStore } from "@/features/chat/stores/chat-thread.store";
+import type * as SharedApi from "@/shared/lib/api";
+
+const { deleteNcpSessionMock, deleteSummaryMock, toast } = vi.hoisted(() => ({
+  deleteNcpSessionMock: vi.fn(),
+  deleteSummaryMock: vi.fn(),
+  toast: { success: vi.fn(), error: vi.fn() },
+}));
+
+vi.mock("@/shared/lib/api", async (importOriginal) => {
+  const actual = await importOriginal<typeof SharedApi>();
+  return {
+    ...actual,
+    deleteNcpSession: deleteNcpSessionMock,
+    deleteNcpSessionSummaryInQueryClient: deleteSummaryMock,
+  };
+});
+
+vi.mock("sonner", () => ({ toast }));
+
+function createUiManager() {
+  return {
+    confirm: vi.fn(async () => true),
+    goToChatRoot: vi.fn(),
+  } as unknown as ConstructorParameters<typeof ChatThreadManager>[0];
+}
+
+beforeEach(() => {
+  deleteNcpSessionMock.mockReset();
+  deleteNcpSessionMock.mockResolvedValue({
+    deleted: true,
+    sessionId: "parent-session-1",
+  });
+  deleteSummaryMock.mockReset();
+  toast.success.mockReset();
+  toast.error.mockReset();
+  useChatSessionListStore.setState({
+    snapshot: {
+      ...useChatSessionListStore.getInitialState().snapshot,
+      selectedSessionKey: "parent-session-1",
+    },
+  });
+  useChatThreadStore.setState({
+    snapshot: {
+      ...useChatThreadStore.getInitialState().snapshot,
+      sessionKey: "parent-session-1",
+      canDeleteSession: true,
+      childSessionTabs: [
+        {
+          sessionKey: "child-session-1",
+          parentSessionKey: "parent-session-1",
+          label: "Child Session 1",
+          agentId: "reviewer",
+        },
+      ],
+    },
+  });
+});
+
+describe("ChatThreadManager deletion", () => {
+  it("clears the current thread and confirms the deletion", async () => {
+    const uiManager = createUiManager();
+    const removeQueries = vi
+      .spyOn(appQueryClient, "removeQueries")
+      .mockImplementation(async () => undefined);
+    const manager = new ChatThreadManager(
+      uiManager,
+      {} as ConstructorParameters<typeof ChatThreadManager>[1],
+    );
+
+    await manager.deleteSession();
+
+    expect(useChatThreadStore.getState().snapshot.sessionKey).toBeNull();
+    expect(deleteSummaryMock).toHaveBeenCalledWith(
+      appQueryClient,
+      "parent-session-1",
+    );
+    expect(removeQueries).toHaveBeenCalledWith({
+      queryKey: ["ncp-session-messages", "parent-session-1"],
+    });
+    expect(uiManager.goToChatRoot).toHaveBeenCalledWith({ replace: true });
+    expect(toast.success).toHaveBeenCalledWith("Session deleted.");
+  });
+
+  it("preserves the current thread when deleting another session", async () => {
+    const uiManager = createUiManager();
+    const manager = new ChatThreadManager(
+      uiManager,
+      {} as ConstructorParameters<typeof ChatThreadManager>[1],
+    );
+
+    await manager.deleteSession("other-session-1");
+
+    expect(deleteNcpSessionMock).toHaveBeenCalledWith("other-session-1");
+    expect(useChatThreadStore.getState().snapshot.sessionKey).toBe(
+      "parent-session-1",
+    );
+    expect(uiManager.goToChatRoot).not.toHaveBeenCalled();
+  });
+
+  it("keeps the session visible and reports a deletion error", async () => {
+    deleteNcpSessionMock.mockRejectedValueOnce(
+      new Error("network unavailable"),
+    );
+    const uiManager = createUiManager();
+    const manager = new ChatThreadManager(
+      uiManager,
+      {} as ConstructorParameters<typeof ChatThreadManager>[1],
+    );
+
+    await manager.deleteSession();
+
+    expect(useChatThreadStore.getState().snapshot.sessionKey).toBe(
+      "parent-session-1",
+    );
+    expect(uiManager.goToChatRoot).not.toHaveBeenCalled();
+    expect(toast.error).toHaveBeenCalledWith(
+      "Could not delete session: network unavailable",
+    );
+  });
+});

package/src/features/chat/managers/__tests__/chat-thread.manager.test.ts

@@ -1,5 +1,4 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { appQueryClient } from '@/app-query-client';
 import { ChatThreadManager } from '@/features/chat/managers/chat-thread.manager';
 import { useChatSessionListStore } from '@/features/chat/stores/chat-session-list.store';
 import { useChatThreadStore } from '@/features/chat/stores/chat-thread.store';
@@ -841,39 +840,3 @@ describe('ChatThreadManager visible workspace selection', () => {
     expect(sessionListManager.markVisibleWorkspaceChildRead).toHaveBeenCalledWith(tab);
   });
 });
-
-describe('ChatThreadManager deletion', () => {
-  it('clears thread state while leaving route-derived selection to navigation', async () => {
-    const removeQueries = vi.spyOn(appQueryClient, 'removeQueries').mockImplementation(async () => undefined);
-    const uiManager = {
-      goToSession: vi.fn(),
-      goToChatRoot: vi.fn(),
-      goToProviders: vi.fn(),
-      confirm: vi.fn(async () => true),
-    } as unknown as ConstructorParameters<typeof ChatThreadManager>[0];
-    const sessionListManager = {} as ConstructorParameters<typeof ChatThreadManager>[1];
-    const manager = new ChatThreadManager(uiManager, sessionListManager);
-
-    await manager.deleteSession();
-
-    expect(useChatSessionListStore.getState().snapshot.selectedSessionKey).toBe('parent-session-1');
-    expect(useChatThreadStore.getState().snapshot).toMatchObject({
-      sessionKey: null,
-      canDeleteSession: false,
-      workspacePanelParentKey: null,
-      childSessionTabs: [],
-      activeChildSessionKey: null,
-      workspaceFileTabs: [],
-      activeWorkspaceFileKey: null,
-      workspaceNavigationHistory: [],
-      workspaceNavigationHistoryIndex: 0,
-    });
-    expect(deleteSummaryMock).toHaveBeenCalledWith(appQueryClient, 'parent-session-1');
-    expect(removeQueries).toHaveBeenCalledWith({
-      queryKey: ['ncp-session-messages', 'parent-session-1'],
-    });
-    expect(uiManager.goToChatRoot).toHaveBeenCalledWith({ replace: true });
-
-    removeQueries.mockRestore();
-  });
-});

package/src/features/chat/managers/chat-thread.manager.ts

@@ -1,5 +1,6 @@
 import { appQueryClient } from '@/app-query-client';
 import { deleteNcpSession as deleteNcpSessionApi, deleteNcpSessionSummaryInQueryClient } from '@/shared/lib/api';
+import { toast } from 'sonner';
 import type {
   ChatFileOpenActionViewModel,
   ChatUiShowContentRequest,
@@ -17,6 +18,7 @@ import type {
   ChatWorkspaceFileTab,
 } from '@/features/chat/stores/chat-thread.store';
 import { useChatThreadStore } from '@/features/chat/stores/chat-thread.store';
+import { createDeletedChatThreadStatePatch } from '@/features/chat/features/session/utils/chat-session-deletion.utils';
 import {
   normalizeChatWorkspaceExplorerWidth,
   normalizeChatWorkspacePanelWidth,
@@ -80,27 +82,7 @@ export class ChatThreadManager {
   };
 
   private clearDeletedSessionState = () => {
-    useChatThreadStore.getState().setSnapshot({
-      sessionKey: null,
-      sessionTypeLabel: null,
-      agentId: null,
-      sessionDisplayName: undefined,
-      draftProjectRoot: null,
-      sessionProjectName: null,
-      canDeleteSession: false,
-      parentSessionKey: null,
-      parentSessionLabel: null,
-      workspacePanelParentKey: null,
-      activeWorkspacePanelKind: null,
-      childSessionTabs: [],
-      activeChildSessionKey: null,
-      activeSideChatDraft: null,
-      workspaceFileTabs: [],
-      activeWorkspaceFileKey: null,
-      closedWorkspaceTabEntries: [],
-      workspaceNavigationHistory: [],
-      workspaceNavigationHistoryIndex: 0,
-    });
+    useChatThreadStore.getState().setSnapshot(createDeletedChatThreadStatePatch());
   };
 
   private resolveWorkspaceParentSessionKey = (): string | null => {
@@ -565,11 +547,12 @@ export class ChatThreadManager {
     this.uiManager.goToSession(resolvedParentSessionKey);
   };
 
-  deleteSession = async () => {
+  deleteSession = async (rawSessionKey?: string) => {
     const {
       snapshot: { selectedSessionKey },
     } = useChatSessionListStore.getState();
-    if (!selectedSessionKey) {
+    const sessionKey = rawSessionKey?.trim() || selectedSessionKey;
+    if (!sessionKey) {
       return;
     }
     const confirmed = await this.uiManager.confirm({
@@ -582,13 +565,19 @@ export class ChatThreadManager {
     }
     useChatThreadStore.getState().setSnapshot({ isDeletePending: true });
     try {
-      await deleteNcpSessionApi(selectedSessionKey);
-      deleteNcpSessionSummaryInQueryClient(appQueryClient, selectedSessionKey);
+      await deleteNcpSessionApi(sessionKey);
+      deleteNcpSessionSummaryInQueryClient(appQueryClient, sessionKey);
       appQueryClient.removeQueries({
-        queryKey: ['ncp-session-messages', selectedSessionKey],
+        queryKey: ['ncp-session-messages', sessionKey],
       });
-      this.clearDeletedSessionState();
-      this.uiManager.goToChatRoot({ replace: true });
+      toast.success(t('chatDeleteSessionSucceeded'));
+      if (sessionKey === selectedSessionKey) {
+        this.clearDeletedSessionState();
+        this.uiManager.goToChatRoot({ replace: true });
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      toast.error(`${t('chatDeleteSessionFailed')}: ${message}`);
     } finally {
       useChatThreadStore.getState().setSnapshot({ isDeletePending: false });
     }

package/src/features/desktop-capabilities/components/desktop-authorization-dialog.test.tsx

@@ -0,0 +1,58 @@
+import { fireEvent, render, screen, waitFor } from "@testing-library/react";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { DesktopAuthorizationDialog } from "./desktop-authorization-dialog";
+import { useDesktopAuthorizationStore } from "../stores/desktop-authorization.store";
+
+const mocks = vi.hoisted(() => ({ grantAccess: vi.fn() }));
+
+vi.mock("../managers/desktop-capability.manager", () => ({
+  desktopCapabilityManager: {
+    grantAccess: mocks.grantAccess,
+  },
+}));
+
+describe("DesktopAuthorizationDialog", () => {
+  beforeEach(() => {
+    mocks.grantAccess.mockReset();
+    mocks.grantAccess.mockResolvedValue({});
+    useDesktopAuthorizationStore.getState().clear();
+  });
+
+  it("shows the trusted subject and grants only after explicit approval", async () => {
+    useDesktopAuthorizationStore.getState().present({
+      applicationId: "wechat",
+      request: {
+        subject: { type: "agent", id: "main" },
+        resource: {
+          type: "desktop.application",
+          target: { applicationId: "wechat", platform: "darwin", bundleId: "com.tencent.xinWeChat" },
+        },
+        access: ["ui.write"],
+        declarationFingerprint: "fingerprint",
+      },
+    });
+
+    render(<DesktopAuthorizationDialog />);
+    expect(screen.getByText("AI · main")).toBeTruthy();
+    expect(screen.getByText("wechat")).toBeTruthy();
+    expect(mocks.grantAccess).not.toHaveBeenCalled();
+
+    fireEvent.click(screen.getByRole("button", { name: "Allow" }));
+    await waitFor(() => expect(mocks.grantAccess).toHaveBeenCalledOnce());
+  });
+
+  it("explains the bounded pointer permission in user terms", () => {
+    useDesktopAuthorizationStore.getState().present({
+      applicationId: "wechat",
+      request: {
+        subject: { type: "agent", id: "main" },
+        resource: { type: "desktop.application", target: { applicationId: "wechat", platform: "darwin", bundleId: "com.tencent.xinWeChat" } },
+        access: ["input.pointer"],
+        declarationFingerprint: "fingerprint",
+      },
+    });
+    render(<DesktopAuthorizationDialog />);
+    expect(screen.getByText("Click inside the app window")).toBeTruthy();
+    expect(screen.getByText(/cannot use keys, scroll, drag, send, or confirm/i)).toBeTruthy();
+  });
+});

package/src/features/desktop-capabilities/components/desktop-authorization-dialog.tsx

@@ -0,0 +1,161 @@
+import { useEffect, useState } from "react";
+import { ShieldAlert } from "lucide-react";
+import { toast } from "sonner";
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+} from "@/shared/components/ui/dialog";
+import { Button } from "@/shared/components/ui/button";
+import { appQueryClient } from "@/app-query-client";
+import { nextclawClient } from "@/shared/lib/api/managers/client.manager";
+import { t } from "@/shared/lib/i18n";
+import { desktopCapabilityManager } from "../managers/desktop-capability.manager";
+import {
+  type DesktopAuthorizationRequest,
+  useDesktopAuthorizationStore,
+} from "../stores/desktop-authorization.store";
+
+const AUTHORIZATION_EVENT_TYPE = "desktop.authorization.required";
+
+export function DesktopAuthorizationDialog() {
+  const pending = useDesktopAuthorizationStore((state) => state.pending);
+  const present = useDesktopAuthorizationStore((state) => state.present);
+  const clear = useDesktopAuthorizationStore((state) => state.clear);
+  const [isGranting, setIsGranting] = useState(false);
+
+  useEffect(() => nextclawClient.eventBus.subscribeAll((event) => {
+    if (event.type !== AUTHORIZATION_EVENT_TYPE) return;
+    const request = readAuthorizationRequest(event.payload);
+    if (request) present(request);
+  }), [present]);
+
+  const allow = async () => {
+    if (!pending || isGranting) return;
+    setIsGranting(true);
+    try {
+      await desktopCapabilityManager.grantAccess(pending.request);
+      await appQueryClient.invalidateQueries({
+        queryKey: ["desktop-capability", "grants"],
+      });
+      clear();
+      toast.success(t("desktopAuthorizationAllowed"));
+    } catch (error) {
+      toast.error(
+        error instanceof Error
+          ? error.message
+          : t("desktopAuthorizationFailed"),
+      );
+    } finally {
+      setIsGranting(false);
+    }
+  };
+
+  return (
+    <Dialog
+      open={Boolean(pending)}
+      onOpenChange={(open) => {
+        if (!open && !isGranting) clear();
+      }}
+    >
+      <DialogContent className="[&>:last-child]:hidden">
+        <DialogHeader>
+          <DialogTitle className="flex items-center gap-2">
+            <ShieldAlert className="h-4 w-4 text-amber-600" />
+            {t("desktopAuthorizationTitle")}
+          </DialogTitle>
+          <DialogDescription>
+            {t("desktopAuthorizationDescription")}
+          </DialogDescription>
+        </DialogHeader>
+        {pending ? (
+          <div className="space-y-3 rounded-xl bg-muted/55 p-4 text-sm">
+            <AuthorizationField
+              label={t("desktopAuthorizationCaller")}
+              value={formatSubject(pending)}
+            />
+            <AuthorizationField
+              label={t("desktopAuthorizationApplication")}
+              value={pending.applicationId}
+            />
+            <AuthorizationField
+              label={t("desktopAuthorizationAccess")}
+              value={pending.request.access.map(formatAccess).join(", ")}
+            />
+            <p className="text-xs leading-5 text-muted-foreground">
+              {formatRisk(pending.request.access)}
+            </p>
+          </div>
+        ) : null}
+        <DialogFooter className="gap-2 sm:gap-0">
+          <Button
+            type="button"
+            variant="outline"
+            disabled={isGranting}
+            onClick={clear}
+          >
+            {t("desktopAuthorizationReject")}
+          </Button>
+          <Button type="button" disabled={isGranting} onClick={() => void allow()}>
+            {isGranting ? t("desktopAuthorizationAllowing") : t("desktopAuthorizationAllow")}
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  );
+}
+
+function AuthorizationField({ label, value }: { label: string; value: string }) {
+  return (
+    <div className="grid grid-cols-[5rem_minmax(0,1fr)] gap-3">
+      <div className="text-xs font-medium text-muted-foreground">{label}</div>
+      <div className="min-w-0 break-words text-xs text-foreground">{value}</div>
+    </div>
+  );
+}
+
+function readAuthorizationRequest(value: unknown): DesktopAuthorizationRequest | null {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const payload = value as Record<string, unknown>;
+  const { request } = payload;
+  if (!request || typeof request !== "object" || Array.isArray(request)) return null;
+  const candidate = request as Record<string, unknown>;
+  if (
+    typeof payload.applicationId !== "string" ||
+    !candidate.subject ||
+    !candidate.resource ||
+    !Array.isArray(candidate.access) ||
+    typeof candidate.declarationFingerprint !== "string"
+  ) return null;
+  return {
+    applicationId: payload.applicationId,
+    request: candidate as DesktopAuthorizationRequest["request"],
+  };
+}
+
+function formatSubject(pending: DesktopAuthorizationRequest): string {
+  const { subject } = pending.request;
+  const label = subject.type === "agent"
+    ? t("desktopCapabilitiesAgent")
+    : t("desktopCapabilitiesExtension");
+  return `${label} · ${subject.id}`;
+}
+
+function formatAccess(access: string): string {
+  if (access === "ui.read") return t("desktopAuthorizationRead");
+  if (access === "ui.observe") return t("desktopAuthorizationObserve");
+  if (access === "ui.write") return t("desktopAuthorizationWrite");
+  if (access === "screen.capture-window") return t("desktopAuthorizationScreenCapture");
+  if (access === "input.pointer") return t("desktopAuthorizationPointerInput");
+  return access;
+}
+
+function formatRisk(access: string[]): string {
+  if (access.includes("ui.write")) return t("desktopAuthorizationWriteRisk");
+  if (access.includes("screen.capture-window")) return t("desktopAuthorizationScreenCaptureRisk");
+  if (access.includes("input.pointer")) return t("desktopAuthorizationPointerInputRisk");
+  return t("desktopAuthorizationReadRisk");
+}

package/src/features/desktop-capabilities/hooks/use-desktop-capabilities.test.ts

@@ -0,0 +1,10 @@
+import { describe, expect, it } from "vitest";
+import { isDesktopAutomationAvailable } from "./use-desktop-capabilities";
+
+describe("isDesktopAutomationAvailable", () => {
+  it("uses only the backend product feature-control value", () => {
+    expect(isDesktopAutomationAvailable({ desktopAutomation: { available: true } })).toBe(true);
+    expect(isDesktopAutomationAvailable({ desktopAutomation: { available: false } })).toBe(false);
+    expect(isDesktopAutomationAvailable(undefined)).toBe(false);
+  });
+});

package/src/features/desktop-capabilities/hooks/use-desktop-capabilities.ts

@@ -0,0 +1,55 @@
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import type { CapabilityGrantView, ProductFeatureControlsView } from "@nextclaw/client-sdk";
+import { useFeatureControls } from "@/app/hooks/use-feature-controls";
+import { desktopCapabilityManager } from "../managers/desktop-capability.manager";
+
+const STATUS_QUERY_KEY = ["desktop-capability", "status"] as const;
+const GRANTS_QUERY_KEY = ["desktop-capability", "grants"] as const;
+
+export function useDesktopCapabilityStatus() {
+  return useQuery({
+    queryKey: STATUS_QUERY_KEY,
+    queryFn: desktopCapabilityManager.getStatus,
+  });
+}
+
+export function useDesktopCapabilityAvailability(): boolean {
+  const featureControls = useFeatureControls();
+  return isDesktopAutomationAvailable(featureControls.data);
+}
+
+export function isDesktopAutomationAvailable(controls: ProductFeatureControlsView | undefined): boolean {
+  return controls?.desktopAutomation.available === true;
+}
+
+export function useDesktopCapabilityGrants() {
+  return useQuery({
+    queryKey: GRANTS_QUERY_KEY,
+    queryFn: desktopCapabilityManager.listGrants,
+  });
+}
+
+export function useRequestDesktopSystemPermission() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: desktopCapabilityManager.requestSystemPermission,
+    onSuccess: async () => {
+      await queryClient.invalidateQueries({ queryKey: STATUS_QUERY_KEY });
+    },
+  });
+}
+
+export function useOpenDesktopSystemSettings() {
+  return useMutation({ mutationFn: desktopCapabilityManager.openSystemSettings });
+}
+
+export function useRevokeDesktopGrant() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (grant: CapabilityGrantView) =>
+      await desktopCapabilityManager.revokeGrant(grant),
+    onSuccess: async () => {
+      await queryClient.invalidateQueries({ queryKey: GRANTS_QUERY_KEY });
+    },
+  });
+}

package/src/features/desktop-capabilities/index.ts

@@ -0,0 +1 @@
+export { DesktopAuthorizationDialog } from "./components/desktop-authorization-dialog";

package/src/features/desktop-capabilities/managers/desktop-capability.manager.ts

@@ -0,0 +1,25 @@
+import type {
+  CapabilityGrantRequestView,
+  CapabilityGrantView,
+} from "@nextclaw/client-sdk";
+import { nextclawClient } from "@/shared/lib/api/managers/client.manager";
+
+export class DesktopCapabilityManager {
+  getStatus = async () => await nextclawClient.capabilityAccess.getDesktopStatus();
+
+  listGrants = async () => await nextclawClient.capabilityAccess.listDesktopGrants();
+
+  grantAccess = async (request: CapabilityGrantRequestView) =>
+    await nextclawClient.capabilityAccess.grantDesktopAccess(request);
+
+  requestSystemPermission = async () =>
+    await nextclawClient.capabilityAccess.requestDesktopPermissions();
+
+  openSystemSettings = async () =>
+    await nextclawClient.capabilityAccess.openDesktopPermissionSettings();
+
+  revokeGrant = async (grant: CapabilityGrantView) =>
+    await nextclawClient.capabilityAccess.revokeDesktopAccess(grant);
+}
+
+export const desktopCapabilityManager = new DesktopCapabilityManager();

package/src/features/desktop-capabilities/pages/desktop-capabilities-page.test.tsx

@@ -0,0 +1,44 @@
+import { fireEvent, render, screen } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+import { DesktopCapabilitiesPage } from "./desktop-capabilities-page";
+
+const mocks = vi.hoisted(() => ({ refetch: vi.fn(), revoke: vi.fn() }));
+
+vi.mock("../hooks/use-desktop-capabilities", () => ({
+  useDesktopCapabilityStatus: () => ({
+    data: {
+      online: true,
+      permissions: { accessibility: "granted", screenCapture: "not_supported" },
+    },
+    isLoading: false,
+    isFetching: false,
+    refetch: mocks.refetch,
+  }),
+  useDesktopCapabilityGrants: () => ({
+    data: [
+      {
+        subject: { type: "agent", id: "main" },
+        resource: { type: "desktop.application", target: { applicationId: "wechat" } },
+        access: ["ui.read"],
+        declarationFingerprint: "fingerprint",
+        grantedAt: "2026-08-26T00:00:00.000Z",
+      },
+    ],
+    isLoading: false,
+  }),
+  useRequestDesktopSystemPermission: () => ({ isPending: false, mutate: vi.fn() }),
+  useOpenDesktopSystemSettings: () => ({ isPending: false, mutate: vi.fn() }),
+  useRevokeDesktopGrant: () => ({ isPending: false, mutate: mocks.revoke }),
+}));
+
+describe("DesktopCapabilitiesPage", () => {
+  it("shows system permission and Agent grants with reachable actions", () => {
+    render(<DesktopCapabilitiesPage />);
+
+    expect(screen.getByText("Desktop Access")).toBeTruthy();
+    expect(screen.getByText("AI · main")).toBeTruthy();
+    expect(screen.getByText("wechat · ui.read")).toBeTruthy();
+    fireEvent.click(screen.getByRole("button", { name: "Check again" }));
+    expect(mocks.refetch).toHaveBeenCalledOnce();
+  });
+});