@agent-native/core 0.84.18 → 0.84.21

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

@@ -33,18 +33,36 @@ const STORAGE_SETUP_REQUIRED_MESSAGE =
   "Connect storage to finish saving this clip: Builder.io (free tier storage + AI) or S3-compatible storage.";
 const STORAGE_SETUP_FAILURE_RE =
   /video storage is not connected|no video storage configured|file upload provider|storage provider|connect builder|s3-compatible/i;
+const CHUNK_UPLOAD_MAX_ATTEMPTS = 3;
+const RETRYABLE_CHUNK_UPLOAD_STATUSES = new Set([
+  408, 425, 429, 500, 502, 503, 504,
+]);
 
 function isStorageSetupFailureMessage(message: string | null | undefined) {
   return STORAGE_SETUP_FAILURE_RE.test(message ?? "");
 }
 
+function isRetryableChunkUploadStatus(status: number): boolean {
+  return RETRYABLE_CHUNK_UPLOAD_STATUSES.has(status);
+}
+
+function retryDelayMs(attempt: number): number {
+  return attempt === 1 ? 500 : 1500;
+}
+
+function waitForRetry(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
 function isFinalUploadRecoveryCandidate(error: Error): boolean {
   const tagged = error as {
+    finalUploadRecoveryAttempted?: boolean;
     finalUpload?: boolean;
     status?: number;
     storageSetupRequired?: boolean;
   };
   if (!tagged.finalUpload || tagged.storageSetupRequired) return false;
+  if (tagged.finalUploadRecoveryAttempted) return false;
   if (tagged.status === 413) return false;
   return !/too large|exceeds.*limit|chunk too large/i.test(error.message);
 }
@@ -129,6 +147,7 @@ type ActiveRecording = {
   sourceStreams: MediaStream[];
   audioContext: AudioContext | null;
   chunkIndex: number;
+  uploadChain: Promise<void>;
   uploadPromises: Promise<unknown>[];
   uploadFailure: Error | null;
   // Local safety buffer: every recorded blob is kept here (browser-managed,
@@ -448,12 +467,50 @@ async function uploadChunk(
   if (recording.authToken) {
     headers.Authorization = `Bearer ${recording.authToken}`;
   }
-  const res = await fetch(url, {
-    method: "POST",
-    headers,
-    credentials: "include",
-    body,
-  });
+  let res: Response | null = null;
+  let triedFinalUploadRecovery = false;
+  for (let attempt = 1; attempt <= CHUNK_UPLOAD_MAX_ATTEMPTS; attempt++) {
+    try {
+      res = await fetch(url, {
+        method: "POST",
+        headers,
+        credentials: "include",
+        body,
+      });
+    } catch (err) {
+      if (attempt >= CHUNK_UPLOAD_MAX_ATTEMPTS) throw err;
+      await waitForRetry(retryDelayMs(attempt));
+      continue;
+    }
+
+    if (
+      !res.ok &&
+      attempt < CHUNK_UPLOAD_MAX_ATTEMPTS &&
+      isRetryableChunkUploadStatus(res.status)
+    ) {
+      if (extra.isFinal && res.status === 504) {
+        triedFinalUploadRecovery = true;
+        await res.text().catch(() => "");
+        const recovered = await waitForReadyRecordingAfterFinalizeError({
+          uploadUrl: recording.uploadUrl,
+          recordingId: recording.recordingId,
+          authToken: recording.authToken,
+        });
+        if (recovered) return recovered;
+        break;
+      }
+      await res.text().catch(() => "");
+      await waitForRetry(retryDelayMs(attempt));
+      continue;
+    }
+
+    break;
+  }
+
+  if (!res) {
+    throw new Error("Upload failed: no response");
+  }
+
   const text = await res.text().catch(() => "");
   let data: UploadResult = {};
   if (text) {
@@ -481,9 +538,11 @@ async function uploadChunk(
             `Upload failed (${res.status}): ${text || res.statusText}`,
     );
     const uploadError = error as {
+      finalUploadRecoveryAttempted?: boolean;
       status?: number;
       storageSetupRequired?: boolean;
     };
+    uploadError.finalUploadRecoveryAttempted = triedFinalUploadRecovery;
     uploadError.status = res.status;
     uploadError.storageSetupRequired = storageSetupRequired;
     captureExtensionError(error, {
@@ -795,6 +854,7 @@ async function begin(message: BeginMessage): Promise<{
     ],
     audioContext: mixedAudio.audioContext,
     chunkIndex: 0,
+    uploadChain: Promise.resolve(),
     uploadPromises: [],
     uploadFailure: null,
     recordedBlobs: [],
@@ -837,30 +897,35 @@ async function begin(message: BeginMessage): Promise<{
     // rejected promise that surfaces as an "Uncaught (in promise)" error (bad
     // look in a Chrome Web Store review). finalizeStop reads recording.upload-
     // Failure and surfaces it through the normal error path instead.
-    const upload = (
-      recording.uploadMode === "streaming"
-        ? uploadStreamingBlob(recording, event.data)
-        : uploadBlobInSlices(recording, event.data)
-    ).catch((err) => {
-      recording.uploadFailure =
-        err instanceof Error ? err : new Error(String(err));
-      captureExtensionError(recording.uploadFailure, {
-        tags: {
-          surface: "offscreen",
-          recordingStep: "dataavailable-upload",
-        },
-        extra: {
-          recordingId: recording.recordingId,
-          blobBytes: event.data.size,
-          chunkIndex: recording.chunkIndex,
-          mimeType: event.data.type || recording.mimeType,
-        },
-      });
-      reportStatus(recording.sessionId, "error", {
-        error: recording.uploadFailure.message,
+    const upload = recording.uploadChain
+      .then(() =>
+        recording.cancelled || recording.uploadFailure
+          ? undefined
+          : recording.uploadMode === "streaming"
+            ? uploadStreamingBlob(recording, event.data)
+            : uploadBlobInSlices(recording, event.data),
+      )
+      .catch((err) => {
+        recording.uploadFailure =
+          err instanceof Error ? err : new Error(String(err));
+        captureExtensionError(recording.uploadFailure, {
+          tags: {
+            surface: "offscreen",
+            recordingStep: "dataavailable-upload",
+          },
+          extra: {
+            recordingId: recording.recordingId,
+            blobBytes: event.data.size,
+            chunkIndex: recording.chunkIndex,
+            mimeType: event.data.type || recording.mimeType,
+          },
+        });
+        reportStatus(recording.sessionId, "error", {
+          error: recording.uploadFailure.message,
+        });
+        if (recorder.state !== "inactive") recorder.stop();
       });
-      if (recorder.state !== "inactive") recorder.stop();
-    });
+    recording.uploadChain = upload.then(() => undefined);
     recording.uploadPromises.push(upload);
   });
 

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

@@ -51,6 +51,7 @@ import { invoke } from "@tauri-apps/api/core";
 import { emit, listen, type UnlistenFn } from "@tauri-apps/api/event";
 import { open as openExternal } from "@tauri-apps/plugin-shell";
 
+import { waitForReadyRecordingAfterFinalizeError } from "../../../shared/finalize-recovery";
 import type { LocalRecordingMode } from "../shared/config";
 import { createAudioCue, type AudioCue } from "./audio-cue";
 import { createCameraCompositeStream } from "./camera-composite";
@@ -718,6 +719,28 @@ async function markBrowserRecordingBackupError(
   });
 }
 
+async function recoverReadyRecordingAfterFinalizeError({
+  serverUrl,
+  recordingId,
+  authToken,
+}: {
+  serverUrl: string;
+  recordingId: string;
+  authToken?: string;
+}): Promise<boolean> {
+  const recovered = await waitForReadyRecordingAfterFinalizeError({
+    uploadUrl: chunkUrl(serverUrl, recordingId, 0, false),
+    recordingId,
+    authToken,
+    preferAuthenticated: true,
+  });
+  if (!recovered) return false;
+  await deleteBrowserRecordingBackup(recordingId).catch((err) => {
+    console.warn("[clips-recorder] recovered backup cleanup failed:", err);
+  });
+  return true;
+}
+
 export async function listBrowserRecordingBackups(): Promise<
   PendingBrowserRecordingUpload[]
 > {
@@ -827,8 +850,12 @@ export async function retryBrowserRecordingBackup(input: {
       );
     }
 
-    await postBackupChunk(
-      chunkUrl(meta.serverUrl, meta.recordingId, validatedChunks.length, true, {
+    const finalChunkUrl = chunkUrl(
+      meta.serverUrl,
+      meta.recordingId,
+      validatedChunks.length,
+      true,
+      {
         total: String(totalPosts),
         mimeType: meta.mimeType,
         durationMs: String(Math.round(meta.durationMs || 0)),
@@ -836,10 +863,29 @@ export async function retryBrowserRecordingBackup(input: {
         ...(meta.height ? { height: String(meta.height) } : {}),
         hasAudio: meta.hasAudio ? "1" : "0",
         hasCamera: meta.hasCamera ? "1" : "0",
-      }),
-      new Blob([], { type: meta.mimeType }),
-      input.authToken,
+      },
     );
+    try {
+      await postBackupChunk(
+        finalChunkUrl,
+        new Blob([], { type: meta.mimeType }),
+        input.authToken,
+      );
+    } catch (err) {
+      if (
+        await recoverReadyRecordingAfterFinalizeError({
+          serverUrl: meta.serverUrl,
+          recordingId: meta.recordingId,
+          authToken: input.authToken,
+        })
+      ) {
+        return {
+          recordingId: meta.recordingId,
+          viewUrl: `/r/${meta.recordingId}`,
+        };
+      }
+      throw err;
+    }
 
     await deleteBrowserRecordingBackup(meta.recordingId);
     return { recordingId: meta.recordingId, viewUrl: `/r/${meta.recordingId}` };
@@ -1986,6 +2032,22 @@ async function startNativeFullscreenRecording(
           try {
             uploadResult = await uploadPromise;
           } catch (err) {
+            if (
+              await recoverReadyRecordingAfterFinalizeError({
+                serverUrl: params.serverUrl,
+                recordingId: id,
+                authToken: params.authToken,
+              })
+            ) {
+              try {
+                await openExternal(
+                  `${params.serverUrl.replace(/\/+$/, "")}${viewUrl}`,
+                );
+              } catch (openErr) {
+                console.error("[clips-recorder] openExternal failed:", openErr);
+              }
+              return { recordingId: id, viewUrl };
+            }
             await abortRecordingUpload(
               params.serverUrl,
               id,
@@ -3225,6 +3287,26 @@ async function startRecordingInner(
       } catch (err) {
         console.error("[clips-recorder] finalize fetch failed:", err);
         const error = err instanceof Error ? err : new Error(String(err));
+        if (
+          await recoverReadyRecordingAfterFinalizeError({
+            serverUrl: params.serverUrl,
+            recordingId: id,
+            authToken: params.authToken,
+          })
+        ) {
+          const viewUrl = `/r/${id}`;
+          try {
+            await openExternal(
+              `${params.serverUrl.replace(/\/+$/, "")}${viewUrl}`,
+            );
+          } catch (openErr) {
+            console.error("[clips-recorder] openExternal failed:", openErr);
+          }
+          invoke("hide_finalizing").catch((hideErr) =>
+            console.error("[clips-recorder] hide_finalizing failed:", hideErr),
+          );
+          return { recordingId: id, viewUrl };
+        }
         await markBrowserRecordingBackupError(id, error.message).catch(
           () => {},
         );

package/corpus/templates/clips/server/lib/streaming-upload-mode.ts

@@ -0,0 +1,7 @@
+// Temporary kill switch: streaming resumable uploads caused a spike of
+// recording issues. Set CLIPS_DISABLE_STREAMING_UPLOAD=false to re-enable
+// once the root cause is fixed. Defaults to disabled (streaming off).
+export function isStreamingUploadDisabled(): boolean {
+  const flag = process.env.CLIPS_DISABLE_STREAMING_UPLOAD ?? "";
+  return flag.toLowerCase() !== "false";
+}

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

@@ -46,6 +46,7 @@ import {
   setResumableSession,
   type StoredResumableSession,
 } from "../../../../lib/resumable-session.js";
+import { isStreamingUploadDisabled } from "../../../../lib/streaming-upload-mode.js";
 import {
   shouldRejectVideoUploadWithoutStorage,
   STORAGE_SETUP_REQUIRED_REASON,
@@ -174,6 +175,11 @@ export default defineEventHandler(async (event: H3Event) => {
 
     // Resumable streaming path — forward chunks directly to the provider.
     const resumableSession = await getResumableSession(recordingId);
+    if (resumableSession && isStreamingUploadDisabled()) {
+      console.warn(
+        `[chunk] streaming uploads are disabled, but preserving existing resumable session for in-flight recording: ${recordingId}`,
+      );
+    }
     if (resumableSession) {
       return handleResumableChunk(
         event,
@@ -574,6 +580,13 @@ async function handleResumableChunk(
   }
 
   if (isFinal && bytes.byteLength === 0) {
+    if (session.bytesUploaded <= 0) {
+      setResponseStatus(event, 400);
+      return {
+        ok: false,
+        error: "Cannot finalize an empty resumable upload",
+      };
+    }
     // 0-byte sentinel from the recorder after stop(). All data chunks have
     // already been PUT to the provider; send Content-Range: bytes */<total>
     // to close the session before handing off to finalize-recording.
@@ -582,7 +595,7 @@ async function handleResumableChunk(
       `bytes */${session.bytesUploaded}`,
       new Uint8Array(0),
     );
-    if (!closeRes.ok) {
+    if (!closeRes.ok || closeRes.status === 308) {
       console.error(
         `[resumable-chunk-${recordingId}] session close failed (${closeRes.status})`,
       );

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

@@ -59,7 +59,10 @@ export default defineEventHandler(async (event: H3Event) => {
       recording: {
         id: recording.id,
         status: recording.status,
-        videoUrl: resolvePlayerVideoUrl(recording, { appPath }),
+        videoUrl: resolvePlayerVideoUrl(recording, {
+          appPath,
+          proxyRemoteMedia: true,
+        }),
         durationMs: recording.durationMs,
         width: recording.width,
         height: recording.height,

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

@@ -86,6 +86,8 @@ const PROXIED_HEADER_NAMES = [
 const PROVIDER_MEDIA_FETCH_TIMEOUT_MS = 30_000;
 const PROTECTED_MEDIA_ACCESS_TTL_SECONDS = 6 * 60 * 60;
 const PROTECTED_MEDIA_COOKIE_PREFIX = "clips_media_";
+const COMPRESSED_BUILDER_MEDIA_MISS_TTL_MS = 5_000;
+const compressedBuilderMediaMisses = new Map<string, number>();
 
 function appPath(path: string): string {
   if (!path.startsWith("/")) return path;
@@ -145,6 +147,82 @@ function isRecursiveVideoRouteUrl(value: string, recordingId: string): boolean {
   }
 }
 
+function compressedBuilderMediaUrl(sourceUrl: string): string | null {
+  try {
+    const url = new URL(sourceUrl);
+    if (!/^cdn(?:-qa)?\.builder\.io$/i.test(url.hostname)) return null;
+    if (url.searchParams.get("optimized") === "true") return null;
+
+    let objectPath: string | null = null;
+    if (url.pathname.startsWith("/o/")) {
+      objectPath = decodeURIComponent(url.pathname.slice("/o/".length));
+    } else if (url.pathname.startsWith("/api/v1/file/")) {
+      objectPath = decodeURIComponent(
+        url.pathname.slice("/api/v1/file/".length),
+      );
+    }
+    if (!objectPath || !objectPath.startsWith("assets/")) return null;
+    if (objectPath.endsWith("/compressed")) return null;
+
+    const parts = objectPath.split("/");
+    const assetId = parts[parts.length - 1];
+    const apiKey = url.searchParams.get("apiKey") || parts[1];
+    if (!assetId || !apiKey) return null;
+
+    const compressedPath = `${objectPath}/compressed`;
+    const compressedUrl = new URL(
+      `/o/${encodeURIComponent(compressedPath)}`,
+      url.origin,
+    );
+    compressedUrl.searchParams.set("apiKey", apiKey);
+    compressedUrl.searchParams.set(
+      "token",
+      url.searchParams.get("token") || assetId,
+    );
+    compressedUrl.searchParams.set("alt", "media");
+    compressedUrl.searchParams.set("optimized", "true");
+    return compressedUrl.toString();
+  } catch {
+    return null;
+  }
+}
+
+function shouldSkipCompressedBuilderMediaProbe(
+  compressedSourceUrl: string,
+): boolean {
+  const expiresAt = compressedBuilderMediaMisses.get(compressedSourceUrl);
+  if (!expiresAt) return false;
+  if (expiresAt <= Date.now()) {
+    compressedBuilderMediaMisses.delete(compressedSourceUrl);
+    return false;
+  }
+  return true;
+}
+
+function rememberCompressedBuilderMediaMiss(compressedSourceUrl: string): void {
+  if (compressedBuilderMediaMisses.size > 1_000) {
+    for (const [url, expiresAt] of compressedBuilderMediaMisses) {
+      if (expiresAt <= Date.now()) compressedBuilderMediaMisses.delete(url);
+    }
+  }
+  compressedBuilderMediaMisses.set(
+    compressedSourceUrl,
+    Date.now() + COMPRESSED_BUILDER_MEDIA_MISS_TTL_MS,
+  );
+}
+
+function shouldFallbackToOriginalMedia(
+  upstream: Response | { error: string; status: number },
+): boolean {
+  return [403, 404, 416].includes(upstream.status);
+}
+
+function shouldRememberCompressedBuilderMediaMiss(
+  upstream: Response | { error: string; status: number },
+): boolean {
+  return [403, 404].includes(upstream.status);
+}
+
 async function fetchProviderMedia(
   sourceUrl: string,
   rangeHeader: string | undefined,
@@ -434,7 +512,24 @@ export default defineEventHandler(async (event: H3Event) => {
 
         let upstream: Response | { error: string; status: number };
         try {
-          upstream = await fetchProviderMedia(sourceUrl, rangeHeader);
+          const compressedSourceUrl = compressedBuilderMediaUrl(sourceUrl);
+          if (
+            compressedSourceUrl &&
+            !shouldSkipCompressedBuilderMediaProbe(compressedSourceUrl)
+          ) {
+            upstream = await fetchProviderMedia(
+              compressedSourceUrl,
+              rangeHeader,
+            );
+            if (shouldRememberCompressedBuilderMediaMiss(upstream)) {
+              rememberCompressedBuilderMediaMiss(compressedSourceUrl);
+            }
+            if (shouldFallbackToOriginalMedia(upstream)) {
+              upstream = await fetchProviderMedia(sourceUrl, rangeHeader);
+            }
+          } else {
+            upstream = await fetchProviderMedia(sourceUrl, rangeHeader);
+          }
         } catch (err) {
           setResponseStatus(event, statusCodeForProviderFetchError(err));
           return { error: messageForProviderFetchError(err) };