@agent-native/core 0.87.0 → 0.90.1

package/corpus/templates/clips/chrome-extension/src/popup.ts

@@ -1,3 +1,5 @@
+import { isSelectableAudioInputDevice } from "@shared/media-device-selection";
+
 import { captureExtensionError, initExtensionSentry } from "./sentry";
 
 initExtensionSentry("popup");
@@ -190,6 +192,19 @@ async function loadFeedbackSchema(
   return pending;
 }
 
+// Chrome (and some OSes) surface synthetic aliases alongside real hardware:
+// a "default" device that mirrors whatever the OS currently considers its
+// default input, and sometimes a "communications" variant. Both re-resolve to
+// a possibly-different physical device at capture time (e.g. macOS Continuity
+// can silently promote a nearby iPhone's mic to system default), so picking
+// one of these rows does not pin recording to the hardware the label implies.
+// Filter them out and only ever list/persist stable hardware device ids.
+const VIRTUAL_DEVICE_ID_RE = /^(default|communications)$/i;
+
+function isVirtualDefaultDevice(device: MediaDeviceInfo): boolean {
+  return VIRTUAL_DEVICE_ID_RE.test(device.deviceId);
+}
+
 // Enumerate the user's input devices for the camera/mic pickers. Labels only
 // populate after camera/mic permission is granted (the extension's permission
 // onboarding page handles that), so fall back to a generic label otherwise.
