@agent-native/core 0.168.10 → 0.168.11

package/corpus/templates/clips/desktop/src/dev/browser-preview.ts

@@ -0,0 +1,65 @@
+/**
+ * Lets the tray's React surfaces render in a plain browser tab (`pnpm
+ * vite:dev`, http://localhost:1420) so layout and copy can be reviewed without
+ * a Rust build.
+ *
+ * Outside Tauri there is no IPC: `getCurrentWindow()` reads
+ * `window.__TAURI_INTERNALS__.metadata` and throws during the first effect,
+ * which blanks the whole app. This installs the smallest stub that keeps React
+ * mounted.
+ *
+ * Every `invoke` REJECTS rather than returning invented data. A settings row
+ * that cannot read its value should show its default and say so, not a
+ * fabricated state that looks real in a screenshot — so what you see here is
+ * the surface's genuine "backend unavailable" rendering. Anything needing true
+ * device state (permission grants, Whisper catalog, Rewind) has to be checked
+ * in the real app.
+ *
+ * Dev-only: `main.tsx` calls this behind `import.meta.env.DEV`, so it is absent
+ * from any production bundle.
+ */
+
+type TauriInternals = {
+  metadata: {
+    currentWindow: { label: string };
+    currentWebview: { label: string; windowLabel: string };
+  };
+  invoke: (cmd: string, args?: unknown) => Promise<never>;
+  transformCallback: (cb: (payload: unknown) => void) => number;
+  convertFileSrc: (path: string) => string;
+};
+
+declare global {
+  interface Window {
+    __TAURI_INTERNALS__?: TauriInternals;
+  }
+}
+
+export function installBrowserPreview(): void {
+  if (window.__TAURI_INTERNALS__) return;
+
+  let callbackId = 0;
+  const callbacks = new Map<number, (payload: unknown) => void>();
+
+  window.__TAURI_INTERNALS__ = {
+    metadata: {
+      currentWindow: { label: "main" },
+      currentWebview: { label: "main", windowLabel: "main" },
+    },
+    invoke: (cmd) =>
+      Promise.reject(
+        new Error(`Tauri command "${cmd}" is unavailable in browser preview`),
+      ),
+    transformCallback: (cb) => {
+      const id = ++callbackId;
+      callbacks.set(id, cb);
+      return id;
+    },
+    convertFileSrc: (path) => path,
+  };
+
+  console.info(
+    "[clips-tray] browser preview: Tauri commands will reject. Add a route " +
+      "hash to jump straight to a surface, e.g. #settings or #settings/advanced.",
+  );
+}

package/corpus/templates/clips/desktop/src/hooks/useSystemAccessRows.ts

