@nextclaw/ui 0.20.2 → 0.21.0

package/src/shared/components/doc-browser/hooks/use-doc-browser-scroll-restoration.ts

@@ -1,126 +1,22 @@
-import { useCallback, useEffect, useRef, type RefObject } from 'react';
-import { PANEL_APP_SCROLL_RESTORATION_CONTRACT } from '@nextclaw/shared';
+import type { RefObject } from 'react';
 import type { DocBrowserTab } from '@/shared/components/doc-browser/doc-browser-context';
-
-type ScrollTarget =
-  | { kind: 'document' }
-  | { kind: 'element'; path: Array<{ index: number; tagName: string }> };
-
-type ScrollPosition = {
-  currentUrl: string;
-  target: ScrollTarget;
-  x: number;
-  y: number;
-};
+import { usePanelAppScrollRestoration } from '@/shared/hooks/use-panel-app-scroll-restoration';
 
 type UseDocBrowserScrollRestorationParams = {
   currentTab?: DocBrowserTab;
-  iframeRef: RefObject<HTMLIFrameElement | null>;
+  iframeRef: RefObject<HTMLIFrameElement>;
   isEnabled: boolean;
-  tabs: DocBrowserTab[];
 };
 
-function isScrollTarget(value: unknown): value is ScrollTarget {
-  if (!value || typeof value !== 'object') {
-    return false;
-  }
-  const candidate = value as Partial<ScrollTarget>;
-  if (candidate.kind === 'document') {
-    return true;
-  }
-  return candidate.kind === 'element'
-    && Array.isArray(candidate.path)
-    && candidate.path.length > 0
-    && candidate.path.length <= 30
-    && candidate.path.every((segment) => (
-      typeof segment?.index === 'number'
-      && Number.isInteger(segment.index)
-      && segment.index >= 0
-      && segment.index <= 1000
-      && typeof segment.tagName === 'string'
-      && segment.tagName.length > 0
-      && segment.tagName.length <= 32
-    ));
-}
-
-function isScrollMessage(value: unknown): value is {
-  target: ScrollTarget;
-  type: string;
-  version: number;
-  x: number;
-  y: number;
-} {
-  if (!value || typeof value !== 'object') {
-    return false;
-  }
-  const candidate = value as Partial<{
-    target: unknown;
-    type: string;
-    version: number;
-    x: number;
-    y: number;
-  }>;
-  return candidate.type === PANEL_APP_SCROLL_RESTORATION_CONTRACT.scrollMessageType
-    && candidate.version === PANEL_APP_SCROLL_RESTORATION_CONTRACT.version
-    && isScrollTarget(candidate.target)
-    && typeof candidate.x === 'number'
-    && Number.isFinite(candidate.x)
-    && candidate.x >= 0
-    && typeof candidate.y === 'number'
-    && Number.isFinite(candidate.y)
-    && candidate.y >= 0;
-}
-
 export function useDocBrowserScrollRestoration({
   currentTab,
   iframeRef,
   isEnabled,
-  tabs,
 }: UseDocBrowserScrollRestorationParams) {
-  const positionsRef = useRef(new Map<string, ScrollPosition>());
-
-  useEffect(() => {
-    const activeTabIds = new Set(tabs.map((tab) => tab.id));
-    for (const tabId of positionsRef.current.keys()) {
-      if (!activeTabIds.has(tabId)) {
-        positionsRef.current.delete(tabId);
-      }
-    }
-  }, [tabs]);
-
-  useEffect(() => {
-    if (!currentTab || !isEnabled) {
-      return;
-    }
-    const onMessage = (event: MessageEvent) => {
-      if (event.source !== iframeRef.current?.contentWindow || !isScrollMessage(event.data)) {
-        return;
-      }
-      positionsRef.current.set(currentTab.id, {
-        currentUrl: currentTab.currentUrl,
-        target: event.data.target,
-        x: event.data.x,
-        y: event.data.y,
-      });
-    };
-    window.addEventListener('message', onMessage);
-    return () => window.removeEventListener('message', onMessage);
-  }, [currentTab, iframeRef, isEnabled]);
-
-  return useCallback(() => {
-    if (!currentTab || !isEnabled) {
-      return;
-    }
-    const position = positionsRef.current.get(currentTab.id);
-    if (!position || position.currentUrl !== currentTab.currentUrl) {
-      return;
-    }
-    iframeRef.current?.contentWindow?.postMessage({
-      type: PANEL_APP_SCROLL_RESTORATION_CONTRACT.restoreScrollMessageType,
-      version: PANEL_APP_SCROLL_RESTORATION_CONTRACT.version,
-      target: position.target,
-      x: position.x,
-      y: position.y,
-    }, '*');
-  }, [currentTab, iframeRef, isEnabled]);
+  return usePanelAppScrollRestoration({
+    currentUrl: currentTab?.currentUrl ?? null,
+    iframeRef,
+    isEnabled,
+    restorationKey: currentTab ? `panel-app:doc-browser:${currentTab.id}` : null,
+  });
 }

