@agent-native/core 0.173.1 → 0.173.2-nightly-20260825163448

package/corpus/README.md

@@ -31,4 +31,4 @@ rg -n "defineAction|useActionQuery" node_modules/@agent-native/core/corpus
 
 ## Generated Counts
 
-- template files: 8609
+- template files: 8611

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

@@ -198,6 +198,10 @@ interface PendingNativeUpload {
 
 type PendingDesktopUpload = PendingNativeUpload | PendingBrowserRecordingUpload;
 
+type NativeUploadProgress = {
+  message?: string;
+};
+
 type PopoverView =
   | "recorder"
   | "memory"
@@ -1137,6 +1141,26 @@ export function App({
   const [retryingUploadStatus, setRetryingUploadStatus] = useState<
     string | null
   >(null);
+  const retryUploadAbortRef = useRef<AbortController | null>(null);
+  const retryingUploadKindRef = useRef<PendingDesktopUpload["kind"] | null>(
+    null,
+  );
+  useEffect(() => {
+    if (!retryingUploadId) return;
+    let disposed = false;
+    let unlisten: (() => void) | null = null;
+    listen<NativeUploadProgress>("clips:native-upload-progress", (event) => {
+      const message = event.payload?.message?.trim();
+      if (message) setRetryingUploadStatus(message);
+    }).then((cleanup) => {
+      if (disposed) cleanup();
+      else unlisten = cleanup;
+    });
+    return () => {
+      disposed = true;
+      unlisten?.();
+    };
+  }, [retryingUploadId]);
   const [exportingUploadId, setExportingUploadId] = useState<string | null>(
     null,
   );
@@ -3107,6 +3131,9 @@ export function App({
     const targetServerUrl = serverUrlForPendingUpload(upload, serverUrl);
     setRecError(null);
     setRetryingUploadId(upload.recordingId);
+    const abortController = new AbortController();
+    retryUploadAbortRef.current = abortController;
+    retryingUploadKindRef.current = upload.kind;
     try {
       const authToken = loadDesktopAuthToken(targetServerUrl);
       if (upload.kind === "native") {
@@ -3132,13 +3159,16 @@ export function App({
           recordingId: upload.recordingId,
           serverUrl: targetServerUrl,
           authToken,
+          signal: abortController.signal,
           onRecoveryDecision: ({ action, progress }) => {
             setRetryingUploadStatus(
               action === "resume"
                 ? `Resuming · ${Math.round(progress * 100)}% already uploaded`
-                : action === "restart"
-                  ? "Restarting upload"
-                  : "Finishing upload",
+                : action === "wait"
+                  ? "Waiting for prior retry"
+                  : action === "restart"
+                    ? "Restarting upload"
+                    : "Finishing upload",
             );
           },
         });
@@ -3152,6 +3182,14 @@ export function App({
       emit("clips:popover-visible", false).catch(() => {});
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
+      if (
+        abortController.signal.aborted ||
+        (err instanceof DOMException && err.name === "AbortError") ||
+        message === "native recording upload retry cancelled"
+      ) {
+        await loadPendingUploads();
+        return;
+      }
       console.error("[clips-tray] retry saved upload failed:", err);
       setRecError(
         isStorageSetupFailureMessage(message)
@@ -3160,11 +3198,28 @@ export function App({
       );
       await loadPendingUploads();
     } finally {
+      if (retryUploadAbortRef.current === abortController) {
+        retryUploadAbortRef.current = null;
+        retryingUploadKindRef.current = null;
+      }
       setRetryingUploadId(null);
       setRetryingUploadStatus(null);
     }
   }
 
+  function cancelPendingUploadRetry(upload: PendingDesktopUpload) {
+    if (retryingUploadId !== upload.recordingId) return;
+    retryUploadAbortRef.current?.abort();
+    if (retryingUploadKindRef.current === "native") {
+      invoke("native_fullscreen_recording_cancel_retry", {
+        recordingId: upload.recordingId,
+      }).catch((err) => {
+        console.error("[clips-tray] cancel saved upload retry failed:", err);
+      });
+    }
+    setRetryingUploadStatus("Cancelling retry");
+  }
+
   async function exportPendingUpload(upload: PendingDesktopUpload) {
     if (retryingUploadId || exportingUploadId || dismissingUploadId) return;
     setRecError(null);
@@ -3873,6 +3928,7 @@ export function App({
           dismissingUploadId={dismissingUploadId}
           onExport={exportPendingUpload}
           onRetry={retryPendingUpload}
+          onCancelRetry={cancelPendingUploadRetry}
           onDismiss={dismissPendingUpload}
           onOpenFolder={openPendingUploadFolder}
           onConnectStorage={(upload) => openVideoStorageSetup(upload.serverUrl)}
@@ -4637,6 +4693,7 @@ function PendingUploadBanner({
   dismissingUploadId,
   onExport,
   onRetry,
+  onCancelRetry,
   onDismiss,
   onOpenFolder,
   onConnectStorage,
@@ -4648,6 +4705,7 @@ function PendingUploadBanner({
   dismissingUploadId: string | null;
   onExport: (upload: PendingDesktopUpload) => void;
   onRetry: (upload: PendingDesktopUpload) => void;
+  onCancelRetry: (upload: PendingDesktopUpload) => void;
   onDismiss: (upload: PendingDesktopUpload) => void;
   onOpenFolder: (upload: PendingDesktopUpload) => void;
   onConnectStorage: (upload: PendingDesktopUpload) => void;
@@ -4656,6 +4714,8 @@ function PendingUploadBanner({
   if (!latest) return null;
 
   const retrying = retryingUploadId === latest.recordingId;
+  const retryCancelling =
+    retrying && retryingUploadStatus === "Cancelling retry";
   const storageSetupFailure = isStorageSetupFailureMessage(latest.lastError);
 
   const canOpenFolder = latest.kind === "native" && !!latest.folderPath;
@@ -4762,12 +4822,22 @@ function PendingUploadBanner({
             <button
               type="button"
               className={`pending-upload-retry${retrying ? " pending-upload-retry-spinning" : ""}`}
-              disabled={actionsDisabled}
-              onClick={() => onRetry(latest)}
+              disabled={retrying ? retryCancelling : actionsDisabled}
+              onClick={() =>
+                retrying ? onCancelRetry(latest) : onRetry(latest)
+              }
               aria-busy={retrying}
             >
-              <IconRefresh size={14} stroke={2} />
-              {retrying ? (retryingUploadStatus ?? "Retrying") : "Retry"}
+              {retrying ? (
+                <IconX size={14} stroke={2} />
+              ) : (
+                <IconRefresh size={14} stroke={2} />
+              )}
+              {retryCancelling
+                ? "Cancelling retry"
+                : retrying
+                  ? "Cancel retry"
+                  : "Retry"}
             </button>
           </>
         )}

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

@@ -104,6 +104,7 @@ import {
   planStreamingRecovery,
   retryAttemptIdAfterRestartSignal,
   retryAttemptIdAfterResumeResponse,
+  retryConflictDelay,
   type UploadResumeResponse,
 } from "./upload-recovery";
 import {
@@ -1061,6 +1062,7 @@ async function postBackupChunk(
   url: string,
   blob: Blob,
   authToken?: string,
+  signal?: AbortSignal,
 ): Promise<FinalizeReceipt | null> {
   const res = await fetch(url, {
     method: "POST",
@@ -1070,6 +1072,7 @@ async function postBackupChunk(
     ),
     credentials: "include",
     body: blob,
+    signal,
   });
   const body = await res.text().catch(() => "");
   if (!res.ok) {
@@ -1103,6 +1106,7 @@ async function resetBrowserRecordingBackupUpload(
   authToken?: string,
   attemptId?: string,
   uploadGenerationId?: string,
+  signal?: AbortSignal,
 ): Promise<{ uploadMode: UploadMode; uploadGenerationId?: string }> {
   const res = await fetch(
     `${meta.serverUrl.replace(/\/+$/, "")}/api/uploads/${meta.recordingId}/reset-chunks`,
@@ -1120,6 +1124,7 @@ async function resetBrowserRecordingBackupUpload(
         ...(attemptId ? { attemptId } : {}),
         ...(uploadGenerationId ? { uploadGenerationId } : {}),
       }),
+      signal,
     },
   );
   if (!res.ok) {
@@ -1147,32 +1152,60 @@ async function getBrowserRecordingUploadResume(
   meta: BrowserRecordingBackupMeta,
   attemptId: string,
   authToken?: string,
+  onWaiting?: (delayMs: number) => void,
+  signal?: AbortSignal,
 ): Promise<UploadResumeResponse> {
   const resumeUrl = new URL(
     `${meta.serverUrl.replace(/\/+$/, "")}/api/uploads/${meta.recordingId}/resume`,
   );
   resumeUrl.searchParams.set("attemptId", attemptId);
-  const res = await fetch(resumeUrl, {
-    method: "GET",
-    headers: buildRetryHeaders("application/json", authToken),
-    credentials: "include",
-  });
-  const body = await res.text().catch(() => "");
-  if (!res.ok) {
-    throw new Error(
-      `Upload resume check failed (${res.status}): ${body.slice(0, 200)}`,
-    );
-  }
-  let parsed: UploadResumeResponse;
-  try {
-    parsed = JSON.parse(body) as UploadResumeResponse;
-  } catch {
-    throw new Error("Upload resume check returned an unreadable response");
-  }
-  if (parsed.resumable && parsed.attemptId !== attemptId) {
-    throw new Error("Upload resume check returned a mismatched retry token");
+  const deadline = Date.now() + 5 * 60_000;
+  for (;;) {
+    const res = await fetch(resumeUrl, {
+      method: "GET",
+      headers: buildRetryHeaders("application/json", authToken),
+      credentials: "include",
+      signal,
+    });
+    let body: string;
+    try {
+      body = await res.text();
+    } catch {
+      throw new Error("Upload resume check response could not be read");
+    }
+    let parsed: UploadResumeResponse;
+    try {
+      parsed = JSON.parse(body) as UploadResumeResponse;
+    } catch {
+      throw new Error("Upload resume check returned an unreadable response");
+    }
+    if (!res.ok) {
+      const delayMs = retryConflictDelay(parsed);
+      if (delayMs !== null && Date.now() + delayMs <= deadline) {
+        onWaiting?.(delayMs);
+        await abortableWait(delayMs, signal);
+        continue;
+      }
+      if (!parsed.resumable && parsed.reason === "retry_already_active") {
+        throw new Error(
+          "Another upload retry is still active. Wait a moment and try again.",
+        );
+      }
+      if (
+        !parsed.resumable &&
+        parsed.reason === "retry_claim_liveness_unavailable"
+      ) {
+        throw new Error(
+          "Clips could not verify whether another retry is active. Your local clip is safe; try again.",
+        );
+      }
+      throw new Error(`Upload resume check failed (${res.status})`);
+    }
+    if (parsed.resumable && parsed.attemptId !== attemptId) {
+      throw new Error("Upload resume check returned a mismatched retry token");
+    }
+    return parsed;
   }
-  return parsed;
 }
 
 async function replayBrowserBackupToResumableSession(
@@ -1185,6 +1218,7 @@ async function replayBrowserBackupToResumableSession(
     bytesReceived: 0,
     nextChunkIndex: 0,
   },
+  signal?: AbortSignal,
 ): Promise<FinalizeReceipt | null> {
   // The backup is stored in raw MediaRecorder blobs, which have arbitrary
   // boundaries. A resumable provider needs every non-final request aligned,
@@ -1217,6 +1251,7 @@ async function replayBrowserBackupToResumableSession(
       }),
       body,
       authToken,
+      signal,
     );
   }
 
@@ -1243,6 +1278,7 @@ async function replayBrowserBackupToResumableSession(
     }),
     finalBody,
     authToken,
+    signal,
   );
 }
 
@@ -1250,8 +1286,9 @@ export async function retryBrowserRecordingBackup(input: {
   recordingId: string;
   serverUrl?: string;
   authToken?: string;
+  signal?: AbortSignal;
   onRecoveryDecision?: (decision: {
-    action: "resume" | "restart" | "reconcile";
+    action: "wait" | "resume" | "restart" | "reconcile";
     progress: number;
   }) => void;
 }): Promise<{ recordingId: string; viewUrl: string }> {
@@ -1284,6 +1321,8 @@ export async function retryBrowserRecordingBackup(input: {
       meta,
       activeAttemptId,
       input.authToken,
+      () => input.onRecoveryDecision?.({ action: "wait", progress: 0 }),
+      input.signal,
     );
     const recoveryPlan = planStreamingRecovery({
       response: resumeResponse,
@@ -1294,7 +1333,7 @@ export async function retryBrowserRecordingBackup(input: {
       activeAttemptId,
       resumeResponse,
     );
-    activeUploadGenerationId = resumeResponse.resumable
+    activeUploadGenerationId = activeAttemptId
       ? resumeResponse.uploadGenerationId
       : undefined;
     if (recoveryPlan.action === "reconcile") {
@@ -1343,6 +1382,7 @@ export async function retryBrowserRecordingBackup(input: {
         input.authToken,
         activeAttemptId,
         activeUploadGenerationId,
+        input.signal,
       );
       uploadMode = reset.uploadMode;
       activeUploadGenerationId = reset.uploadGenerationId;
@@ -1358,6 +1398,7 @@ export async function retryBrowserRecordingBackup(input: {
           activeAttemptId,
           activeUploadGenerationId,
           resumeFrom,
+          input.signal,
         );
       } catch (err) {
         if (err instanceof UploadRestartRequiredError) {
@@ -1365,9 +1406,6 @@ export async function retryBrowserRecordingBackup(input: {
             activeAttemptId,
             err.recoveryEnabled,
           );
-          if (err.recoveryEnabled === false) {
-            activeUploadGenerationId = undefined;
-          }
           input.onRecoveryDecision?.({ action: "restart", progress: 0 });
           console.info("[clips-recorder] restarting expired upload session", {
             recordingId: meta.recordingId,
@@ -1378,6 +1416,7 @@ export async function retryBrowserRecordingBackup(input: {
             input.authToken,
             activeAttemptId,
             activeUploadGenerationId,
+            input.signal,
           );
           uploadMode = reset.uploadMode;
           activeUploadGenerationId = reset.uploadGenerationId;
@@ -1388,6 +1427,8 @@ export async function retryBrowserRecordingBackup(input: {
               input.authToken,
               activeAttemptId,
               activeUploadGenerationId,
+              undefined,
+              input.signal,
             );
           }
         } else if (
@@ -1439,6 +1480,7 @@ export async function retryBrowserRecordingBackup(input: {
         }),
         chunk.blob,
         input.authToken,
+        input.signal,
       );
     }
 
@@ -1466,6 +1508,7 @@ export async function retryBrowserRecordingBackup(input: {
         finalChunkUrl,
         new Blob([], { type: meta.mimeType }),
         input.authToken,
+        input.signal,
       );
       const receiptStatus = verifyFinalizeReceipt(receipt, meta);
       if (receiptStatus === "processing") {
@@ -1498,6 +1541,12 @@ export async function retryBrowserRecordingBackup(input: {
     await deleteBrowserRecordingBackup(meta.recordingId);
     return { recordingId: meta.recordingId, viewUrl: `/r/${meta.recordingId}` };
   } catch (err) {
+    if (
+      input.signal?.aborted ||
+      (err instanceof DOMException && err.name === "AbortError")
+    ) {
+      throw err;
+    }
     const message = err instanceof Error ? err.message : String(err);
     if (
       await recoverAcceptedRecordingAfterFinalizeError({
@@ -1638,6 +1687,23 @@ function wait(ms: number): Promise<void> {
   return new Promise((resolve) => window.setTimeout(resolve, ms));
 }
 
+function abortableWait(ms: number, signal?: AbortSignal): Promise<void> {
+  if (!signal) return wait(ms);
+  if (signal.aborted)
+    return Promise.reject(new DOMException("Aborted", "AbortError"));
+  return new Promise((resolve, reject) => {
+    const timer = window.setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      window.clearTimeout(timer);
+      reject(new DOMException("Aborted", "AbortError"));
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
 interface NativeFullscreenUploadResult {
   recordingId: string;
   durationMs: number;

package/corpus/templates/clips/desktop/src/lib/upload-recovery.ts

@@ -17,8 +17,25 @@ export type UploadResumeResponse =
       videoUrl?: string | null;
       reason?: string;
       attemptId?: string;
+      uploadGenerationId?: string;
+      retryAfterMs?: number;
     };
 
+export function retryConflictDelay(
+  response: UploadResumeResponse,
+): number | null {
+  if (
+    response.resumable ||
+    response.recoveryEnabled !== true ||
+    response.reason !== "retry_already_active" ||
+    !Number.isSafeInteger(response.retryAfterMs) ||
+    (response.retryAfterMs ?? 0) <= 0
+  ) {
+    return null;
+  }
+  return Math.min(Math.max(response.retryAfterMs!, 250), 30_000);
+}
+
 export type StreamingRecoveryPlan =
   | {
       action: "resume";
@@ -38,15 +55,16 @@ export interface StreamingReplayRequest {
 
 export function retryAttemptIdAfterRestartSignal(
   attemptId: string | undefined,
-  recoveryEnabled: unknown,
+  _recoveryEnabled: unknown,
 ): string | undefined {
-  return recoveryEnabled === false ? undefined : attemptId;
+  return attemptId;
 }
 
 export function retryAttemptIdAfterResumeResponse(
   attemptId: string | undefined,
   response: UploadResumeResponse,
 ): string | undefined {
+  if (response.recoveryEnabled === false) return response.attemptId;
   return response.resumable && response.attemptId === attemptId
     ? attemptId
     : undefined;

package/corpus/templates/clips/desktop/src-tauri/Cargo.toml

@@ -67,7 +67,13 @@ reqwest = { version = "0.12", default-features = false, features = [
   "rustls-tls",
   "json",
 ] }
-tokio = { version = "1", features = ["rt", "rt-multi-thread", "time", "sync"] }
+tokio = { version = "1", features = [
+  "rt",
+  "rt-multi-thread",
+  "time",
+  "sync",
+  "macros",
+] }
 chrono = { version = "0.4", features = ["serde"] }
 # Verify the integrity of the Whisper model we download from HuggingFace.
 sha2 = "0.10"

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

@@ -161,6 +161,7 @@ pub fn run() {
             native_screen::native_fullscreen_pending_uploads,
             native_screen::native_fullscreen_recover_orphaned_uploads,
             native_screen::native_fullscreen_recording_retry_upload,
+            native_screen::native_fullscreen_recording_cancel_retry,
             native_screen::native_fullscreen_recording_mark_upload_error,
             native_screen::native_fullscreen_recording_clear_upload,
             native_screen::native_fullscreen_recording_dismiss_upload,