@@ -0,0 +1,128 @@
+import { useCallback, useEffect, useState } from "react";
+
+import {
+  permissionStatusForPane,
+  readPermissionStatuses,
+  requestOrOpenPermission,
+  type MacosPrivacyPane,
+  type PermissionStatuses,
+} from "../lib/permission-status";
+import { isMacPlatform } from "../lib/platform";
+
+export type SystemAccessRow = {
+  key: string;
+  label: string;
+  description: string;
+  /** `null` means the grant could not be read — never render it as denied. */
+  granted: boolean | null;
+  onGrant: () => void;
+};
+
+type SystemAccessDefinition = {
+  key: string;
+  label: string;
+  description: string;
+  panes: MacosPrivacyPane[];
+};
+
+/**
+ * Collapses the per-pane permission list into the few lines a user acts on:
+ * capture as one grant, then only the extras their configuration needs.
+ */
+export function useSystemAccessRows({
+  includeVoicePaste,
+  includeFnMonitoring,
+  onOpenSettings,
+}: {
+  includeVoicePaste: boolean;
+  includeFnMonitoring: boolean;
+  onOpenSettings: (pane: MacosPrivacyPane) => void;
+}): SystemAccessRow[] {
+  const mac = isMacPlatform();
+  const [statuses, setStatuses] = useState<PermissionStatuses | null>(null);
+
+  const recheck = useCallback(() => {
+    void readPermissionStatuses().then(setStatuses);
+  }, []);
+
+  // Grants are changed in System Settings, outside this window. Re-reading on
+  // focus is what stops a row from still demanding "Grant" after the user did.
+  useEffect(() => {
+    recheck();
+    window.addEventListener("focus", recheck);
+    return () => window.removeEventListener("focus", recheck);
+  }, [recheck]);
+
+  // One row per OS grant, worded exactly like the recorder's readiness panel —
+  // the same grant must read as the same thing on both surfaces, and each
+  // Grant button must open exactly the pane its row names. The earlier
+  // combined capture row walked three panes one click at a time, which read
+  // as one grant that mysteriously kept not taking.
+  const definitions: SystemAccessDefinition[] = [
+    {
+      key: "screen",
+      label: "Screen Recording",
+      description: "Allows Clips to record your screen",
+      panes: ["screen"],
+    },
+    {
+      key: "microphone",
+      label: "Microphone",
+      description: "Allows Clips to access your microphone",
+      panes: ["microphone"],
+    },
+    {
+      key: "camera",
+      label: "Camera",
+      description: "Allows Clips to access your camera",
+      panes: ["camera"],
+    },
+  ];
+  if (mac) {
+    definitions.push({
+      key: "speech",
+      label: "Speech Recognition",
+      description: "Allows Clips to use speech recognition",
+      panes: ["speech"],
+    });
+  }
+  if (mac && includeVoicePaste) {
+    definitions.push({
+      key: "accessibility",
+      label: "Accessibility",
+      description: "Allows Clips to control this device to paste dictated text",
+      panes: ["accessibility"],
+    });
+  }
+  if (mac && includeFnMonitoring) {
+    definitions.push({
+      key: "input-monitoring",
+      label: "Input Monitoring",
+      description: "Allows Clips to detect the Fn key",
+      panes: ["input-monitoring"],
+    });
+  }
+
+  return definitions.map(({ panes, ...definition }) => {
+    const results = panes.map((pane) =>
+      permissionStatusForPane(pane, statuses),
+    );
+    const granted = results.some((result) => result === null)
+      ? null
+      : results.every(Boolean);
+    return {
+      ...definition,
+      granted,
+      onGrant: () => {
+        const target =
+          panes.find(
+            (pane) => permissionStatusForPane(pane, statuses) === false,
+          ) ?? panes[0];
+        void requestOrOpenPermission(target, {
+          onOpenSettings,
+          onRecheck: recheck,
+        });
+      },
+    };
+  });
+}

package/corpus/templates/clips/desktop/src/hooks/useWhisperSettings.ts

