@agent-native/core 0.145.1 → 0.145.2

package/corpus/README.md

@@ -31,4 +31,4 @@ rg -n "defineAction|useActionQuery" node_modules/@agent-native/core/corpus
 
 ## Generated Counts
 
-- template files: 7848
+- template files: 7850

package/corpus/templates/brain/server/lib/capture-sanitization.ts

@@ -442,9 +442,13 @@ async function classifyWithApprovedModel(
   if (!model || !engineName) return null;
 
   const core = await import("@agent-native/core/server");
-  const userApiKey = await core.getOwnerActiveApiKey(input.source.ownerEmail);
+  const userApiKey = await core.resolveOwnerEngineApiKey({
+    engineOption: engineName,
+    ownerEmail: input.source.ownerEmail,
+  });
   const engine = await core.resolveEngine({
-    apiKey: userApiKey ?? undefined,
+    apiKey: userApiKey.apiKey,
+    apiKeyEnvVar: userApiKey.apiKeyEnvVar,
     appId: "brain",
     engineOption: engineName,
   });

package/corpus/templates/clips/changelog/2026-08-07-full-screen-recordings-on-a-multi-monitor-mac-now-let-you-pi.md

@@ -0,0 +1,6 @@
+---
+type: added
+date: 2026-08-07
+---
+
+Full-screen recordings on a multi-monitor Mac now let you pick which display to record before capture starts.

package/corpus/templates/clips/chrome-extension/src/styles.css

@@ -861,7 +861,7 @@ h1 {
 
 .field-label {
   color: var(--foreground);
-  font-size: 12px;
+  font-size: 14px;
   font-weight: 700;
 }
 
@@ -873,6 +873,7 @@ h1 {
   padding: 0 11px;
   color: var(--fg);
   background: var(--bg);
+  font-size: 14px;
 }
 
 .form-actions {
@@ -899,14 +900,14 @@ h1 {
 
 .toggle-title {
   color: var(--foreground);
-  font-size: 13px;
+  font-size: 14px;
   font-weight: 700;
 }
 
 .toggle-subtitle {
   margin-top: 3px;
   color: var(--muted-foreground);
-  font-size: 12px;
+  font-size: 13px;
   line-height: 1.35;
 }
 
@@ -923,7 +924,7 @@ h1 {
   background: var(--primary);
   color: var(--primary-foreground);
   cursor: pointer;
-  font-size: 13px;
+  font-size: 14px;
   font-weight: 700;
 }
 
@@ -931,6 +932,14 @@ h1 {
   opacity: 0.92;
 }
 
+.options-page .secondary-action {
+  font-size: 14px;
+}
+
+.options-page .field-help {
+  font-size: 13px;
+}
+
 /* Unsupported-page notice (shown in the popup when the active tab can't host
    the on-page overlay, e.g. chrome:// / New Tab / Web Store pages). */
 .notice {

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

@@ -92,6 +92,7 @@ import {
   exportBrowserRecordingBackup,
   getRewindClipOrigin,
   listBrowserRecordingBackups,
+  pickFullscreenRecordingDisplay,
   retryBrowserRecordingBackup,
   scheduleNativeBackupCleanupAfterProcessing,
   shouldUseNativeFullscreenRecording,
@@ -2899,7 +2900,10 @@ export function App() {
     /** Live capture inherited from the take a restart is replacing. */
     resumeCapture?: RestartHandoff;
   }): Promise<RecorderHandle | null> {
-    if (recorder && !options?.ignoreActiveRecorder) {
+    if (
+      (recorder || recordingFlowGateRef.current) &&
+      !options?.ignoreActiveRecorder
+    ) {
       console.warn(
         "[clips-popover] handleStartRecording ignored — recorder already active",
       );
@@ -2941,21 +2945,54 @@ export function App() {
     });
 
     if (mode !== "camera" && nativeFullscreenRecordingActive) {
+      // Latch re-entry protection before these awaits, not after — both the
+      // permission prompt and the monitor picker below can take a while (the
+      // picker waits on the user), and without this a double-click while
+      // either is pending passes the top-of-function guard and starts a
+      // second, competing recording-start flow. The real flow-active latch
+      // further below hasn't run yet at this point, so reset this on every
+      // early return in this block.
+      recordingFlowGateRef.current = true;
       try {
         const granted = await invoke<boolean>(
           "request_macos_screen_recording_access",
         );
         if (!granted) {
+          recordingFlowGateRef.current = false;
           setReadinessOpen(true);
           setRecError(MACOS_SCREEN_PERMISSION_MESSAGE);
           openPrivacySettings("screen");
           return null;
         }
       } catch (err) {
+        recordingFlowGateRef.current = false;
         setReadinessOpen(true);
         setRecError(err instanceof Error ? err.message : String(err));
         return null;
       }
+      // A restart hands off the already-live display stream from the take
+      // it's replacing (see `discardForRestart`/`preAcquiredDisplayStream`
+      // below) — it must keep recording the same screen, not re-prompt.
+      if (source === "full-screen" && !options?.resumeCapture) {
+        try {
+          // Must resolve before `recordingFlowActive` flips the toolbar on
+          // below — the toolbar reads the pick to place itself on the
+          // chosen screen the first time it's shown.
+          await pickFullscreenRecordingDisplay();
+        } catch (err) {
+          recordingFlowGateRef.current = false;
+          if (err instanceof Error && err.name === "AbortError") {
+            // User cancelled the screen picker (Escape) — abort silently,
+            // same as dismissing the native macOS screen picker.
+            return null;
+          }
+          // A real failure (picker window construction, persisting the
+          // pick, etc.) — surface it instead of silently aborting like a
+          // cancel, or the user has no idea why nothing happened.
+          setRecError(err instanceof Error ? err.message : String(err));
+          return null;
+        }
+      }
     }
 
     stopAllMicMeters();

package/corpus/templates/clips/desktop/src/components/MediaDeviceRow.tsx

@@ -1,8 +1,10 @@
+import { IconVinyl } from "@tabler/icons-react";
 import { useMemo } from "react";
 
 import { useMicMeter } from "../hooks/useMicMeter";
 import { CameraIcon, CheckIcon, ChevronDown, MicIcon } from "./Icons";
 import { Switch } from "./Switch";
+import { Tooltip, TooltipContent, TooltipTrigger } from "./Tooltip";
 import { useRowMenu } from "./useRowMenu";
 
 function Toggle({
@@ -112,109 +114,71 @@ export function MediaDeviceRow({
     kind === "camera" ? "Refresh cameras" : "Refresh microphones";
 
   return (
-    <div className="media-device-row" ref={rowRef}>
-      <div className={`row ${on ? "row-on" : "row-off"}`}>
-        <span className="row-icon">
-          <Icon />
-        </span>
-        <button
-          type="button"
-          className="row-button"
-          onClick={() => setOpen((v) => !v)}
-          disabled={disabled}
-          title={label}
-        >
-          <span className="row-label">{label}</span>
-          {kind === "mic" && on ? (
-            <MicWave deviceId={selectedId} active={on && meterActive} />
-          ) : (
-            <span className="row-flex" aria-hidden />
-          )}
-        </button>
-        {canOpenMenu ? (
+    <div className="media-device-row">
+      <div className="media-device-picker" ref={rowRef}>
+        <div className={`row ${on ? "row-on" : "row-off"}`}>
+          <span className="row-icon">
+            <Icon />
+          </span>
           <button
             type="button"
-            className="row-menu-trigger"
-            onClick={() => setOpen((value) => !value)}
-            aria-label={on ? `Choose ${kind}` : "System audio settings"}
-            aria-expanded={open}
-            aria-haspopup="menu"
+            className="row-button"
+            onClick={() => setOpen((v) => !v)}
+            disabled={disabled}
+            title={label}
           >
-            <ChevronDown />
+            <span className="row-label">{label}</span>
+            {kind === "mic" && on ? (
+              <MicWave deviceId={selectedId} active={on && meterActive} />
+            ) : (
+              <span className="row-flex" aria-hidden />
+            )}
           </button>
-        ) : (
-          <span className="row-chev" aria-hidden>
-            <ChevronDown />
-          </span>
-        )}
-        <Toggle
-          on={on}
-          onChange={(v) => {
-            if (!v) setOpen(false);
-            onToggle(v);
-          }}
-          label={kind === "camera" ? "Camera" : "Microphone"}
-        />
-      </div>
-      {open && canOpenMenu ? (
-        <div className="row-menu" role="menu">
-          {on ? (
-            <>
-              <button
-                type="button"
-                className={`row-menu-item ${!selectedId ? "selected" : ""}`}
-                role="menuitemradio"
-                aria-checked={!selectedId}
-                onClick={() => {
-                  onSelect("", "");
-                  setOpen(false);
-                }}
-              >
-                <span className="row-menu-check" aria-hidden>
-                  {!selectedId ? <CheckIcon /> : null}
-                </span>
-                <span className="row-menu-label">{defaultLabel}</span>
-              </button>
-              {devices.length === 0 ? (
+          {canOpenMenu ? (
+            <button
+              type="button"
+              className="row-menu-trigger"
+              onClick={() => setOpen((value) => !value)}
+              aria-label={on ? `Choose ${kind}` : "System audio settings"}
+              aria-expanded={open}
+              aria-haspopup="menu"
+            >
+              <ChevronDown />
+            </button>
+          ) : (
+            <span className="row-chev" aria-hidden>
+              <ChevronDown />
+            </span>
+          )}
+          <Toggle
+            on={on}
+            onChange={(v) => {
+              if (!v) setOpen(false);
+              onToggle(v);
+            }}
+            label={kind === "camera" ? "Camera" : "Microphone"}
+          />
+        </div>
+        {open && canOpenMenu ? (
+          <div className="row-menu" role="menu">
+            {on ? (
+              <>
                 <button
                   type="button"
-                  className="row-menu-item row-menu-action"
-                  role="menuitem"
+                  className={`row-menu-item ${!selectedId ? "selected" : ""}`}
+                  role="menuitemradio"
+                  aria-checked={!selectedId}
                   onClick={() => {
-                    onRefresh();
+                    onSelect("", "");
                     setOpen(false);
                   }}
                 >
-                  <span className="row-menu-check" aria-hidden />
-                  <span className="row-menu-label">{accessLabel}</span>
+                  <span className="row-menu-check" aria-hidden>
+                    {!selectedId ? <CheckIcon /> : null}
+                  </span>
+                  <span className="row-menu-label">{defaultLabel}</span>
                 </button>
-              ) : (
-                <>
-                  {devices.map((d) => {
-                    const isSelected =
-                      !!selectedId && d.deviceId === selectedId;
-                    return (
-                      <button
-                        key={d.deviceId}
-                        type="button"
-                        className={`row-menu-item ${isSelected ? "selected" : ""}`}
-                        role="menuitemradio"
-                        aria-checked={isSelected}
-                        onClick={() => {
-                          onSelect(d.deviceId, d.label);
-                          setOpen(false);
-                        }}
-                      >
-                        <span className="row-menu-check" aria-hidden>
-                          {isSelected ? <CheckIcon /> : null}
-                        </span>
-                        <span className="row-menu-label">
-                          {d.label ||
-                            (kind === "camera" ? "Camera" : "Microphone")}
-                        </span>
-                      </button>
-                    );
-                  })}
+                {devices.length === 0 ? (
                   <button
                     type="button"
                     className="row-menu-item row-menu-action"
@@ -225,23 +189,78 @@ export function MediaDeviceRow({
                     }}
                   >
                     <span className="row-menu-check" aria-hidden />
-                    <span className="row-menu-label">{refreshLabel}</span>
+                    <span className="row-menu-label">{accessLabel}</span>
                   </button>
-                </>
-              )}
-            </>
-          ) : null}
-          {kind === "mic" && onSystemAudioToggle ? (
-            <div className="row-menu-toggle">
-              <span className="row-menu-toggle-label">Record System audio</span>
-              <Switch
+                ) : (
+                  <>
+                    {devices.map((d) => {
+                      const isSelected =
+                        !!selectedId && d.deviceId === selectedId;
+                      return (
+                        <button
+                          key={d.deviceId}
+                          type="button"
+                          className={`row-menu-item ${isSelected ? "selected" : ""}`}
+                          role="menuitemradio"
+                          aria-checked={isSelected}
+                          onClick={() => {
+                            onSelect(d.deviceId, d.label);
+                            setOpen(false);
+                          }}
+                        >
+                          <span className="row-menu-check" aria-hidden>
+                            {isSelected ? <CheckIcon /> : null}
+                          </span>
+                          <span className="row-menu-label">
+                            {d.label ||
+                              (kind === "camera" ? "Camera" : "Microphone")}
+                          </span>
+                        </button>
+                      );
+                    })}
+                    <button
+                      type="button"
+                      className="row-menu-item row-menu-action"
+                      role="menuitem"
+                      onClick={() => {
+                        onRefresh();
+                        setOpen(false);
+                      }}
+                    >
+                      <span className="row-menu-check" aria-hidden />
+                      <span className="row-menu-label">{refreshLabel}</span>
+                    </button>
+                  </>
+                )}
+              </>
+            ) : null}
+          </div>
+        ) : null}
+      </div>
+      {kind === "mic" && onSystemAudioToggle ? (
+        <Tooltip>
+          <TooltipTrigger asChild>
+            <div
+              className={`row system-audio-option ${systemAudio ? "row-on" : "row-off"}`}
+            >
+              <span className="row-icon">
+                <IconVinyl size={18} stroke={1.75} />
+              </span>
+              <span className="system-audio-option-label">
+                Record System Audio
+              </span>
+              <span className="row-flex" aria-hidden />
+              <Toggle
                 on={!!systemAudio}
                 onChange={onSystemAudioToggle}
-                label="Record system audio"
+                label="Record System Audio"
               />
             </div>
-          ) : null}
-        </div>
+          </TooltipTrigger>
+          <TooltipContent side="bottom">
+            Record audio from other applications
+          </TooltipContent>
+        </Tooltip>
       ) : null}
     </div>
   );

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

@@ -2111,6 +2111,155 @@ async function selectRegionForRecording(): Promise<RegionCaptureRect> {
   }
 }
 
+class MonitorPickerCancelledError extends Error {
+  constructor() {
+    super("Full-screen monitor selection cancelled");
+    this.name = "AbortError";
+  }
+}
+
+/**
+ * Safety net only — a normal pick takes as long as the user needs. This
+ * guards against the picker windows being torn down by something other than
+ * a click or Escape (a monitor disconnecting mid-pick, some other teardown)
+ * with neither selection event ever firing, which would otherwise hang the
+ * recording-start flow forever. Matches the "abandon after a while" window
+ * used elsewhere in this file (see `CUE_IDLE_CLEANUP_MS` in audio-cue.ts).
+ */
+const MONITOR_PICKER_SELECTION_TIMEOUT_MS = 5 * 60_000;
+
+function waitForMonitorPickerSelection(): {
+  promise: Promise<number | null>;
+  cleanup: () => void;
+} {
+  let settled = false;
+  const unlistens: UnlistenFn[] = [];
+  let timer: ReturnType<typeof setTimeout> | null = null;
+
+  const cleanup = () => {
+    settled = true;
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+    for (const unlisten of unlistens.splice(0)) {
+      try {
+        unlisten();
+      } catch {
+        // ignore
+      }
+    }
+  };
+
+  const promise = new Promise<number | null>((resolve, reject) => {
+    const finish = (cancelled: boolean, displayId: number | null) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      if (cancelled) reject(new MonitorPickerCancelledError());
+      else resolve(displayId);
+    };
+
+    timer = setTimeout(() => {
+      finish(true, null);
+    }, MONITOR_PICKER_SELECTION_TIMEOUT_MS);
+
+    const track = (listener: Promise<UnlistenFn>) => {
+      listener
+        .then((unlisten) => {
+          if (settled) {
+            try {
+              unlisten();
+            } catch {
+              // ignore
+            }
+            return;
+          }
+          unlistens.push(unlisten);
+        })
+        .catch((err) => {
+          if (settled) return;
+          settled = true;
+          cleanup();
+          reject(err);
+        });
+    };
+
+    track(
+      listen<{ displayId?: number | null }>(
+        "clips:monitor-picker-selected",
+        (event) => {
+          const raw = event.payload?.displayId;
+          const displayId =
+            typeof raw === "number" && Number.isFinite(raw) && raw > 0
+              ? raw
+              : null;
+          finish(false, displayId);
+        },
+      ),
+    );
+    track(
+      listen("clips:monitor-picker-cancelled", () => {
+        finish(true, null);
+      }),
+    );
+  });
+
+  return { promise, cleanup };
+}
+
+/**
+ * When more than one monitor is connected, shows a small "record this
+ * screen" popup centered on each one and waits for the user to pick one —
+ * or cancel with Escape, which aborts the whole recording start. Resolves
+ * immediately with no popup when there's only one monitor, matching the
+ * prior single-monitor behavior.
+ *
+ * Callers must await this BEFORE flipping any "recording is starting" UI
+ * state (toolbar, timer, etc.) — that chrome positions itself on whatever
+ * `tray_monitor_physical_rect` returns at the moment it's shown, which
+ * reads this pick. Called from `startNativeFullscreenRecording` instead,
+ * the toolbar was already up (and pinned to the wrong screen) by the time
+ * the user finished picking.
+ */
+export async function pickFullscreenRecordingDisplay(): Promise<void> {
+  // Registered BEFORE showing the picker windows: a fast click (or keyboard
+  // activation) can otherwise fire the selection event before these
+  // listeners exist, and Tauri does not replay events to a listener
+  // registered after the fact — the wait would then sit until its timeout.
+  const selection = waitForMonitorPickerSelection();
+  let shown: boolean;
+  try {
+    shown = await invoke<boolean>("show_monitor_picker");
+  } catch (err) {
+    selection.cleanup();
+    throw err;
+  }
+  if (!shown) {
+    selection.cleanup();
+    return;
+  }
+  let displayId: number | null = null;
+  try {
+    displayId = await selection.promise;
+  } catch (err) {
+    selection.cleanup();
+    await invoke("close_monitor_picker").catch(() => {});
+    throw err;
+  }
+  try {
+    // Deliberately not swallowed: if this fails, `tray_display_id` falls
+    // back to the tray-anchor screen with no way for the caller to tell
+    // that happened, silently recording a different screen than the one
+    // the user just picked. Propagate so the caller aborts the start
+    // instead.
+    await invoke("set_recording_display_override", { displayId });
+  } finally {
+    selection.cleanup();
+    await invoke("close_monitor_picker").catch(() => {});
+  }
+}
+
 async function prepareCountdownEventWaiter(
   timeoutMs = 4000,
   signal?: AbortSignal,
@@ -3063,6 +3212,9 @@ async function startNativeFullscreenRecording(
       // down on stop, cancel, and the error paths below.
       await showRegionRecordBorder(captureRegion);
     }
+    // Full-screen's monitor pick already happened in the caller, before
+    // `recordingFlowActive`/the toolbar went up — see
+    // `pickFullscreenRecordingDisplay`'s doc comment for why.
 
     if (localOnly && localRecordingMode === "separate" && wantsCamera) {
       localCameraStream =
@@ -3443,7 +3595,16 @@ async function startNativeFullscreenRecording(
         );
       });
     await localCameraExport?.cancel().catch(() => {});
-    await invoke("native_fullscreen_recording_cancel").catch((err) =>
+    // A restart discards this take and immediately starts a replacement on
+    // the SAME screen without re-running the monitor picker (native restarts
+    // hand off the live capture, not a browser display stream — see
+    // `pickFullscreenRecordingDisplay`'s skip condition in app.tsx). Without
+    // `preserveDisplayOverride`, these calls would clear the pick before the
+    // replacement recording ever reads it, silently falling back to the
+    // tray-anchor screen.
+    await invoke("native_fullscreen_recording_cancel", {
+      preserveDisplayOverride: forRestart,
+    }).catch((err) =>
       console.warn("[clips-recorder] native fullscreen cancel failed:", err),
     );
     if (bubbleCaptureExcluded) {
@@ -3457,7 +3618,9 @@ async function startNativeFullscreenRecording(
     }
     streamCleanups.forEach((cleanup) => cleanup());
     if (forRestart) {
-      await invoke("hide_recording_chrome").catch(() => {});
+      await invoke("hide_recording_chrome", {
+        preserveDisplayOverride: true,
+      }).catch(() => {});
     } else {
       await endSession();
     }

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

@@ -10,6 +10,7 @@ import { Finalizing } from "./overlays/finalizing";
 import { FlowBar } from "./overlays/flow-bar";
 import { MeetingNotification } from "./overlays/meeting-notification";
 import { MeetingNub } from "./overlays/meeting-nub";
+import { MonitorPicker } from "./overlays/monitor-picker";
 import { Onboarding } from "./overlays/onboarding";
 import { Preparing } from "./overlays/preparing";
 import { RecordingPill } from "./overlays/recording-pill";
@@ -64,6 +65,8 @@ function pickRoute(route: string): React.ReactElement {
       return <RegionGuideEditor mode="capture" />;
     case "region-record-border":
       return <RegionRecordBorder />;
+    case "monitor-picker":
+      return <MonitorPicker />;
     default:
       return <App />;
   }