@agent-native/core 0.90.1 → 0.90.3

package/corpus/templates/clips/app/routes/record.tsx

@@ -7,7 +7,10 @@ import {
 } from "@agent-native/core/client";
 import { useLiveTranscription } from "@agent-native/core/client/transcription/use-live-transcription";
 import type { BrowserDiagnosticsData } from "@shared/browser-diagnostics";
-import { waitForReadyRecordingAfterFinalizeError } from "@shared/finalize-recovery";
+import {
+  isStoredButUnservableFinalizeError,
+  waitForReadyRecordingAfterFinalizeError,
+} from "@shared/finalize-recovery";
 import {
   chunkUploadUrl,
   pickMimeType,
@@ -1357,6 +1360,7 @@ export default function RecordRoute() {
   // upload pipeline so finalize-recording handles it identically.
   // -------------------------------------------------------------------------
   const UPLOAD_CHUNK_BYTES = 3 * 1024 * 1024;
+  const UPLOAD_PARALLELISM = 4;
 
   const probeVideoMetadata = useCallback(
     (
@@ -1602,92 +1606,180 @@ export default function RecordRoute() {
           1,
           Math.ceil(uploadBlob.size / UPLOAD_CHUNK_BYTES),
         );
-        let finalChunkResult: Record<string, unknown> | null = null;
-        for (let i = 0; i < totalChunks; i++) {
-          if (isStale()) throw makeAbortError("Upload cancelled");
+
+        const chunkDescs = Array.from({ length: totalChunks }, (_, i) => {
           const start = i * UPLOAD_CHUNK_BYTES;
           const end = Math.min(start + UPLOAD_CHUNK_BYTES, uploadBlob.size);
-          const slice = uploadBlob.slice(start, end, uploadMimeType);
           const isFinal = i === totalChunks - 1;
-          const chunkUrl = chunkUploadUrl(uploadBase, {
+          return {
             index: i,
-            total: totalChunks,
+            slice: uploadBlob.slice(start, end, uploadMimeType),
             isFinal,
-            mimeType: uploadMimeType,
-            durationMs: isFinal ? meta.durationMs : undefined,
-            width: isFinal ? meta.width : undefined,
-            height: isFinal ? meta.height : undefined,
-            hasAudio: isFinal ? true : undefined,
-            hasCamera: isFinal ? false : undefined,
+            url: chunkUploadUrl(uploadBase, {
+              index: i,
+              total: totalChunks,
+              isFinal,
+              mimeType: uploadMimeType,
+              durationMs: isFinal ? meta.durationMs : undefined,
+              width: isFinal ? meta.width : undefined,
+              height: isFinal ? meta.height : undefined,
+              hasAudio: isFinal ? true : undefined,
+              hasCamera: isFinal ? false : undefined,
+            }),
+          };
+        });
+        const finalChunkDesc = chunkDescs[chunkDescs.length - 1];
+        const parallelChunks = chunkDescs.slice(0, -1);
+
+        const chunkAbort = new AbortController();
+        if (abort.signal.aborted) {
+          chunkAbort.abort(abort.signal.reason);
+        } else {
+          abort.signal.addEventListener(
+            "abort",
+            () => chunkAbort.abort(abort.signal.reason),
+            { once: true },
+          );
+        }
+
+        const finalChunk = { result: null as Record<string, unknown> | null };
+        let uploadError: Error | null = null;
+        const queue = parallelChunks.slice();
+
+        const worker = async () => {
+          while (queue.length > 0) {
+            if (isStale() || chunkAbort.signal.aborted) break;
+            const item = queue.shift();
+            if (!item) break;
+            const { index, slice, url } = item;
+
+            let chunkRes: Response;
+            try {
+              chunkRes = await fetch(url, {
+                method: "POST",
+                headers: { "Content-Type": uploadMimeType },
+                body: await slice.arrayBuffer(),
+                signal: chunkAbort.signal,
+              });
+            } catch (err) {
+              if (chunkAbort.signal.aborted) return;
+              if (!uploadError) {
+                uploadError =
+                  err instanceof Error ? err : new Error(String(err));
+                chunkAbort.abort(uploadError);
+              }
+              return;
+            }
+
+            if (!chunkRes.ok) {
+              const text = await chunkRes.text().catch(() => "");
+              const error = new Error(
+                t("recordRoute.uploadFailedAtChunk", {
+                  chunk: index + 1,
+                  total: totalChunks,
+                  message: text || chunkRes.statusText,
+                }),
+              );
+              (error as Error & { status?: number }).status = chunkRes.status;
+              if (!uploadError) {
+                uploadError = error;
+                chunkAbort.abort(uploadError);
+              }
+              return;
+            }
+            setUploadProgress((index + 1) / totalChunks);
+          }
+        };
+
+        await Promise.all(
+          Array.from(
+            { length: Math.min(UPLOAD_PARALLELISM, parallelChunks.length) },
+            worker,
+          ),
+        );
+
+        if (uploadError) throw uploadError;
+        if (abort.signal.aborted) {
+          const reason = abort.signal.reason;
+          throw reason instanceof Error
+            ? reason
+            : makeAbortError("Upload cancelled");
+        }
+        if (isStale()) throw makeAbortError("Upload cancelled");
+
+        const { index, slice, url } = finalChunkDesc;
+        let chunkRes: Response | null = null;
+        try {
+          chunkRes = await fetch(url, {
+            method: "POST",
+            headers: { "Content-Type": uploadMimeType },
+            body: await slice.arrayBuffer(),
+            signal: abort.signal,
           });
-          let chunkRes: Response;
-          try {
-            chunkRes = await fetch(chunkUrl, {
-              method: "POST",
-              headers: { "Content-Type": uploadMimeType },
-              body: await slice.arrayBuffer(),
+        } catch (err) {
+          if (
+            createdId &&
+            (err as { name?: string } | null)?.name !== "AbortError"
+          ) {
+            const recovered = await waitForReadyRecordingAfterFinalizeError({
+              uploadUrl: uploadBase,
+              recordingId: createdId,
+              preferAuthenticated: true,
               signal: abort.signal,
             });
-          } catch (err) {
-            if (
-              isFinal &&
-              createdId &&
-              (err as { name?: string } | null)?.name !== "AbortError"
-            ) {
-              const recovered = await waitForReadyRecordingAfterFinalizeError({
-                uploadUrl: uploadBase,
-                recordingId: createdId,
-                preferAuthenticated: true,
-              });
-              if (recovered) {
-                finalChunkResult = recovered;
-                break;
-              }
+            if (recovered) {
+              finalChunk.result = recovered;
+            } else {
+              throw err;
             }
+          } else {
             throw err;
           }
-          if (!chunkRes.ok) {
-            const text = await chunkRes.text().catch(() => "");
-            const error = new Error(
-              t("recordRoute.uploadFailedAtChunk", {
-                chunk: i + 1,
-                total: totalChunks,
-                message: text || chunkRes.statusText,
-              }),
-            );
-            (error as Error & { status?: number }).status = chunkRes.status;
-            if (
-              isFinal &&
-              createdId &&
-              chunkRes.status !== 413 &&
-              !isUploadSizeError(error.message)
-            ) {
-              const recovered = await waitForReadyRecordingAfterFinalizeError({
-                uploadUrl: uploadBase,
-                recordingId: createdId,
-                preferAuthenticated: true,
-              });
-              if (recovered) {
-                finalChunkResult = recovered;
-                break;
-              }
+        }
+
+        if (chunkRes && !chunkRes.ok) {
+          const text = await chunkRes.text().catch(() => "");
+          const error = new Error(
+            t("recordRoute.uploadFailedAtChunk", {
+              chunk: index + 1,
+              total: totalChunks,
+              message: text || chunkRes.statusText,
+            }),
+          );
+          (error as Error & { status?: number }).status = chunkRes.status;
+          if (
+            createdId &&
+            chunkRes.status !== 413 &&
+            !isUploadSizeError(error.message)
+          ) {
+            const recovered = await waitForReadyRecordingAfterFinalizeError({
+              uploadUrl: uploadBase,
+              recordingId: createdId,
+              preferAuthenticated: true,
+              signal: abort.signal,
+            });
+            if (recovered) {
+              finalChunk.result = recovered;
+            } else {
+              throw error;
             }
+          } else {
             throw error;
           }
-          if (isFinal) {
-            finalChunkResult =
-              ((await chunkRes.json().catch(() => null)) as Record<
-                string,
-                unknown
-              > | null) ?? null;
-          }
-          setUploadProgress((i + 1) / totalChunks);
+        }
+
+        if (chunkRes?.ok) {
+          finalChunk.result =
+            ((await chunkRes.json().catch(() => null)) as Record<
+              string,
+              unknown
+            > | null) ?? null;
         }
 
         setUiState("complete");
         const waitingForStorage =
-          finalChunkResult?.waitingForStorage === true ||
-          finalChunkResult?.status === "waiting_storage";
+          finalChunk.result?.waitingForStorage === true ||
+          finalChunk.result?.status === "waiting_storage";
         if (waitingForStorage) {
           toast.info(t("recordRoute.videoReadyToUpload"), {
             description: t("recordRoute.connectStorageToFinish"),
@@ -1725,7 +1817,9 @@ export default function RecordRoute() {
             : undefined;
         const serverRejectedTooLarge =
           status === 413 || isUploadSizeError(message);
-        if (createdId && !serverRejectedTooLarge) {
+        const preserveBufferedChunks =
+          isStoredButUnservableFinalizeError(message);
+        if (createdId && !serverRejectedTooLarge && !preserveBufferedChunks) {
           fetch(`${appBasePath()}/api/uploads/${createdId}/abort`, {
             method: "POST",
             headers: { "Content-Type": "application/json" },
@@ -2038,11 +2132,13 @@ export default function RecordRoute() {
         return;
       }
       await saveBrowserDiagnostics(pending.id);
-      fetch(pending.abortUrl, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ reason: message }),
-      }).catch(() => {});
+      if (!isStoredButUnservableFinalizeError(message)) {
+        fetch(pending.abortUrl, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ reason: message }),
+        }).catch(() => {});
+      }
       setError(message);
       setUiState("error");
       toast.error(t("recordRoute.uploadFailed"), {
@@ -2073,11 +2169,13 @@ export default function RecordRoute() {
       }
       const message =
         err instanceof Error ? err.message : t("recordRoute.uploadFailed");
-      fetch(pending.abortUrl, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ reason: message }),
-      }).catch(() => {});
+      if (!isStoredButUnservableFinalizeError(message)) {
+        fetch(pending.abortUrl, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ reason: message }),
+        }).catch(() => {});
+      }
       setCompressionProgress(null);
       setUploadProgress(null);
       setError(message);

package/corpus/templates/clips/changelog/2026-07-02-recordings-now-wait-for-storage-media-to-serve-before-finishing.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-02
+---
+
+Recordings now wait for uploaded media to play from storage before finishing, and playback falls back when a compressed storage copy is temporarily broken.

package/corpus/templates/clips/changelog/2026-07-07-a-pending-app-update-no-longer-blocks-screen-recording-updat.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-07
+---
+
+A pending app update no longer blocks screen recording — updates now install when you restart, not mid-session

package/corpus/templates/clips/changelog/2026-07-07-chrome-extension-recordings-keep-audio-after-refreshing-tab.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-07
+---
+
+Chrome extension recordings now survive refreshing the tab being recorded: the camera bubble and recording toolbar reappear, and tab audio and microphone sound keep recording.

package/corpus/templates/clips/changelog/2026-07-07-clip-playback-progress-now-starts-and-finishes-at-the-right-times.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-07
+---
+
+Clip playback progress now starts at the beginning and reaches the end reliably.

package/corpus/templates/clips/changelog/2026-07-07-sharing-public-clips-now-stays-focused-on-the-normal-link-wi.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-07-07
+---
+
+Sharing public clips now stays focused on the normal link, with agent links tucked away for private clips only.

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

@@ -2318,6 +2318,24 @@ chrome.tabs.onActivated.addListener((info) => {
   })();
 });
 
+// The overlay content script is injected on demand (activeTab), so reloading the
+// launch tab wipes it — the camera bubble and toolbar would vanish for the rest
+// of the recording even though capture keeps running in the offscreen document.
+// Re-inject and re-mount once the launch tab finishes reloading while a recording
+// is active. Scoped to the launch tab (the only tab activeTab lets us touch); a
+// same-URL reload keeps that grant.
+chrome.tabs.onUpdated.addListener((tabId, changeInfo) => {
+  if (changeInfo.status !== "complete") return;
+  void (async () => {
+    await ensureRestored();
+    if (overlayPhase === "idle" || !activeNativeRecording) return;
+    if (tabId !== overlayTabId) return;
+    await mountOverlayOnTab(tabId);
+    broadcastOverlayState();
+    if (overlayPhase === "countdown") await handleOverlaySkip();
+  })();
+});
+
 // While recording, the popup is disabled (setActionPopup("")), so clicking the
 // extension icon lands here: stop & save immediately (or discard if we're still
 // in the pre-roll countdown). When idle, the popup opens and this never fires.

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

@@ -733,19 +733,34 @@ async function buildCompositor(
 async function createMixedAudio(
   streams: MediaStream[],
 ): Promise<{ audioContext: AudioContext | null; tracks: MediaStreamTrack[] }> {
-  const streamsWithAudio = streams.filter(
-    (stream) => stream.getAudioTracks().length,
-  );
-  if (!streamsWithAudio.length) return { audioContext: null, tracks: [] };
-  if (streamsWithAudio.length === 1) {
-    return { audioContext: null, tracks: streamsWithAudio[0].getAudioTracks() };
+  const audioTracks = streams.flatMap((stream) => stream.getAudioTracks());
+  if (!audioTracks.length) return { audioContext: null, tracks: [] };
+  if (audioTracks.length === 1) {
+    return { audioContext: null, tracks: audioTracks };
   }
 
   const audioContext = new AudioContext();
   await audioContext.resume().catch(() => undefined);
   const destination = audioContext.createMediaStreamDestination();
-  for (const stream of streamsWithAudio) {
-    audioContext.createMediaStreamSource(stream).connect(destination);
+  for (const track of audioTracks) {
+    // One source per track (not per stream) so each input is isolated in the
+    // mix graph and can be detached independently.
+    const source = audioContext.createMediaStreamSource(
+      new MediaStream([track]),
+    );
+    source.connect(destination);
+    // A mixed input track can end mid-recording — most commonly the shared
+    // tab's audio track when the user refreshes the captured tab. Disconnect
+    // just that dead source so the mixed output keeps carrying the surviving
+    // inputs (the microphone). Without this the whole mixed destination can go
+    // silent, dropping both the tab audio and the mic for the rest of the clip.
+    track.addEventListener("ended", () => {
+      try {
+        source.disconnect();
+      } catch {
+        /* already disconnected */
+      }
+    });
   }
   return { audioContext, tracks: destination.stream.getAudioTracks() };
 }

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;