package/src/shared/components/ui/__tests__/confirm-dialog.test.tsx

@@ -0,0 +1,31 @@
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { describe, expect, it, vi } from 'vitest';
+import { ConfirmDialog } from '@/shared/components/ui/confirm-dialog';
+
+describe('ConfirmDialog', () => {
+  it('focuses the confirm action so Enter confirms the dialog', async () => {
+    const user = userEvent.setup();
+    const onConfirm = vi.fn();
+
+    render(
+      <ConfirmDialog
+        open
+        onOpenChange={vi.fn()}
+        title="Delete session"
+        description="This action cannot be undone."
+        confirmLabel="Delete"
+        cancelLabel="Cancel"
+        onConfirm={onConfirm}
+        onCancel={vi.fn()}
+      />,
+    );
+
+    const confirmButton = await screen.findByRole('button', { name: 'Delete' });
+    expect(document.activeElement).toBe(confirmButton);
+
+    await user.keyboard('{Enter}');
+
+    expect(onConfirm).toHaveBeenCalledOnce();
+  });
+});

package/src/shared/components/ui/confirm-dialog.tsx

@@ -35,6 +35,8 @@ export const ConfirmDialog = ({
   onConfirm,
   onCancel
 }: ConfirmDialogProps) => {
+  const confirmButtonRef = React.useRef<HTMLButtonElement>(null);
+
   const handleConfirm = () => {
     onConfirm();
     onOpenChange(false);
@@ -45,7 +47,14 @@ export const ConfirmDialog = ({
   };
   return (
     <Dialog open={open} onOpenChange={onOpenChange}>
-      <DialogContent className="[&>:last-child]:hidden" onCloseAutoFocus={(e) => e.preventDefault()}>
+      <DialogContent
+        className="[&>:last-child]:hidden"
+        onOpenAutoFocus={(event) => {
+          event.preventDefault();
+          confirmButtonRef.current?.focus();
+        }}
+        onCloseAutoFocus={(event) => event.preventDefault()}
+      >
         <DialogHeader>
           <DialogTitle>{title}</DialogTitle>
           {description ? <DialogDescription>{description}</DialogDescription> : null}
@@ -55,6 +64,7 @@ export const ConfirmDialog = ({
             {cancelLabel}
           </Button>
           <Button
+            ref={confirmButtonRef}
             type="button"
             variant={variant === 'destructive' ? 'destructive' : 'default'}
             onClick={handleConfirm}

package/src/shared/hooks/use-panel-app-scroll-restoration.test.tsx

@@ -0,0 +1,66 @@
+import { fireEvent, render } from "@testing-library/react";
+import { useRef } from "react";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { PANEL_APP_SCROLL_RESTORATION_CONTRACT } from "@nextclaw/shared";
+import { usePanelAppScrollRestoration } from "@/shared/hooks/use-panel-app-scroll-restoration";
+import { scrollRestorationManager } from "@/shared/lib/navigation-history";
+
+function PanelAppFrame({ currentUrl = "/app", restorationKey = "panel-app:test" }: {
+  currentUrl?: string;
+  restorationKey?: string;
+}) {
+  const iframeRef = useRef<HTMLIFrameElement>(null);
+  const restoreScroll = usePanelAppScrollRestoration({
+    currentUrl,
+    iframeRef,
+    isEnabled: true,
+    restorationKey,
+  });
+  return <iframe ref={iframeRef} data-testid="panel-app-frame" onLoad={restoreScroll} />;
+}
+
+describe("usePanelAppScrollRestoration", () => {
+  beforeEach(() => scrollRestorationManager.clear());
+
+  it("records only scroll messages from its iframe and restores them after load", () => {
+    const { getByTestId } = render(<PanelAppFrame />);
+    const iframe = getByTestId("panel-app-frame") as HTMLIFrameElement;
+    const postMessage = vi.spyOn(iframe.contentWindow!, "postMessage");
+    const target = { kind: "document" } as const;
+
+    window.dispatchEvent(new MessageEvent("message", {
+      data: {
+        type: PANEL_APP_SCROLL_RESTORATION_CONTRACT.scrollMessageType,
+        version: PANEL_APP_SCROLL_RESTORATION_CONTRACT.version,
+        target,
+        x: 8,
+        y: 64,
+      },
+      source: iframe.contentWindow,
+    }));
+    fireEvent.load(iframe);
+
+    expect(postMessage).toHaveBeenCalledWith({
+      type: PANEL_APP_SCROLL_RESTORATION_CONTRACT.restoreScrollMessageType,
+      version: PANEL_APP_SCROLL_RESTORATION_CONTRACT.version,
+      target,
+      x: 8,
+      y: 64,
+    }, "*");
+  });
+
+  it("does not restore a position from another resource URL", () => {
+    scrollRestorationManager.save("panel-app:test", {
+      x: 0,
+      y: 64,
+      payload: { currentUrl: "/old-app", target: { kind: "document" } },
+    });
+    const { getByTestId } = render(<PanelAppFrame currentUrl="/new-app" />);
+    const iframe = getByTestId("panel-app-frame") as HTMLIFrameElement;
+    const postMessage = vi.spyOn(iframe.contentWindow!, "postMessage");
+
+    fireEvent.load(iframe);
+
+    expect(postMessage).not.toHaveBeenCalled();
+  });
+});

package/src/shared/hooks/use-panel-app-scroll-restoration.ts

@@ -0,0 +1,107 @@
+import { useCallback, useEffect, type RefObject } from "react";
+import { PANEL_APP_SCROLL_RESTORATION_CONTRACT } from "@nextclaw/shared";
+import { scrollRestorationManager } from "@/shared/lib/navigation-history";
+
+type ScrollTarget =
+  | { kind: "document" }
+  | { kind: "element"; path: Array<{ index: number; tagName: string }> };
+
+type PanelAppScrollSnapshot = {
+  currentUrl: string;
+  target: ScrollTarget;
+};
+
+type UsePanelAppScrollRestorationParams = {
+  currentUrl: string | null;
+  iframeRef: RefObject<HTMLIFrameElement>;
+  isEnabled: boolean;
+  restorationKey: string | null;
+};
+
+function isScrollTarget(value: unknown): value is ScrollTarget {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value as Partial<ScrollTarget>;
+  if (candidate.kind === "document") return true;
+  return candidate.kind === "element"
+    && Array.isArray(candidate.path)
+    && candidate.path.length > 0
+    && candidate.path.length <= 30
+    && candidate.path.every((segment) => (
+      typeof segment?.index === "number"
+      && Number.isInteger(segment.index)
+      && segment.index >= 0
+      && segment.index <= 1000
+      && typeof segment.tagName === "string"
+      && segment.tagName.length > 0
+      && segment.tagName.length <= 32
+    ));
+}
+
+function isPanelAppScrollSnapshot(value: unknown): value is PanelAppScrollSnapshot {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value as Partial<PanelAppScrollSnapshot>;
+  return typeof candidate.currentUrl === "string" && isScrollTarget(candidate.target);
+}
+
+function isScrollMessage(value: unknown): value is {
+  target: ScrollTarget;
+  x: number;
+  y: number;
+} {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value as Partial<{
+    target: unknown;
+    type: string;
+    version: number;
+    x: number;
+    y: number;
+  }>;
+  return candidate.type === PANEL_APP_SCROLL_RESTORATION_CONTRACT.scrollMessageType
+    && candidate.version === PANEL_APP_SCROLL_RESTORATION_CONTRACT.version
+    && isScrollTarget(candidate.target)
+    && typeof candidate.x === "number"
+    && Number.isFinite(candidate.x)
+    && candidate.x >= 0
+    && typeof candidate.y === "number"
+    && Number.isFinite(candidate.y)
+    && candidate.y >= 0;
+}
+
+/** Bridges the Panel App iframe scroll protocol to the shared navigation history. */
+export function usePanelAppScrollRestoration({
+  currentUrl,
+  iframeRef,
+  isEnabled,
+  restorationKey,
+}: UsePanelAppScrollRestorationParams) {
+  useEffect(() => {
+    if (!currentUrl || !isEnabled || !restorationKey) return;
+    const onMessage = (event: MessageEvent) => {
+      if (event.source !== iframeRef.current?.contentWindow || !isScrollMessage(event.data)) {
+        return;
+      }
+      scrollRestorationManager.save(restorationKey, {
+        x: event.data.x,
+        y: event.data.y,
+        payload: { currentUrl, target: event.data.target } satisfies PanelAppScrollSnapshot,
+      });
+    };
+    window.addEventListener("message", onMessage);
+    return () => window.removeEventListener("message", onMessage);
+  }, [currentUrl, iframeRef, isEnabled, restorationKey]);
+
+  return useCallback(() => {
+    if (!currentUrl || !isEnabled || !restorationKey) return;
+    const position = scrollRestorationManager.read(restorationKey);
+    if (!position || !isPanelAppScrollSnapshot(position.payload) || position.payload.currentUrl !== currentUrl) {
+      return;
+    }
+    iframeRef.current?.contentWindow?.postMessage({
+      type: PANEL_APP_SCROLL_RESTORATION_CONTRACT.restoreScrollMessageType,
+      version: PANEL_APP_SCROLL_RESTORATION_CONTRACT.version,
+      target: position.payload.target,
+      x: position.x,
+      y: position.y,
+    }, "*");
+  }, [currentUrl, iframeRef, isEnabled, restorationKey]);
+}

package/src/shared/hooks/use-scroll-restoration.test.tsx

@@ -0,0 +1,62 @@
+import { fireEvent, render } from "@testing-library/react";
+import { beforeEach, describe, expect, it } from "vitest";
+import { useScrollRestoration } from "@/shared/hooks/use-scroll-restoration";
+import { scrollRestorationManager } from "@/shared/lib/navigation-history";
+
+function ScrollSurface({ restorationKey }: { restorationKey: string }) {
+  const scrollRestoration = useScrollRestoration<HTMLDivElement>({ restorationKey });
+  const { onScroll, scrollRef } = scrollRestoration;
+  return (
+    <div
+      ref={scrollRef}
+      data-testid="scroll-surface"
+      onScroll={onScroll}
+    />
+  );
+}
+
+describe("useScrollRestoration", () => {
+  beforeEach(() => scrollRestorationManager.clear());
+
+  it("restores an existing position during layout and saves scroll events", () => {
+    scrollRestorationManager.save("page:first", { x: 16, y: 48 });
+    const { getByTestId } = render(<ScrollSurface restorationKey="page:first" />);
+    const surface = getByTestId("scroll-surface") as HTMLDivElement;
+
+    expect(surface.scrollLeft).toBe(16);
+    expect(surface.scrollTop).toBe(48);
+
+    surface.scrollLeft = 24;
+    surface.scrollTop = 72;
+    fireEvent.scroll(surface);
+
+    expect(scrollRestorationManager.read("page:first")).toEqual({ x: 24, y: 72 });
+  });
+
+  it("saves the previous key and restores the next key when navigation changes", () => {
+    scrollRestorationManager.save("page:second", { x: 0, y: 96 });
+    const view = render(<ScrollSurface restorationKey="page:first" />);
+    const surface = view.getByTestId("scroll-surface") as HTMLDivElement;
+    surface.scrollTop = 32;
+    fireEvent.scroll(surface);
+
+    view.rerender(<ScrollSurface restorationKey="page:second" />);
+
+    expect(scrollRestorationManager.read("page:first")).toEqual({ x: 0, y: 32 });
+    expect(surface.scrollTop).toBe(96);
+  });
+
+  it("keeps the last scroll event when React resets the element during navigation", () => {
+    const view = render(<ScrollSurface restorationKey="page:first" />);
+    const surface = view.getByTestId("scroll-surface") as HTMLDivElement;
+    surface.scrollTop = 144;
+    fireEvent.scroll(surface);
+
+    // Switching the content can reset the DOM scroll position before the
+    // previous layout effect's cleanup runs.
+    surface.scrollTop = 0;
+    view.rerender(<ScrollSurface restorationKey="page:second" />);
+
+    expect(scrollRestorationManager.read("page:first")).toEqual({ x: 0, y: 144 });
+  });
+});

package/src/shared/hooks/use-scroll-restoration.ts

@@ -0,0 +1,61 @@
+import { useCallback, useLayoutEffect, useRef, type RefObject, type UIEvent } from "react";
+import {
+  scrollRestorationManager,
+  type ScrollRestorationPosition,
+} from "@/shared/lib/navigation-history";
+
+type UseScrollRestorationParams<T extends HTMLElement> = {
+  restorationKey: string | null;
+  scrollRef?: RefObject<T>;
+  isEnabled?: boolean;
+};
+
+/** Connects one DOM scroll surface to the shared in-memory navigation history. */
+export function useScrollRestoration<T extends HTMLElement>({
+  restorationKey,
+  scrollRef,
+  isEnabled = true,
+}: UseScrollRestorationParams<T>) {
+  const internalScrollRef = useRef<T>(null);
+  const lastKnownPositionRef = useRef<ScrollRestorationPosition | null>(null);
+  const resolvedScrollRef = scrollRef ?? internalScrollRef;
+
+  useLayoutEffect(() => {
+    if (!isEnabled || !restorationKey) return;
+    const element = resolvedScrollRef.current;
+    const position = scrollRestorationManager.read(restorationKey);
+    if (element && position) {
+      element.scrollLeft = position.x;
+      element.scrollTop = position.y;
+    }
+    if (element) {
+      lastKnownPositionRef.current = {
+        x: element.scrollLeft,
+        y: element.scrollTop,
+      };
+    }
+
+    return () => {
+      if (!element) return;
+      scrollRestorationManager.save(
+        restorationKey,
+        lastKnownPositionRef.current ?? {
+          x: element.scrollLeft,
+          y: element.scrollTop,
+        },
+      );
+    };
+  }, [isEnabled, restorationKey, resolvedScrollRef]);
+
+  const onScroll = useCallback((event: UIEvent<T>) => {
+    if (!isEnabled || !restorationKey) return;
+    const position = {
+      x: event.currentTarget.scrollLeft,
+      y: event.currentTarget.scrollTop,
+    };
+    lastKnownPositionRef.current = position;
+    scrollRestorationManager.save(restorationKey, position);
+  }, [isEnabled, restorationKey]);
+
+  return { onScroll, scrollRef: resolvedScrollRef };
+}

package/src/shared/lib/api/index.ts

@@ -8,6 +8,7 @@ export * from './managers/client.manager';
 export * from './utils/config.utils';
 export * from './utils/marketplace.utils';
 export * from './utils/mcp-marketplace.utils';
+export * from './utils/mcp-connection.utils';
 export * from './utils/ncp-attachments.utils';
 export * from './utils/ncp-session.utils';
 export * from './projects/project.utils';

package/src/shared/lib/api/ncp-session-query-cache.utils.ts

@@ -149,6 +149,7 @@ export function applyNcpSessionRealtimeEvent(
   queryClient: QueryClient | undefined,
   event: Extract<WsEvent, { type: 'session.run-status' | 'session.summary.upsert' | 'session.summary.delete' }>
 ): void {
+  void queryClient?.invalidateQueries({ queryKey: ['ncp-session-pages'] });
   if (event.type === 'session.run-status') {
     updateNcpSessionRunStatusInQueryClient(queryClient, event.payload);
     return;

package/src/shared/lib/api/ncp-session.types.ts

@@ -103,6 +103,9 @@ export type NcpSessionSummaryView = NcpSessionSummary;
 export type NcpSessionsListView = {
   sessions: NcpSessionSummaryView[];
   total: number;
+  page?: number;
+  pageSize?: number;
+  hasMore?: boolean;
 };
 
 export type NcpMessageView = NcpMessage;

package/src/shared/lib/api/types.ts

@@ -488,6 +488,7 @@ export type PanelAppListView = {
   workspacePath: string;
   panelsPath: string;
   entries: PanelAppEntryView[];
+  unavailablePackages?: Array<{ appId: string; message: string }>;
 };
 
 export type PanelAppPreferencesUpdateView = {

package/src/shared/lib/api/utils/mcp-connection.utils.ts

@@ -0,0 +1,10 @@
+import type { McpConnectionCreateResult, McpConnectionRequest, McpConnectionTestResult } from "@nextclaw/client-sdk";
+import { nextclawClient } from "@/shared/lib/api/managers/client.manager";
+
+export async function testMcpConnection(request: McpConnectionRequest): Promise<McpConnectionTestResult> {
+  return await nextclawClient.mcp.testConnection(request);
+}
+
+export async function createMcpConnection(request: McpConnectionRequest): Promise<McpConnectionCreateResult> {
+  return await nextclawClient.mcp.createConnection(request);
+}

package/src/shared/lib/api/utils/ncp-session.utils.ts

@@ -14,6 +14,9 @@ import type {
 // GET /api/ncp/sessions
 export async function fetchNcpSessions(params?: {
   limit?: number;
+  page?: number;
+  pageSize?: number;
+  query?: string;
   peerId?: string;
 }): Promise<NcpSessionsListView> {
   return (await nextclawClient.sessions.list(params)) as NcpSessionsListView;

package/src/shared/lib/i18n/locales/en-US/chat.json

@@ -80,7 +80,7 @@
   "chatWorkspaceContinuousAttentionEmpty": "No continuous attention",
   "chatWorkspaceContinuousAttentionEmptyDescription": "The Agent has not established this type of ongoing relationship for the session.",
   "chatWorkspaceTokenUsage": "Token usage",
-  "chatWorkspaceTokenUsageDescription": "Counts this session's own AI runs. Cached input is included in input tokens; the hit rate is cached reads divided by all input.",
+  "chatWorkspaceTokenUsageDescription": "Summarizes this session's recorded Agent rounds. Cached input is included in input tokens; cache read ratio is cached reads divided by all input tokens.",
   "chatWorkspaceTokenUsageLoading": "Calculating token usage…",
   "chatWorkspaceTokenUsageLoadFailed": "Couldn’t load token usage.",
   "chatWorkspaceTokenUsageRetry": "Retry",
@@ -89,11 +89,14 @@
   "chatWorkspaceTokenUsageInput": "Input",
   "chatWorkspaceTokenUsageOutput": "Output",
   "chatWorkspaceTokenUsageCachedInput": "Cached input",
-  "chatWorkspaceTokenUsageCacheHitRate": "Cache hit rate",
-  "chatWorkspaceTokenUsageRuns": "AI runs",
+  "chatWorkspaceTokenUsageCacheHitRate": "Cache read ratio",
+  "chatWorkspaceTokenUsageRuns": "Agent rounds",
+  "chatWorkspaceTokenUsageModelCalls": "Model calls",
+  "chatWorkspaceTokenUsageReportedModelCalls": "Reported calls",
   "chatWorkspaceTokenUsageByModel": "By model",
-  "chatWorkspaceTokenUsageModelRunCount": "Runs: {count}",
-  "chatWorkspaceTokenUsageModelCacheHitRate": "Cache hit rate: {rate}",
+  "chatWorkspaceTokenUsageModelRunCount": "{count} agent rounds",
+  "chatWorkspaceTokenUsageModelCallCount": "{count} model calls",
+  "chatWorkspaceTokenUsageModelCacheHitRate": "Cache read ratio: {rate}",
   "chatWorkspaceTokenUsageReported": "Usage reported",
   "chatWorkspaceTokenUsagePartial": "Partial usage",
   "chatWorkspaceTokenUsageUnavailable": "Usage unavailable",
@@ -473,6 +476,8 @@
   "chatSteeringPending": "Waiting for the next step",
   "chatDeleteSession": "Delete Session",
   "chatDeleteSessionConfirm": "Delete the current session?",
+  "chatDeleteSessionSucceeded": "Session deleted.",
+  "chatDeleteSessionFailed": "Could not delete session",
   "chatSessionMoreActions": "More actions",
   "chatSessionCopyId": "Copy session ID",
   "chatSessionCopyIdSuccess": "Session ID copied",

package/src/shared/lib/i18n/locales/en-US/core.json

@@ -26,6 +26,49 @@
   "sidebarExpand": "Expand sidebar",
   "security": "Sign-in Management",
   "privacy": "Privacy & Analytics",
+  "desktopCapabilities": "Desktop Access",
+  "desktopCapabilitiesPageTitle": "Desktop Access",
+  "desktopCapabilitiesPageDescription": "Check NextClaw Desktop system permissions and manage which desktop apps AI agents and Extensions can access.",
+  "desktopCapabilitiesSystemTitle": "System permission",
+  "desktopCapabilitiesSystemDescription": "macOS only needs permission for NextClaw Desktop. Each AI agent or Extension still needs separate access to an app.",
+  "desktopCapabilitiesHostStatus": "Desktop Host",
+  "desktopCapabilitiesHostOnline": "Connected and ready to check desktop apps and system permissions.",
+  "desktopCapabilitiesHostOffline": "Not connected. Start NextClaw Desktop first.",
+  "desktopCapabilitiesRecheck": "Check again",
+  "desktopCapabilitiesAccessibility": "Accessibility",
+  "desktopCapabilitiesOpenSettings": "Open System Settings",
+  "desktopCapabilitiesRequestPermission": "Request permission",
+  "desktopCapabilitiesPermissionGranted": "NextClaw Desktop can control local apps.",
+  "desktopCapabilitiesPermissionNotGranted": "Not allowed yet. Open System Settings and enable Accessibility for NextClaw Desktop.",
+  "desktopCapabilitiesPermissionNotSupported": "Desktop access is not supported on this system.",
+  "desktopCapabilitiesPermissionUnknown": "The permission state is currently unavailable.",
+  "desktopCapabilitiesGrantsTitle": "App access",
+  "desktopCapabilitiesGrantsDescription": "These permissions decide which AI agent or Extension can read or operate an app. Revoking access stops related operations immediately.",
+  "desktopCapabilitiesNoGrants": "No app access yet",
+  "desktopCapabilitiesNoGrantsDescription": "NextClaw will ask for permission when an AI agent or Extension first accesses a desktop app.",
+  "desktopCapabilitiesAgent": "AI",
+  "desktopCapabilitiesExtension": "Extension",
+  "desktopCapabilitiesUnknownApplication": "Unknown app",
+  "desktopCapabilitiesRevoke": "Revoke access",
+  "desktopAuthorizationTitle": "Allow desktop access?",
+  "desktopAuthorizationDescription": "This action needs access to a local app. Check who is asking, which app, and what they can do.",
+  "desktopAuthorizationCaller": "Requested by",
+  "desktopAuthorizationApplication": "App",
+  "desktopAuthorizationAccess": "Access",
+  "desktopAuthorizationRead": "Read visible content",
+  "desktopAuthorizationObserve": "Watch visible changes",
+  "desktopAuthorizationWrite": "Write to the app",
+  "desktopAuthorizationScreenCapture": "Capture visible window content",
+  "desktopAuthorizationPointerInput": "Click inside the app window",
+  "desktopAuthorizationReadRisk": "Once allowed, this requester can read or watch currently visible content in this app until you revoke access in Desktop Access.",
+  "desktopAuthorizationWriteRisk": "Once allowed, this AI agent can write a draft into this app. This permission does not allow sending or confirming.",
+  "desktopAuthorizationScreenCaptureRisk": "Once allowed, this requester can capture the currently visible content of this app window for AI understanding until you revoke access in Desktop Access.",
+  "desktopAuthorizationPointerInputRisk": "Once allowed, this AI can click inside this app's authorized window. It cannot use keys, scroll, drag, send, or confirm.",
+  "desktopAuthorizationReject": "Don't allow",
+  "desktopAuthorizationAllow": "Allow",
+  "desktopAuthorizationAllowing": "Allowing…",
+  "desktopAuthorizationAllowed": "Access allowed. The AI can retry the previous action.",
+  "desktopAuthorizationFailed": "Desktop access could not be saved.",
   "backToMain": "Back to Main",
   "enabled": "Enabled",
   "disabled": "Disabled",

package/src/shared/lib/i18n/locales/en-US/cron.json

@@ -17,6 +17,8 @@
   "cronNextPage": "Next page",
   "cronTotalLabel": "Total",
   "cronLoading": "Loading scheduled tasks...",
+  "cronLoadFailed": "Scheduled tasks could not be loaded right now.",
+  "cronRetry": "Retry",
   "cronEmpty": "No scheduled tasks yet.",
   "cronScheduleLabel": "Schedule",
   "cronSessionLabel": "Execution session",
@@ -64,8 +66,8 @@
   "cronRunFailed": "Latest run failed",
   "cronBoundSession": "Bound session",
   "cronDedicatedSession": "Dedicated session",
-  "cronEditDetails": "View and edit task",
-  "cronDetailDescription": "Review the task and its latest run. Return to its execution session to describe changes.",
+  "cronEditDetails": "View task details",
+  "cronDetailDescription": "Review the task and its latest run. To change it, return to the execution session and describe what you need.",
   "cronTaskPrompt": "Task prompt",
   "cronTaskDetails": "Task settings",
   "cronAgentLabel": "Execution Agent",