@agent-native/core 0.80.11 → 0.81.1

package/corpus/templates/clips/chrome-extension/src/content-script.ts

@@ -195,21 +195,33 @@
 
   window.addEventListener("resize", () => applyBubbleGeom());
 
-  function requestState(): void {
+  function readCurrentParts(
+    callback: (parts: OverlayPart[] | null) => void,
+  ): void {
     try {
       chrome.runtime.sendMessage(
         { type: "CLIPS_CONTENT_HELLO" },
         (response) => {
-          if (chrome.runtime.lastError) return;
+          if (chrome.runtime.lastError) {
+            callback(null);
+            return;
+          }
           const parts = (response as { parts?: unknown } | undefined)?.parts;
-          reconcile(Array.isArray(parts) ? (parts as OverlayPart[]) : []);
+          callback(Array.isArray(parts) ? (parts as OverlayPart[]) : []);
         },
       );
     } catch {
-      /* worker asleep; will resync on next message */
+      callback(null);
     }
   }
 
+  function requestState(): void {
+    readCurrentParts((parts) => {
+      if (parts) reconcile(parts);
+      /* worker asleep; will resync on next message */
+    });
+  }
+
   // Only wake the service worker (via requestState) when a recording is actually
   // active. When idle this script does nothing but keep its message listener
   // registered, so a recording that starts later still reaches this tab via the
@@ -396,14 +408,23 @@
   function mountDeferredCountdown(): void {
     countdownDeferred = false;
     clearTimeout(countdownFallbackTimer);
-    hideConnecting();
-    setBubbleHidden(false);
-    const container = document.getElementById(
-      CONTAINER_ID,
-    ) as HTMLDivElement | null;
-    if (container && !document.getElementById(partFrameId("countdown"))) {
-      mountPart(container, "countdown");
-    }
+    readCurrentParts((parts) => {
+      if (!parts?.includes("countdown")) {
+        hideConnecting();
+        setBubbleHidden(false);
+        if (parts) reconcile(parts);
+        return;
+      }
+
+      hideConnecting();
+      setBubbleHidden(false);
+      const container = document.getElementById(
+        CONTAINER_ID,
+      ) as HTMLDivElement | null;
+      if (container && !document.getElementById(partFrameId("countdown"))) {
+        mountPart(container, "countdown");
+      }
+    });
   }
 
   function reconcile(parts: OverlayPart[]): void {
@@ -493,6 +514,11 @@
       if (countdownDeferred) mountDeferredCountdown();
       return;
     }
+    if (data.kind === "countdown-finished") {
+      document.getElementById(partFrameId("countdown"))?.remove();
+      hideConnecting();
+      return;
+    }
     if (data.kind === "bubble-drag-start") {
       startBubbleDrag();
       return;

package/corpus/templates/clips/chrome-extension/src/finalize-recovery.ts

@@ -0,0 +1,224 @@
+type FetchLike = (
+  input: RequestInfo | URL,
+  init?: RequestInit,
+) => Promise<Response>;
+
+export type RecoveredReadyRecording = {
+  ok: true;
+  finalized: true;
+  recoveredAfterFinalizeError: true;
+  id: string;
+  recordingId: string;
+  status: "ready";
+  videoUrl: string;
+  durationMs?: number;
+  width?: number;
+  height?: number;
+  hasAudio?: boolean;
+  hasCamera?: boolean;
+};
+
+type ProbeResult =
+  | { ready: true; result: RecoveredReadyRecording }
+  | { ready: false; terminal: boolean; status?: string };
+
+const DEFAULT_READY_RECOVERY_TIMEOUT_MS = 90_000;
+const DEFAULT_READY_RECOVERY_INTERVAL_MS = 3_000;
+const DEFAULT_READY_RECOVERY_FETCH_TIMEOUT_MS = 2_000;
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export function publicRecordingStatusUrl(
+  uploadUrl: string,
+  recordingId: string,
+): string {
+  const url = new URL(uploadUrl);
+  const match = url.pathname.match(/^(.*)\/api\/uploads\/[^/]+\/chunk$/);
+  const basePath = match?.[1] ?? "";
+  url.pathname = `${basePath}/api/public-recording`;
+  url.search = "";
+  url.searchParams.set("id", recordingId);
+  return url.toString();
+}
+
+export function authenticatedRecordingStatusUrl(
+  uploadUrl: string,
+  recordingId: string,
+): string {
+  const url = new URL(uploadUrl);
+  const match = url.pathname.match(/^(.*)\/api\/uploads\/[^/]+\/chunk$/);
+  const basePath = match?.[1] ?? "";
+  url.pathname = `${basePath}/api/uploads/${encodeURIComponent(recordingId)}/status`;
+  url.search = "";
+  return url.toString();
+}
+
+function optionalNumber(value: unknown): number | undefined {
+  return typeof value === "number" && Number.isFinite(value)
+    ? value
+    : undefined;
+}
+
+function optionalBoolean(value: unknown): boolean | undefined {
+  return typeof value === "boolean" ? value : undefined;
+}
+
+export function readyRecordingFromPublicPayload(
+  payload: unknown,
+  fallbackRecordingId: string,
+): ProbeResult {
+  const root =
+    payload && typeof payload === "object"
+      ? (payload as Record<string, unknown>)
+      : null;
+  const recording =
+    root?.recording && typeof root.recording === "object"
+      ? (root.recording as Record<string, unknown>)
+      : null;
+  const status =
+    typeof recording?.status === "string" ? recording.status : undefined;
+
+  if (!recording) return { ready: false, terminal: false };
+  if (status === "failed") return { ready: false, terminal: true, status };
+
+  const videoUrl =
+    typeof recording.videoUrl === "string" ? recording.videoUrl : "";
+  if (status !== "ready" || !videoUrl) {
+    return { ready: false, terminal: false, status };
+  }
+
+  const id =
+    typeof recording.id === "string" && recording.id
+      ? recording.id
+      : fallbackRecordingId;
+  return {
+    ready: true,
+    result: {
+      ok: true,
+      finalized: true,
+      recoveredAfterFinalizeError: true,
+      id,
+      recordingId: id,
+      status: "ready",
+      videoUrl,
+      durationMs: optionalNumber(recording.durationMs),
+      width: optionalNumber(recording.width),
+      height: optionalNumber(recording.height),
+      hasAudio: optionalBoolean(recording.hasAudio),
+      hasCamera: optionalBoolean(recording.hasCamera),
+    },
+  };
+}
+
+async function fetchWithTimeout(
+  fetchImpl: FetchLike,
+  url: string,
+  init: RequestInit,
+  timeoutMs: number,
+): Promise<Response> {
+  if (timeoutMs <= 0 || typeof AbortController === "undefined") {
+    return fetchImpl(url, init);
+  }
+
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    return await fetchImpl(url, { ...init, signal: controller.signal });
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+export async function waitForReadyRecordingAfterFinalizeError(args: {
+  uploadUrl: string;
+  recordingId: string;
+  authToken?: string | null;
+  fetchImpl?: FetchLike;
+  sleepImpl?: (ms: number) => Promise<void>;
+  timeoutMs?: number;
+  intervalMs?: number;
+  fetchTimeoutMs?: number;
+}): Promise<RecoveredReadyRecording | null> {
+  const fetchImpl = args.fetchImpl ?? fetch;
+  const sleepImpl = args.sleepImpl ?? sleep;
+  const timeoutMs = Math.max(
+    1,
+    args.timeoutMs ?? DEFAULT_READY_RECOVERY_TIMEOUT_MS,
+  );
+  const intervalMs = Math.max(
+    1,
+    args.intervalMs ?? DEFAULT_READY_RECOVERY_INTERVAL_MS,
+  );
+  const attempts = Math.max(1, Math.ceil(timeoutMs / intervalMs));
+  let url: string;
+  let authenticatedUrl: string | null = null;
+  try {
+    url = publicRecordingStatusUrl(args.uploadUrl, args.recordingId);
+    authenticatedUrl = args.authToken
+      ? authenticatedRecordingStatusUrl(args.uploadUrl, args.recordingId)
+      : null;
+  } catch {
+    return null;
+  }
+
+  for (let attempt = 0; attempt < attempts; attempt += 1) {
+    const urls = authenticatedUrl
+      ? [
+          { url: authenticatedUrl, authenticated: true },
+          { url, authenticated: false },
+        ]
+      : [{ url, authenticated: false }];
+
+    for (const endpoint of urls) {
+      const headers: Record<string, string> = {
+        Accept: "application/json",
+        "X-Agent-Native-Frontend": "1",
+      };
+      if (endpoint.authenticated && args.authToken) {
+        headers.Authorization = `Bearer ${args.authToken}`;
+      }
+
+      try {
+        const response = await fetchWithTimeout(
+          fetchImpl,
+          endpoint.url,
+          {
+            method: "GET",
+            headers,
+            credentials: "include",
+            cache: "no-store",
+          },
+          args.fetchTimeoutMs ?? DEFAULT_READY_RECOVERY_FETCH_TIMEOUT_MS,
+        );
+
+        if (response.ok) {
+          const payload = await response.json().catch(() => null);
+          const probe = readyRecordingFromPublicPayload(
+            payload,
+            args.recordingId,
+          );
+          if (probe.ready) return probe.result;
+          if (probe.terminal) return null;
+          break;
+        }
+
+        if (
+          response.status >= 400 &&
+          response.status < 500 &&
+          !endpoint.authenticated &&
+          !authenticatedUrl
+        ) {
+          return null;
+        }
+      } catch {
+        // Try the public endpoint fallback below, then keep polling.
+      }
+    }
+
+    if (attempt < attempts - 1) await sleepImpl(intervalMs);
+  }
+
+  return null;
+}

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

@@ -20,6 +20,7 @@ import { scheduleReadyChime } from "@shared/recording-audio";
 import { chunkUploadUrl, pickMimeType } from "@shared/recording-core";
 import { MAX_UPLOAD_BYTES } from "@shared/upload-limits";
 
+import { waitForReadyRecordingAfterFinalizeError } from "./finalize-recovery";
 import { captureExtensionError, initExtensionSentry } from "./sentry";
 
 initExtensionSentry("offscreen");
@@ -33,6 +34,17 @@ function isStorageSetupFailureMessage(message: string | null | undefined) {
   return STORAGE_SETUP_FAILURE_RE.test(message ?? "");
 }
 
+function isFinalUploadRecoveryCandidate(error: Error): boolean {
+  const tagged = error as {
+    finalUpload?: boolean;
+    status?: number;
+    storageSetupRequired?: boolean;
+  };
+  if (!tagged.finalUpload || tagged.storageSetupRequired) return false;
+  if (tagged.status === 413) return false;
+  return !/too large|exceeds.*limit|chunk too large/i.test(error.message);
+}
+
 type CaptureMode = "screen" | "camera";
 
 type AcquireMessage = {
@@ -79,6 +91,8 @@ type UploadResult = {
   recordingId?: string;
   videoUrl?: string;
   status?: string;
+  finalized?: boolean;
+  recoveredAfterFinalizeError?: boolean;
   waitingForStorage?: boolean;
   storageSetupRequired?: boolean;
   error?: string;
@@ -456,8 +470,12 @@ async function uploadChunk(
         : data?.error ||
             `Upload failed (${res.status}): ${text || res.statusText}`,
     );
-    (error as { storageSetupRequired?: boolean }).storageSetupRequired =
-      storageSetupRequired;
+    const uploadError = error as {
+      status?: number;
+      storageSetupRequired?: boolean;
+    };
+    uploadError.status = res.status;
+    uploadError.storageSetupRequired = storageSetupRequired;
     captureExtensionError(error, {
       tags: {
         surface: "offscreen",
@@ -480,6 +498,57 @@ async function uploadChunk(
   return data;
 }
 
+function uploadAbortUrl(uploadUrl: string): string | null {
+  try {
+    const url = new URL(uploadUrl);
+    url.pathname = url.pathname.replace(/\/chunk$/, "/abort");
+    url.search = "";
+    return url.toString();
+  } catch {
+    return null;
+  }
+}
+
+async function abortServerUpload(
+  recording: ActiveRecording,
+  reason: string,
+): Promise<void> {
+  const url = uploadAbortUrl(recording.uploadUrl);
+  if (!url) return;
+  const headers: Record<string, string> = {
+    "Content-Type": "application/json",
+    "X-Agent-Native-Frontend": "1",
+  };
+  if (recording.authToken) {
+    headers.Authorization = `Bearer ${recording.authToken}`;
+  }
+  const controller =
+    typeof AbortController === "undefined" ? null : new AbortController();
+  const timer = controller
+    ? window.setTimeout(() => controller.abort(), 4_000)
+    : undefined;
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers,
+      credentials: "include",
+      body: JSON.stringify({ reason }),
+      signal: controller?.signal,
+    });
+    if (!response.ok) {
+      console.warn(
+        "[clips-offscreen] abort upload returned",
+        response.status,
+        await response.text().catch(() => ""),
+      );
+    }
+  } catch (err) {
+    console.warn("[clips-offscreen] abort upload failed", err);
+  } finally {
+    if (timer) window.clearTimeout(timer);
+  }
+}
+
 // Keep a local copy of every recorded blob so a failed upload can still be
 // saved to disk. Blob references are browser-managed (often disk-backed), so
 // this is far cheaper than holding ArrayBuffers. We stop retaining past the
@@ -930,20 +999,27 @@ async function finalizeStop(recording: ActiveRecording): Promise<void> {
         durationMs,
       );
     }
-    const result = await uploadChunk(
-      recording,
-      new Blob([], { type: recording.mimeType }),
-      recording.chunkIndex,
-      {
-        isFinal: true,
-        total: recording.chunkIndex,
-        durationMs,
-        width: recording.dimensions.width,
-        height: recording.dimensions.height,
-        hasAudio: recording.hasAudio,
-        hasCamera: recording.hasCamera,
-      },
-    );
+    let result: UploadResult;
+    try {
+      result = await uploadChunk(
+        recording,
+        new Blob([], { type: recording.mimeType }),
+        recording.chunkIndex,
+        {
+          isFinal: true,
+          total: recording.chunkIndex,
+          durationMs,
+          width: recording.dimensions.width,
+          height: recording.dimensions.height,
+          hasAudio: recording.hasAudio,
+          hasCamera: recording.hasCamera,
+        },
+      );
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      (error as { finalUpload?: boolean }).finalUpload = true;
+      throw error;
+    }
     cleanup(recording);
     if (activeRecording === recording) activeRecording = null;
     reportStatus(recording.sessionId, "complete", {
@@ -955,6 +1031,30 @@ async function finalizeStop(recording: ActiveRecording): Promise<void> {
     cleanup(recording);
     if (activeRecording === recording) activeRecording = null;
     const error = err instanceof Error ? err : new Error(String(err));
+
+    if (isFinalUploadRecoveryCandidate(error)) {
+      const recovered = await waitForReadyRecordingAfterFinalizeError({
+        uploadUrl: recording.uploadUrl,
+        recordingId: recording.recordingId,
+        authToken: recording.authToken,
+      });
+      if (recovered) {
+        console.warn(
+          "[clips-offscreen] final upload looked failed, but the recording is ready; treating as saved.",
+          {
+            recordingId: recording.recordingId,
+            originalError: error.message,
+          },
+        );
+        reportStatus(recording.sessionId, "complete", {
+          recordingId: recording.recordingId,
+          result: recovered,
+        });
+        recording.resolveStopped(recovered);
+        return;
+      }
+    }
+
     captureExtensionError(error, {
       tags: {
         surface: "offscreen",
@@ -969,6 +1069,9 @@ async function finalizeStop(recording: ActiveRecording): Promise<void> {
     });
     // The upload failed — save the buffered recording to disk so it isn't lost.
     const saved = await saveRecordingToDisk(recording);
+    if (!(error as { storageSetupRequired?: boolean }).storageSetupRequired) {
+      await abortServerUpload(recording, error.message);
+    }
     reportStatus(recording.sessionId, "error", {
       recordingId: recording.recordingId,
       error: error.message,

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

@@ -28,6 +28,21 @@ function postToolbarSize(height: number): void {
   }
 }
 
+function postCountdownFinished(): void {
+  try {
+    window.parent.postMessage(
+      {
+        source: "clips-overlay",
+        kind: "countdown-finished",
+        part: "countdown",
+      },
+      "*",
+    );
+  } catch {
+    /* parent gone */
+  }
+}
+
 type OverlayState = {
   phase: OverlayPhase;
   baseElapsedMs: number;
@@ -244,6 +259,7 @@ function initCountdown(): void {
       if (!doneSent) {
         doneSent = true;
         send("CLIPS_OVERLAY_COUNTDOWN_DONE");
+        postCountdownFinished();
       }
       return;
     }

package/corpus/templates/clips/server/lib/recording-upload-state.ts

@@ -0,0 +1,48 @@
+import { getDbExec, isPostgres } from "@agent-native/core/db";
+
+function escapeLike(value: string): string {
+  return value.replace(/[!%_]/g, (match) => `!${match}`);
+}
+
+function chunkPrefix(recordingId: string): string {
+  return `recording-chunks-${recordingId}-`;
+}
+
+function likePrefix(prefix: string): string {
+  return `${escapeLike(prefix)}%`;
+}
+
+function numberFromRowValue(value: unknown): number {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "bigint") return Number(value);
+  if (typeof value === "string") {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : 0;
+  }
+  return 0;
+}
+
+export async function listRecordingChunkKeys(
+  ownerEmail: string,
+  recordingId: string,
+): Promise<string[]> {
+  const { rows } = await getDbExec().execute({
+    sql: `SELECT key FROM application_state WHERE session_id = ? AND key LIKE ? ESCAPE '!'`,
+    args: [ownerEmail, likePrefix(chunkPrefix(recordingId))],
+  });
+  return rows.map((row) => String(row.key));
+}
+
+export async function sumRecordingChunkBytes(
+  ownerEmail: string,
+  recordingId: string,
+): Promise<number> {
+  const bytesExpression = isPostgres()
+    ? `COALESCE(SUM((value::jsonb ->> 'bytes')::bigint), 0)`
+    : `COALESCE(SUM(json_extract(value, '$.bytes')), 0)`;
+  const { rows } = await getDbExec().execute({
+    sql: `SELECT ${bytesExpression} AS bytes FROM application_state WHERE session_id = ? AND key LIKE ? ESCAPE '!'`,
+    args: [ownerEmail, likePrefix(chunkPrefix(recordingId))],
+  });
+  return numberFromRowValue(rows[0]?.bytes);
+}

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

@@ -45,7 +45,11 @@ export default defineEventHandler(async (event: H3Event) => {
     const db = getDb();
 
     const [existing] = await db
-      .select({ id: schema.recordings.id })
+      .select({
+        id: schema.recordings.id,
+        status: schema.recordings.status,
+        videoUrl: schema.recordings.videoUrl,
+      })
       .from(schema.recordings)
       .where(
         and(
@@ -59,6 +63,10 @@ export default defineEventHandler(async (event: H3Event) => {
       return { error: "Recording not found" };
     }
 
+    if (existing.status === "ready" && existing.videoUrl) {
+      return { ok: true, recordingId, alreadyReady: true, chunksCleared: 0 };
+    }
+
     const cleared = await deleteAppStateByPrefix(
       `recording-chunks-${recordingId}-`,
     );