@agent-native/core 0.90.2 → 0.90.3

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

@@ -57,6 +57,7 @@ import {
   MACOS_CAPTURE_PERMISSION_MESSAGE,
   MACOS_SCREEN_PERMISSION_MESSAGE,
   MACOS_SPEECH_PERMISSION_MESSAGE,
+  MACOS_UPDATE_RESTART_MESSAGE,
 } from "./lib/permissions";
 import { isMacPlatform, isWindowsPlatform } from "./lib/platform";
 import {
@@ -78,6 +79,7 @@ import {
   saveBool,
   saveString,
 } from "./lib/storage";
+import { installAndRestart, isUpdatePendingRestart } from "./lib/updater";
 import { normalizeServerUrl } from "./lib/url";
 import {
   installDesktopVoiceDictation,
@@ -1976,7 +1978,16 @@ export function App() {
       return;
     }
     if (isHardCapturePermissionError(message)) {
-      setRecError(MACOS_CAPTURE_PERMISSION_MESSAGE);
+      // If an update has finished downloading and is waiting to install, the
+      // safe next step is to restart (which applies the update and gives the
+      // process a clean binary + permission state). Prefer that hint over the
+      // "grant permissions" banner, which is misleading when the readiness
+      // checkmarks are already green.
+      setRecError(
+        isUpdatePendingRestart()
+          ? MACOS_UPDATE_RESTART_MESSAGE
+          : MACOS_CAPTURE_PERMISSION_MESSAGE,
+      );
       return;
     }
     if (isStorageSetupFailureMessage(message)) {
@@ -2414,8 +2425,10 @@ export function App() {
             : "Start local recording"}
       </button>
       {recError ? (
-        recError === MACOS_CAPTURE_PERMISSION_MESSAGE ||
-        recError === MACOS_SCREEN_PERMISSION_MESSAGE ? (
+        recError === MACOS_UPDATE_RESTART_MESSAGE ? (
+          <UpdateRestartBanner message={recError} />
+        ) : recError === MACOS_CAPTURE_PERMISSION_MESSAGE ||
+          recError === MACOS_SCREEN_PERMISSION_MESSAGE ? (
           <PermissionRecoveryBanner
             kind="recording"
             message={recError}
@@ -2579,6 +2592,30 @@ function PermissionRecoveryBanner({
   );
 }
 
+function UpdateRestartBanner({ message }: { message: string }) {
+  return (
+    <div className="error-banner permission-banner">
+      <div className="permission-copy">
+        <div className="permission-title">Restart to finish updating</div>
+        <div>{message}</div>
+      </div>
+      <div className="permission-actions">
+        <button
+          type="button"
+          className="permission-retry"
+          onClick={() => {
+            installAndRestart().catch((err) => {
+              console.error("[clips-updater] relaunch failed:", err);
+            });
+          }}
+        >
+          Restart Clips
+        </button>
+      </div>
+    </div>
+  );
+}
+
 function StorageConnectionBanner({ onConnect }: { onConnect: () => void }) {
   return (
     <div className="storage-flow-banner">

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

@@ -10,7 +10,6 @@ import {
 
 import {
   chooseFallbackAudioInput,
-  findAudioInputBySavedLabel,
   isPseudoMediaDeviceId,
   isSelectableAudioInputDevice,
   normalizedMediaDeviceId,
@@ -272,17 +271,30 @@ export function useMediaDevices({
   useEffect(() => {
     if (isPseudoMediaDeviceId(micId) || !micId || mics.length === 0) return;
     if (mics.some((d) => d.deviceId === micId)) return;
-    const rematch = findAudioInputBySavedLabel(mics, {
+    // The selected mic (e.g. Bluetooth headset unplugged mid-session) is gone.
+    // Prefer rematching by saved label, then fall back to the best available
+    // input so we don't stay pinned to a device that no longer exists.
+    const fallback = chooseFallbackAudioInput(mics, {
       savedLabel: micLabel,
       avoidDeviceIds: [micId],
     });
-    if (!rematch) return;
+    if (!fallback) {
+      // Nothing concrete left; drop to the OS default rather than keeping the
+      // disconnected device selected.
+      setMicId("");
+      setMicLabel("");
+      return;
+    }
     console.warn(
-      "[clips-recorder] saved mic id was missing; rematched by label",
-      { previousDeviceId: micId, nextDeviceId: rematch.deviceId },
+      "[clips-recorder] saved mic id was missing; fell back to available input",
+      {
+        previousDeviceId: micId,
+        nextDeviceId: fallback.deviceId,
+        reason: fallback.reason,
+      },
     );
-    setMicId(rematch.deviceId);
-    setMicLabel(rematch.label);
+    setMicId(fallback.deviceId);
+    setMicLabel(fallback.label);
   }, [micId, micLabel, mics]);
 
   useEffect(() => saveString(CAM_KEY, cameraId), [cameraId]);

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

@@ -8,6 +8,8 @@ export const MACOS_SCREEN_PERMISSION_MESSAGE =
   "Grant Screen Recording permission in macOS Settings, then restart Clips and try again.";
 export const MACOS_SPEECH_PERMISSION_MESSAGE =
   "Grant Speech Recognition and Microphone access, then try again. If you just changed access, restart Clips before retrying.";
+export const MACOS_UPDATE_RESTART_MESSAGE =
+  "An update was downloaded and needs a restart to finish installing. Restart Clips, then record again.";
 
 export function isHardCapturePermissionError(message: string): boolean {
   return /permission denied by system|blocked by system|system settings|screen recording|privacy|sandbox/i.test(

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

@@ -45,9 +45,15 @@ async function runCheck() {
     const notes = update.body ?? undefined;
     setStatus({ state: "available", version, notes });
 
+    // Download ONLY — do not install here. On macOS `install` swaps the .app
+    // bundle on disk while this process keeps running, which invalidates the
+    // running process's Screen Recording (TCC) grant and breaks capture until
+    // relaunch. We defer the swap to `installAndRestart()` so a downloaded-but-
+    // not-yet-installed update leaves the running app fully functional; the
+    // user records normally until they choose to restart.
     let total = 0;
     let downloaded = 0;
-    await update.downloadAndInstall((event) => {
+    await update.download((event) => {
       if (event.event === "Started") {
         total = event.data.contentLength ?? 0;
         downloaded = 0;
@@ -98,10 +104,27 @@ export function useUpdateStatus(): UpdateStatus {
 }
 
 export async function installAndRestart(): Promise<void> {
-  // downloadAndInstall already applied the bundle; relaunch completes it.
+  // Perform the deferred bundle swap now, then relaunch onto the new binary.
+  // Installing immediately before relaunch keeps the window where the on-disk
+  // bundle no longer matches the running process as short as possible — the
+  // process is torn down by `relaunch()` right after, so capture never runs
+  // against a swapped-out bundle.
+  if (pendingUpdate) {
+    await pendingUpdate.install();
+  }
   await relaunch();
 }
 
+/**
+ * True once an update has been downloaded and is waiting for the user to
+ * restart. The recording flow uses this to explain a post-download capture
+ * failure as "restart to finish updating" instead of a misleading "grant
+ * permissions" message — see `app.tsx` recError routing.
+ */
+export function isUpdatePendingRestart(): boolean {
+  return cachedStatus.state === "downloaded";
+}
+
 /**
  * Manual retry entry point. Used by the UpdateBanner's error state to let
  * users re-attempt after a signature-verification / download / network

package/corpus/templates/clips/desktop/src-tauri/src/native_screen.rs

@@ -1538,6 +1538,13 @@ fn take_and_finalize_active_session(
             session.lost_segment_duration.as_secs()
         );
     }
+
+    if let Some(paused_at) = session.paused_at.take() {
+        session.paused_total = session
+            .paused_total
+            .checked_add(paused_at.elapsed())
+            .unwrap_or(session.paused_total);
+    }
     let duration_ms = session
         .started_at
         .elapsed()

package/corpus/templates/clips/server/routes/api/recordings/[recordingId]/thumbnail.post.ts

@@ -165,6 +165,7 @@ export default defineEventHandler(async (event: H3Event) => {
       mimeType,
       filename: `thumb-${recordingId}.${ext}`,
       ownerEmail,
+      recordAsset: false,
     });
 
     let url: string;

package/corpus/templates/clips/server/routes/api/uploads/[recordingId]/abort.post.ts

@@ -6,10 +6,12 @@
  */
 
 import {
+  readAppState,
   writeAppState,
   deleteAppStateByPrefix,
 } from "@agent-native/core/application-state";
 import { runWithRequestContext } from "@agent-native/core/server";
+import { isStoredButUnservableFinalizeError } from "@shared/finalize-recovery.js";
 import { and, eq } from "drizzle-orm";
 import {
   defineEventHandler,
@@ -50,6 +52,7 @@ export default defineEventHandler(async (event: H3Event) => {
         id: schema.recordings.id,
         status: schema.recordings.status,
         videoUrl: schema.recordings.videoUrl,
+        failureReason: schema.recordings.failureReason,
       })
       .from(schema.recordings)
       .where(
@@ -68,10 +71,14 @@ export default defineEventHandler(async (event: H3Event) => {
       return { ok: true, recordingId, alreadyReady: true, chunksCleared: 0 };
     }
 
+    const preserveRecoveryState =
+      isStoredButUnservableFinalizeError(failureReason) ||
+      isStoredButUnservableFinalizeError(existing.failureReason);
+
     // Already a terminal failure (e.g. a duplicate/retried abort call, or
     // finalize's own failChunkAssembly already flipped it) — no-op instead of
     // re-clearing chunk state and overwriting the original failureReason.
-    if (existing.status === "failed") {
+    if (existing.status === "failed" && !preserveRecoveryState) {
       return { ok: true, recordingId, alreadyFailed: true, chunksCleared: 0 };
     }
 
@@ -85,17 +92,27 @@ export default defineEventHandler(async (event: H3Event) => {
       })
       .where(eq(schema.recordings.id, recordingId));
 
+    const existingUploadStateRaw = await readAppState(
+      `recording-upload-${recordingId}`,
+    ).catch(() => null);
+    const existingUploadState =
+      existingUploadStateRaw && typeof existingUploadStateRaw === "object"
+        ? (existingUploadStateRaw as Record<string, unknown>)
+        : {};
     await writeAppState(`recording-upload-${recordingId}`, {
+      ...existingUploadState,
       recordingId,
       status: "failed",
       failureReason,
       updatedAt: now,
     });
 
-    const cleared = await deleteAppStateByPrefix(
-      `recording-chunks-${recordingId}-`,
-    );
-    await deleteResumableSession(recordingId).catch(() => {});
+    const cleared = preserveRecoveryState
+      ? 0
+      : await deleteAppStateByPrefix(`recording-chunks-${recordingId}-`);
+    if (!preserveRecoveryState) {
+      await deleteResumableSession(recordingId).catch(() => {});
+    }
     await writeAppState("refresh-signal", { ts: Date.now() });
 
     return { ok: true, recordingId, chunksCleared: cleared };

package/corpus/templates/clips/server/routes/api/uploads/[recordingId]/chunk.post.ts

@@ -596,7 +596,15 @@ export default defineEventHandler(async (event: H3Event) => {
             updatedAt: new Date().toISOString(),
           })
           .where(eq(schema.recordings.id, recordingId));
+        const failedUploadStateRaw = await readAppState(
+          `recording-upload-${recordingId}`,
+        ).catch(() => null);
+        const failedUploadState =
+          failedUploadStateRaw && typeof failedUploadStateRaw === "object"
+            ? (failedUploadStateRaw as Record<string, unknown>)
+            : {};
         await writeAppState(`recording-upload-${recordingId}`, {
+          ...failedUploadState,
           recordingId,
           status: "failed",
           failureReason: err instanceof Error ? err.message : "Finalize failed",

package/corpus/templates/clips/server/routes/api/video/[recordingId].get.ts

@@ -177,13 +177,13 @@ function rememberCompressedBuilderMediaMiss(compressedSourceUrl: string): void {
 function shouldFallbackToOriginalMedia(
   upstream: Response | { error: string; status: number },
 ): boolean {
-  return [403, 404, 416].includes(upstream.status);
+  return upstream.status >= 500 || [403, 404, 416].includes(upstream.status);
 }
 
 function shouldRememberCompressedBuilderMediaMiss(
   upstream: Response | { error: string; status: number },
 ): boolean {
-  return [403, 404].includes(upstream.status);
+  return upstream.status >= 500 || [403, 404].includes(upstream.status);
 }
 
 async function fetchProviderMedia(
@@ -497,10 +497,17 @@ export default defineEventHandler(async (event: H3Event) => {
             compressedSourceUrl &&
             !shouldSkipCompressedBuilderMediaProbe(compressedSourceUrl)
           ) {
-            upstream = await fetchProviderMedia(
-              compressedSourceUrl,
-              rangeHeader,
-            );
+            try {
+              upstream = await fetchProviderMedia(
+                compressedSourceUrl,
+                rangeHeader,
+              );
+            } catch (err) {
+              upstream = {
+                status: statusCodeForProviderFetchError(err),
+                error: messageForProviderFetchError(err),
+              };
+            }
             if (shouldRememberCompressedBuilderMediaMiss(upstream)) {
               rememberCompressedBuilderMediaMiss(compressedSourceUrl);
             }

package/corpus/templates/clips/shared/finalize-recovery.ts

@@ -48,6 +48,18 @@ function sleep(ms: number, signal?: AbortSignal): Promise<void> {
   });
 }
 
+export function isStoredButUnservableFinalizeError(value: unknown): boolean {
+  const message =
+    typeof value === "string"
+      ? value
+      : value instanceof Error
+        ? value.message
+        : value && typeof value === "object" && "message" in value
+          ? String((value as { message?: unknown }).message ?? "")
+          : "";
+  return /\bstored-but-unservable\b/i.test(message);
+}
+
 function absoluteUploadUrl(uploadUrl: string): URL {
   if (/^[a-z][a-z0-9+.-]*:/i.test(uploadUrl)) return new URL(uploadUrl);
   const origin =