@@ -48,7 +48,6 @@ export function useWhisperSettings(
 
   const enabled = featureConfig?.whisperModelEnabled !== false;
   const modelId = featureConfig?.whisperModelId ?? "base";
-  const selectedModel = catalog.find((m) => m.id === modelId) ?? null;
   const deletableModels = catalog.filter(
     (m) => m.id !== modelId && downloadedModelIds.includes(m.id),
   );
@@ -162,7 +161,6 @@ export function useWhisperSettings(
     status,
     enabled,
     modelId,
-    selectedModel,
     deletableModels,
     triggerDownload,
     setEnabled,

package/corpus/templates/clips/desktop/src/lib/permission-status.ts

@@ -0,0 +1,84 @@
+// Reading and repairing OS privacy grants. Shared by the recorder's readiness
+// list and Settings › General › System access so both surfaces report the same
+// three states.
+import { invoke } from "@tauri-apps/api/core";
+
+import { isMacPlatform } from "./platform";
+
+export type MacosPrivacyPane =
+  | "camera"
+  | "microphone"
+  | "screen"
+  | "speech"
+  | "accessibility"
+  | "input-monitoring";
+
+export type PermissionStatuses = {
+  screen: boolean;
+  camera: boolean;
+  microphone: boolean;
+  speech: boolean;
+  accessibility: boolean;
+  inputMonitoring: boolean;
+};
+
+/**
+ * `null` means the grants could not be read — a non-macOS host, or the command
+ * failing. It is not the same as "denied", and callers must not render it as
+ * one: an unreadable grant offers to open System Settings, a denied grant asks
+ * the user to fix it.
+ */
+export async function readPermissionStatuses(): Promise<PermissionStatuses | null> {
+  if (!isMacPlatform()) return null;
+  try {
+    return await invoke<PermissionStatuses>("check_permission_statuses");
+  } catch {
+    // coercion-ok: null IS the typed "could not read" value — callers render
+    // it as unknown, never as denied (locked by permission-status.test.ts).
+    return null;
+  }
+}
+
+export function permissionStatusForPane(
+  pane: MacosPrivacyPane,
+  statuses: PermissionStatuses | null,
+): boolean | null {
+  if (!statuses) return null;
+  const map: Record<MacosPrivacyPane, boolean> = {
+    screen: statuses.screen,
+    camera: statuses.camera,
+    microphone: statuses.microphone,
+    speech: statuses.speech,
+    accessibility: statuses.accessibility,
+    "input-monitoring": statuses.inputMonitoring,
+  };
+  return map[pane];
+}
+
+/**
+ * Screen Recording is the one grant macOS will still prompt for in-app, so try
+ * that before sending the user to System Settings. Every other pane only opens.
+ */
+export async function requestOrOpenPermission(
+  pane: MacosPrivacyPane,
+  {
+    onOpenSettings,
+    onRecheck,
+  }: {
+    onOpenSettings: (pane: MacosPrivacyPane) => void;
+    onRecheck?: () => void;
+  },
+): Promise<void> {
+  if (isMacPlatform() && pane === "screen") {
+    try {
+      const granted = await invoke<boolean>("system_audio_request_permission");
+      onRecheck?.();
+      if (granted) return;
+    } catch {
+      // coercion-ok: the request API may be unavailable on an older macOS
+      // build, or the user may have denied the prompt once already — falling
+      // through to open the dedicated privacy pane IS the recovery path.
+    }
+  }
+  onOpenSettings(pane);
+}

package/corpus/templates/clips/desktop/src/lib/rewind-status.ts

@@ -52,7 +52,8 @@ export function getRewindStatusPresentation({
     return {
       kind: "excluded",
       title: "Rewind is protecting a private moment",
-      detail: status.coverage || "An excluded app is being skipped.",
+      detail:
+        status.coverage || "An excluded app is in front, so capture is paused.",
       isLive: false,
       hasError: false,
     };
@@ -62,7 +63,7 @@ export function getRewindStatusPresentation({
     return {
       kind: "unavailable",
       title: "Rewind is unavailable",
-      detail: "Rewind capture is not available on this device.",
+      detail: "Capture isn't available on this device.",
       isLive: false,
       hasError: false,
     };
@@ -75,7 +76,7 @@ export function getRewindStatusPresentation({
       detail:
         status.lastError ||
         status.coverage ||
-        "Rewind is retaining local coverage.",
+        "New moments are being saved to this device.",
       isLive: true,
       hasError: Boolean(status.lastError),
     };
@@ -93,10 +94,10 @@ export function getRewindStatusPresentation({
 
   return {
     kind: "idle",
-    title: "Rewind is enabled but not currently capturing",
+    title: "Rewind is on but not capturing",
     detail: clipRecordingActive
       ? "Rewind will resume when this Clip ends."
-      : "No new local coverage is being retained right now.",
+      : "Nothing new is being saved right now.",
     isLive: false,
     hasError: false,
   };

package/corpus/templates/clips/desktop/src/lib/settings-navigation.ts

@@ -1,11 +1,24 @@
-export type DesktopSettingsTab =
-  | "general"
-  | "recording"
-  | "meetings"
-  | "dictation";
+// Order is the settings nav order; app.tsx's settingsTabs labels/icons follow it.
+export const DESKTOP_SETTINGS_TABS = [
+  "general",
+  "recording",
+  "rewind",
+  "meetings",
+  "dictation",
+  "advanced",
+] as const;
+
+export type DesktopSettingsTab = (typeof DESKTOP_SETTINGS_TABS)[number];
 
 export function initialDesktopSettingsTab(
   tab?: DesktopSettingsTab,
 ): DesktopSettingsTab {
   return tab ?? "general";
 }
+
+/** `#settings/<tab>` detail → a known tab, or undefined for anything else. */
+export function asDesktopSettingsTab(
+  value: string | undefined,
+): DesktopSettingsTab | undefined {
+  return DESKTOP_SETTINGS_TABS.find((tab) => tab === value);
+}

package/corpus/templates/clips/desktop/src/lib/utils.ts

@@ -0,0 +1,6 @@
+import { clsx, type ClassValue } from "clsx";
+import { twMerge } from "tailwind-merge";
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs));
+}

package/corpus/templates/clips/desktop/src/main.tsx

@@ -2,8 +2,10 @@ import { invoke } from "@tauri-apps/api/core";
 import React from "react";
 import ReactDOM from "react-dom/client";
 
-import { App } from "./app";
+import { App, installAuthFetchInterceptor } from "./app";
+import { installBrowserPreview } from "./dev/browser-preview";
 import { initDesktopSentry } from "./lib/sentry";
+import { asDesktopSettingsTab } from "./lib/settings-navigation";
 import { Bubble } from "./overlays/bubble";
 import { Countdown } from "./overlays/countdown";
 import { Finalizing } from "./overlays/finalizing";
@@ -17,7 +19,8 @@ import { RegionGuideEditor, RegionGuides } from "./overlays/region-guides";
 import { RegionRecordBorder } from "./overlays/region-record-border";
 import { Toolbar } from "./overlays/toolbar";
 
-import "./styles.css";
+// Imports styles.css itself, into a lower cascade layer — see tailwind.css.
+import "./tailwind.css";
 
 /**
  * One bundle, one HTML, many views. We pick which component to mount based
@@ -26,7 +29,14 @@ import "./styles.css";
  */
 function currentRoute(): string {
   const hash = window.location.hash.replace(/^#/, "").toLowerCase();
-  return hash || "popover";
+  // `#settings/advanced` names a surface plus where to open it; the route is
+  // the part before the slash.
+  return hash.split("/")[0] || "popover";
+}
+
+/** `#settings/advanced` → "advanced". */
+function currentRouteDetail(): string | undefined {
+  return window.location.hash.replace(/^#/, "").toLowerCase().split("/")[1];
 }
 
 function installRouteAttributes(route: string): void {
@@ -64,6 +74,16 @@ function pickRoute(route: string): React.ReactElement {
       return <RegionRecordBorder />;
     case "monitor-picker":
       return <MonitorPicker />;
+    // Opens the popover straight onto Settings. Rust never spawns this route —
+    // it exists so `#settings` / `#settings/advanced` reaches the surface
+    // directly in a browser tab or a dev window.
+    case "settings":
+      return (
+        <App
+          initialView="settings"
+          initialSettingsTab={asDesktopSettingsTab(currentRouteDetail())}
+        />
+      );
     default:
       return <App />;
   }
@@ -214,7 +234,14 @@ function installConsoleCapture(route: string): void {
 const rootEl = document.getElementById("root");
 if (rootEl) {
   const route = currentRoute();
-  installRouteAttributes(route);
+  // Before anything reads Tauri internals: outside the app shell this keeps the
+  // surfaces mountable in a browser tab. No-ops inside Tauri, absent in prod.
+  if (import.meta.env.DEV) installBrowserPreview();
+  // Before React renders: covers fetches made during the first commit.
+  installAuthFetchInterceptor();
+  // `settings` is the popover window showing one of its views, so it takes the
+  // popover's shell styling rather than a full-viewport overlay's.
+  installRouteAttributes(route === "settings" ? "popover" : route);
   initDesktopSentry(route);
   installConsoleCapture(route);
   installBeforeUnloadCleanup();

package/corpus/templates/clips/desktop/src/overlays/finalizing.tsx

@@ -219,8 +219,8 @@ export function Finalizing() {
       ? "Uploaded"
       : progress.stage === "failed"
         ? progress.savedLocally
-          ? "Upload paused — clip saved locally"
-          : "Upload paused — open Clips to recover"
+          ? "Upload paused. Clip saved locally."
+          : "Upload paused. Open Clips to recover."
         : progress.stage === "uploading" ||
             progress.stage === "processing" ||
             progress.stage === "opening"

package/corpus/templates/clips/desktop/src/overlays/toolbar.tsx

@@ -366,8 +366,8 @@ export function Toolbar() {
             className={`toolbar-v-disk-indicator toolbar-v-disk-indicator-${diskSpaceLevel}`}
             title={
               diskSpaceLevel === "critical"
-                ? "Disk almost full — stop recording now to avoid losing your clip"
-                : "Low disk space — save your recording soon"
+                ? "Disk almost full. Stop recording now to avoid losing your clip."
+                : "Low disk space. Save your recording soon."
             }
             data-no-drag
           >