@@ -203,12 +218,13 @@ async function enumerateInputDevices(): Promise<{
     const microphones: InputDevice[] = [];
     for (const device of devices) {
       if (!device.deviceId) continue;
+      if (isVirtualDefaultDevice(device)) continue;
       if (device.kind === "videoinput") {
         cameras.push({
           deviceId: device.deviceId,
           label: device.label.trim() || `Camera ${cameras.length + 1}`,
         });
-      } else if (device.kind === "audioinput") {
+      } else if (isSelectableAudioInputDevice(device)) {
         microphones.push({
           deviceId: device.deviceId,
           label: device.label.trim() || `Microphone ${microphones.length + 1}`,
@@ -563,6 +579,11 @@ let inputDevices: { cameras: InputDevice[]; microphones: InputDevice[] } = {
   microphones: [],
 };
 
+// Distinguishes "the user explicitly picked the OS default" from "the id we
+// have on file doesn't match any enumerated device anymore" (e.g. the device
+// was unplugged, or it was a stale/virtual id saved before this fix). The two
+// cases must not collapse into the same label — that's what let a stored id
+// silently re-resolve to something other than what the UI implied.
 function deviceLabel(
   devices: InputDevice[],
   deviceId: string,
@@ -570,7 +591,7 @@ function deviceLabel(
 ): string {
   if (!deviceId) return fallback;
   const match = devices.find((device) => device.deviceId === deviceId);
-  return match ? match.label : fallback;
+  return match ? match.label : `${fallback} (device disconnected)`;
 }
 
 function renderDeviceMenu(
@@ -622,13 +643,13 @@ function renderDevicePickers(settings: ExtensionSettings): void {
     cameraLabel.textContent = deviceLabel(
       inputDevices.cameras,
       settings.videoDeviceId,
-      "Default camera",
+      "System default",
     );
     renderDeviceMenu(
       cameraMenu,
       inputDevices.cameras,
       settings.videoDeviceId,
-      "Default camera",
+      "System default",
     );
   } else {
     cameraMenu.hidden = true;
@@ -643,13 +664,13 @@ function renderDevicePickers(settings: ExtensionSettings): void {
     micLabel.textContent = deviceLabel(
       inputDevices.microphones,
       settings.audioDeviceId,
-      "Default mic",
+      "System default",
     );
     renderDeviceMenu(
       micMenu,
       inputDevices.microphones,
       settings.audioDeviceId,
-      "Default mic",
+      "System default",
     );
   } else {
     micMenu.hidden = true;
@@ -848,7 +869,37 @@ async function init(): Promise<void> {
   // this is also re-run when the device list changes.
   const refreshDevices = async (): Promise<void> => {
     inputDevices = await enumerateInputDevices();
+    // A stored device id that no longer matches anything enumerated (unplugged
+    // hardware, or a stale virtual "default" id saved before this fix) must not
+    // keep being treated as a real selection — clear it so capture honestly
+    // falls back to the OS default instead of trying to `exact`-match a ghost id.
+    // Only trust a NON-empty list, though: enumeration yields empty lists on
+    // transient errors or before permission is granted, and wiping a valid
+    // saved selection over that would destroy the user's choice for no reason
+    // (the label already renders a fallback while the list is empty).
+    let settingsChanged = false;
+    if (
+      settings.videoDeviceId &&
+      inputDevices.cameras.length > 0 &&
+      !inputDevices.cameras.some(
+        (device) => device.deviceId === settings.videoDeviceId,
+      )
+    ) {
+      settings.videoDeviceId = "";
+      settingsChanged = true;
+    }
+    if (
+      settings.audioDeviceId &&
+      inputDevices.microphones.length > 0 &&
+      !inputDevices.microphones.some(
+        (device) => device.deviceId === settings.audioDeviceId,
+      )
+    ) {
+      settings.audioDeviceId = "";
+      settingsChanged = true;
+    }
     renderDevicePickers(settings);
+    if (settingsChanged) void saveSettings(settings);
   };
 
   const closeDeviceMenus = (): void => {

package/corpus/templates/clips/desktop/package.json

@@ -9,7 +9,7 @@
     "kill:installed": "pkill -x Clips 2>/dev/null; exit 0",
     "dev": "pnpm run check:prereqs && pnpm run kill:installed && tauri dev",
     "build": "vite build",
-    "build:tauri": "pnpm run check:prereqs && tauri build",
+    "build:tauri": "CLIPS_DESKTOP_LOCAL_BUILD=1 pnpm run check:prereqs && CLIPS_DESKTOP_LOCAL_BUILD=1 tauri build --config '{\"bundle\":{\"createUpdaterArtifacts\":false},\"plugins\":{\"updater\":{\"active\":false}}}' && node ./scripts/sign-macos-local.ts",
     "tauri": "tauri",
     "vite:dev": "vite",
     "vite:build": "vite build"

package/corpus/templates/clips/desktop/scripts/sign-macos-local.ts

@@ -0,0 +1,67 @@
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const DEFAULT_IDENTITY =
+  "Developer ID Application: Builder.io, Inc (W3PMF2T3MW)";
+
+if (process.platform !== "darwin") {
+  process.exit(0);
+}
+
+const scriptDir = dirname(fileURLToPath(import.meta.url));
+const desktopDir = resolve(scriptDir, "..");
+const appPath = resolve(
+  desktopDir,
+  "src-tauri/target/release/bundle/macos/Clips.app",
+);
+const entitlementsPath = resolve(desktopDir, "src-tauri/Entitlements.plist");
+
+if (!existsSync(appPath)) {
+  console.warn(`[clips-desktop] No macOS app bundle found at ${appPath}`);
+  process.exit(0);
+}
+
+function sign(identity: string) {
+  const result = spawnSync(
+    "codesign",
+    [
+      "--force",
+      "--deep",
+      "--sign",
+      identity,
+      "--options",
+      "runtime",
+      "--entitlements",
+      entitlementsPath,
+      appPath,
+    ],
+    { encoding: "utf8" },
+  );
+  if (result.stdout) process.stdout.write(result.stdout);
+  if (result.stderr) process.stderr.write(result.stderr);
+  return result;
+}
+
+const configuredIdentity = process.env.CLIPS_MACOS_CODESIGN_IDENTITY;
+const identity = configuredIdentity || DEFAULT_IDENTITY;
+let result = sign(identity);
+
+if (
+  result.status !== 0 &&
+  !configuredIdentity &&
+  /identity|not found|no identity/i.test(
+    `${result.stdout ?? ""}\n${result.stderr ?? ""}`,
+  )
+) {
+  console.warn(
+    "[clips-desktop] Builder.io Developer ID identity is unavailable; falling back to ad-hoc signing.",
+  );
+  console.warn(
+    "[clips-desktop] Camera capture may still require a Developer ID signed local build.",
+  );
+  result = sign("-");
+}
+
+process.exit(result.status ?? 1);

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

@@ -42,14 +42,20 @@ import { Tooltip, TooltipContent, TooltipTrigger } from "./components/Tooltip";
 import { UpdateBanner } from "./components/UpdateBanner";
 import { useMediaDevices } from "./hooks/useMediaDevices";
 import { useMeetingTranscription } from "./hooks/useMeetingTranscription";
+import { stopAllMicMeters } from "./hooks/useMicMeter";
 import { startBubbleFramePump } from "./lib/bubble-pump";
 import {
   startBubbleWebrtc,
   type BubbleWebrtcHandle,
 } from "./lib/bubble-webrtc";
+import {
+  getCameraStreamWithFallback,
+  isMediaConstraintFailure,
+} from "./lib/media-capture-constraints";
 import {
   isHardCapturePermissionError,
   MACOS_CAPTURE_PERMISSION_MESSAGE,
+  MACOS_SCREEN_PERMISSION_MESSAGE,
   MACOS_SPEECH_PERMISSION_MESSAGE,
 } from "./lib/permissions";
 import { isMacPlatform, isWindowsPlatform } from "./lib/platform";
@@ -432,6 +438,11 @@ function normalizeVoiceProvider(value: string): VoiceProvider {
   if (value === "auto") return native;
   if (value === "builder") return "builder-gemini";
   if (value === "macos-native" && !isMacPlatform()) return "browser";
+  // Symmetric migration: a persisted "browser" preference from a non-Mac
+  // install (or an older build) silently ran native transcription on Mac
+  // via resolveProvider()'s mic-override branch with zero UI indication.
+  // Normalize the stale value at the source instead (D1).
+  if (value === "browser" && isMacPlatform()) return "macos-native";
   return value === "browser" ||
     value === "macos-native" ||
     value === "whisper" ||
@@ -1358,15 +1369,15 @@ export function App() {
       "[clips-popover] bubble session start — acquiring camera + showing bubble",
     );
 
-    navigator.mediaDevices
-      .getUserMedia({
-        video: {
-          width: { ideal: 1280 },
-          height: { ideal: 720 },
-          ...(cameraId ? { deviceId: { exact: cameraId } } : {}),
-        },
-        audio: false,
-      })
+    // The saved camera id can go stale (webcam unplugged since last launch).
+    // The fallback helper retries once with the default camera on a
+    // constraint failure instead of leaving the ghost id to fail with
+    // OverconstrainedError; once `loadDevices()` refreshes the list below,
+    // the stale selection itself is cleared by `useMediaDevices`.
+    getCameraStreamWithFallback(cameraId, {
+      width: { ideal: 1280 },
+      height: { ideal: 720 },
+    })
       .then(async (s) => {
         if (cancelled) {
           // Effect re-ran before we resolved — throw this stream away.
@@ -1426,6 +1437,13 @@ export function App() {
           err?.name === "NotAllowedError"
         ) {
           setCameraError(MACOS_CAPTURE_PERMISSION_MESSAGE);
+        } else if (isMediaConstraintFailure(err)) {
+          // Even the default-camera retry inside getCameraStreamWithFallback
+          // failed, so no camera is usable right now. Say that plainly
+          // instead of surfacing constraint jargon like "Invalid constraint".
+          setCameraError(
+            "No camera found. Connect a camera, or pick one from the camera menu.",
+          );
         } else {
           setCameraError(`Camera unavailable: ${msg}`);
         }
@@ -1769,7 +1787,7 @@ export function App() {
         );
         if (!granted) {
           setReadinessOpen(true);
-          setRecError(MACOS_CAPTURE_PERMISSION_MESSAGE);
+          setRecError(MACOS_SCREEN_PERMISSION_MESSAGE);
           openPrivacySettings("screen");
           return;
         }
@@ -1780,6 +1798,8 @@ export function App() {
       }
     }
 
+    stopAllMicMeters();
+
     // Latch BEFORE the async work so the popover stays in "recording
     // flow" during the macOS screen-picker focus dance. The bubble
     // session effect also keys off this flag (via `bubbleActive`) so
@@ -2363,7 +2383,7 @@ export function App() {
           onToggle={setMicOn}
           systemAudio={systemAudioOn}
           onSystemAudioToggle={setSystemAudioOn}
-          meterActive={popoverVisible && !isRecording}
+          meterActive={popoverVisible && !isRecording && !recordingFlowActive}
         />
       </div>
 
@@ -2394,11 +2414,16 @@ export function App() {
             : "Start local recording"}
       </button>
       {recError ? (
-        recError === MACOS_CAPTURE_PERMISSION_MESSAGE ? (
+        recError === MACOS_CAPTURE_PERMISSION_MESSAGE ||
+        recError === MACOS_SCREEN_PERMISSION_MESSAGE ? (
           <PermissionRecoveryBanner
             kind="recording"
             message={recError}
-            panes={permissionPanesForRecording(mode, cameraOn, micOn)}
+            panes={
+              recError === MACOS_SCREEN_PERMISSION_MESSAGE
+                ? ["screen"]
+                : permissionPanesForRecording(mode, cameraOn, micOn)
+            }
             onRetry={handleStartRecording}
           />
         ) : recError === MACOS_SPEECH_PERMISSION_MESSAGE ? (

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

@@ -37,6 +37,7 @@ export function SourceRow({
         title={LABELS[value]}
       >
         <span className="row-label">{LABELS[value]}</span>
+        <span className="row-flex" aria-hidden />
         <span className="row-chev" aria-hidden>
           <ChevronDown />
         </span>

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

@@ -8,6 +8,13 @@ import {
   type MutableRefObject,
 } from "react";
 
+import {
+  chooseFallbackAudioInput,
+  findAudioInputBySavedLabel,
+  isPseudoMediaDeviceId,
+  isSelectableAudioInputDevice,
+  normalizedMediaDeviceId,
+} from "../lib/media-device-selection";
 import {
   isHardCapturePermissionError,
   MACOS_CAPTURE_PERMISSION_MESSAGE,
@@ -19,13 +26,13 @@ const MIC_KEY = "clips:last-mic-id";
 const CAM_LABEL_KEY = "clips:last-camera-label";
 const MIC_LABEL_KEY = "clips:last-mic-label";
 
-function normalizedMediaDeviceId(value: string | null | undefined): string {
-  return value?.trim() ?? "";
-}
-
-function isPseudoMediaDeviceId(value: string | null | undefined): boolean {
-  const id = normalizedMediaDeviceId(value).toLowerCase();
-  return id === "default" || id === "communications";
+function rawMicConstraints(deviceId?: string): MediaTrackConstraints {
+  return {
+    ...(deviceId ? { deviceId: { exact: deviceId } } : {}),
+    echoCancellation: false,
+    noiseSuppression: false,
+    autoGainControl: false,
+  };
 }
 
 function concreteMediaDeviceId(value: string | null | undefined): string {
@@ -37,16 +44,6 @@ function isSelectableMediaDevice(device: MediaDeviceInfo): boolean {
   return !!concreteMediaDeviceId(device.deviceId);
 }
 
-function isBuiltInMicDevice(device: MediaDeviceInfo): boolean {
-  const label = device.label.toLowerCase();
-  return (
-    label.includes("macbook") ||
-    label.includes("built-in") ||
-    label.includes("built in") ||
-    label.includes("internal microphone")
-  );
-}
-
 interface Props {
   // Mirrors whether the on-screen camera bubble owns the camera grant. While
   // it does, this page must never probe getUserMedia itself.
@@ -123,11 +120,7 @@ export function useMediaDevices({
           (d) => d.kind === "videoinput" && isSelectableMediaDevice(d),
         ),
       );
-      setMics(
-        list.filter(
-          (d) => d.kind === "audioinput" && isSelectableMediaDevice(d),
-        ),
-      );
+      setMics(list.filter((d) => isSelectableAudioInputDevice(d)));
     } catch {
       // ignore
     }
@@ -141,6 +134,29 @@ export function useMediaDevices({
     };
   }, [loadDevices]);
 
+  // Reopening the popover doesn't reliably re-fire the Tauri
+  // `clips:popover-visible` event (the WebView is shown/hidden, not
+  // remounted, and the native side only ever emits the `false`/hidden
+  // transition). Without this, a webcam unplugged while the popover was
+  // closed would still show the previous session's device list — the exact
+  // "reopen without my webcam, it still shows the old camera selected" bug.
+  // Cover reopen via both signals so it works whether the WebView regains
+  // focus or only its document visibility flips.
+  useEffect(() => {
+    const onFocus = (): void => {
+      loadDevices();
+    };
+    const onVisibility = (): void => {
+      if (document.visibilityState === "visible") loadDevices();
+    };
+    window.addEventListener("focus", onFocus);
+    document.addEventListener("visibilitychange", onVisibility);
+    return () => {
+      window.removeEventListener("focus", onFocus);
+      document.removeEventListener("visibilitychange", onVisibility);
+    };
+  }, [loadDevices]);
+
   const unlockDeviceLabels = useCallback(async () => {
     // Audio-only probe to unlock mic labels. We INTENTIONALLY skip video —
     // the on-screen camera bubble window owns the camera, and probing
@@ -160,7 +176,7 @@ export function useMediaDevices({
         return;
       }
       const s = await navigator.mediaDevices.getUserMedia({
-        audio: { deviceId: { exact: selectedMicId } },
+        audio: rawMicConstraints(selectedMicId),
         video: false,
       });
       s.getTracks().forEach((t) => t.stop());
@@ -179,7 +195,10 @@ export function useMediaDevices({
         const stream = await navigator.mediaDevices.getUserMedia(
           kind === "camera"
             ? { video: true, audio: false }
-            : { audio: true, video: false },
+            : {
+                audio: rawMicConstraints(selectedMicId || undefined),
+                video: false,
+              },
         );
         stream.getTracks().forEach((track) => track.stop());
         await loadDevices();
@@ -220,10 +239,51 @@ export function useMediaDevices({
   }, [loadDevices, unlockDeviceLabels, popoverVisible]);
 
   useEffect(() => {
-    if (!isPseudoMediaDeviceId(micId) || mics.length === 0) return;
-    const builtIn = mics.find(isBuiltInMicDevice);
-    setMicId(builtIn?.deviceId ?? "");
-  }, [micId, mics]);
+    if (!micId || !isPseudoMediaDeviceId(micId) || mics.length === 0) return;
+    const fallback = chooseFallbackAudioInput(mics, {
+      savedLabel: micLabel,
+      avoidDeviceIds: [micId],
+    });
+    if (!fallback) return;
+    console.warn("[clips-recorder] resolved pseudo mic id to concrete input", {
+      previousDeviceId: micId,
+      nextDeviceId: fallback.deviceId,
+      reason: fallback.reason,
+    });
+    setMicId(fallback.deviceId);
+    setMicLabel(fallback.label);
+  }, [micId, micLabel, mics]);
+
+  // A stored device id that no longer matches anything enumerated (e.g. the
+  // webcam/mic was unplugged since the app last ran) must not be rewritten to
+  // the OS default. Keep the explicit choice unless we can rematch it by saved
+  // label, because macOS default can point at Continuity/iPhone.
+  //
+  // Only trust a NON-EMPTY list, though: enumeration legitimately returns an
+  // empty list on a transient error or before permission is granted, and
+  // clearing a valid saved selection over that would destroy the user's
+  // choice for no reason.
+  useEffect(() => {
+    if (!cameraId || cameras.length === 0) return;
+    if (cameras.some((d) => d.deviceId === cameraId)) return;
+    setCameraId("");
+    setCameraLabel("");
+  }, [cameraId, cameras]);
+  useEffect(() => {
+    if (isPseudoMediaDeviceId(micId) || !micId || mics.length === 0) return;
+    if (mics.some((d) => d.deviceId === micId)) return;
+    const rematch = findAudioInputBySavedLabel(mics, {
+      savedLabel: micLabel,
+      avoidDeviceIds: [micId],
+    });
+    if (!rematch) return;
+    console.warn(
+      "[clips-recorder] saved mic id was missing; rematched by label",
+      { previousDeviceId: micId, nextDeviceId: rematch.deviceId },
+    );
+    setMicId(rematch.deviceId);
+    setMicLabel(rematch.label);
+  }, [micId, micLabel, mics]);
 
   useEffect(() => saveString(CAM_KEY, cameraId), [cameraId]);
   useEffect(() => saveString(MIC_KEY, micId), [micId]);