@agent-native/core 0.92.12 → 0.93.0

package/corpus/templates/clips/desktop/src/components/ReadinessPanel.tsx

@@ -8,7 +8,7 @@ import {
 import { invoke } from "@tauri-apps/api/core";
 import { useState, useCallback, useEffect } from "react";
 
-import { isMacPlatform } from "../lib/platform";
+import { isMacPlatform, isWindowsPlatform } from "../lib/platform";
 
 type CaptureMode = "screen" | "screen-camera" | "camera";
 type MacosPrivacyPane =
@@ -56,7 +56,6 @@ function readinessItems({
       detail: "Needed for screen or window capture.",
       pane: "screen",
       active: mode !== "camera",
-      macosOnly: true,
     },
     {
       label: "Microphone",
@@ -132,6 +131,7 @@ export function ReadinessPanel({
   onOpenPermission: (pane: MacosPrivacyPane) => void;
 }) {
   const mac = isMacPlatform();
+  const canOpenPrivacySettings = mac || isWindowsPlatform();
   const items = readinessItems({
     mode,
     cameraOn,
@@ -215,13 +215,19 @@ export function ReadinessPanel({
                         )}
                       </span>
                     ) : null}
-                    <button
-                      type="button"
-                      className="readiness-open-button"
-                      onClick={() => onOpenPermission(item.pane)}
-                    >
-                      Open
-                    </button>
+                    {canOpenPrivacySettings ? (
+                      <button
+                        type="button"
+                        className="readiness-open-button"
+                        onClick={() => onOpenPermission(item.pane)}
+                      >
+                        Open
+                      </button>
+                    ) : (
+                      <span className="readiness-item-detail">
+                        System prompt
+                      </span>
+                    )}
                   </div>
                 </div>
               );

package/corpus/templates/clips/desktop/src/lib/finalization-guard.ts

@@ -0,0 +1,22 @@
+interface FinalizationGuardOptions<T> {
+  ensureBackupDurable: () => Promise<void>;
+  attemptFinalize: () => Promise<T>;
+  releaseGuard: () => Promise<void> | void;
+}
+
+/**
+ * Keep the desktop's post-stop guard visible until recovery metadata is
+ * durable and the finalize request has settled at least once.
+ */
+export async function finalizeAfterDurableBackup<T>({
+  ensureBackupDurable,
+  attemptFinalize,
+  releaseGuard,
+}: FinalizationGuardOptions<T>): Promise<T> {
+  try {
+    await ensureBackupDurable();
+    return await attemptFinalize();
+  } finally {
+    await releaseGuard();
+  }
+}

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

@@ -1,4 +1,4 @@
-// macOS capture/permission messaging shared between the device pickers and the
+// Capture/permission messaging shared between the device pickers and the
 // recording flow. Centralized so the "is this a hard system block?" heuristic
 // and the user-facing copy stay in sync wherever a getUserMedia call can fail.
 
@@ -6,6 +6,8 @@ export const MACOS_CAPTURE_PERMISSION_MESSAGE =
   "Grant the required macOS permissions below, then try again. If you just changed access, restart Clips before retrying.";
 export const MACOS_SCREEN_PERMISSION_MESSAGE =
   "Grant Screen Recording permission in macOS Settings, then restart Clips and try again.";
+export const DESKTOP_CAPTURE_PERMISSION_MESSAGE =
+  "Allow the requested screen, camera, or microphone access in your desktop permission prompt, then 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 =

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

@@ -55,6 +55,7 @@ import { waitForReadyRecordingAfterFinalizeError } from "../../../shared/finaliz
 import type { LocalRecordingMode } from "../shared/config";
 import { createAudioCue, type AudioCue } from "./audio-cue";
 import { createCameraCompositeStream } from "./camera-composite";
+import { finalizeAfterDurableBackup } from "./finalization-guard";
 import {
   createLocalRecordingFolderName,
   exportBlobChunksToLocalRecordingFile,
@@ -1661,6 +1662,15 @@ function showFinalizingFeedback() {
   );
 }
 
+async function releaseFinalizingFeedback() {
+  await invoke("set_recording_state", { active: false }).catch((err) =>
+    console.error("[clips-recorder] clear recording state failed:", err),
+  );
+  await invoke("hide_finalizing").catch((err) =>
+    console.error("[clips-recorder] hide_finalizing failed:", err),
+  );
+}
+
 async function claimNativeUploadOpen(recordingId: string): Promise<boolean> {
   return invoke<boolean>("native_fullscreen_claim_upload_open", {
     recordingId,
@@ -2203,15 +2213,19 @@ async function startNativeFullscreenRecording(
           },
         );
         uploadPromise.catch(() => {});
+        // The recording row already exists, so open its page as soon as the
+        // native stop command has started. Upload/finalize continues in this
+        // webview while the page polls from `uploading` to `ready`.
+        await openNativeUploadUrl(
+          id,
+          `${params.serverUrl.replace(/\/+$/, "")}${viewUrl}`,
+        );
         try {
           await Promise.race([
             recorderFinalized,
             new Promise<void>((resolve) => window.setTimeout(resolve, 15000)),
           ]);
           unlistenFinalized();
-          await invoke("set_recording_state", { active: false }).catch(
-            () => {},
-          );
 
           const capturedTranscript = await transcriptionCapture
             ?.stop()
@@ -2263,10 +2277,6 @@ async function startNativeFullscreenRecording(
                 authToken: params.authToken,
               })
             ) {
-              await openNativeUploadUrl(
-                id,
-                `${params.serverUrl.replace(/\/+$/, "")}${viewUrl}`,
-              );
               return { recordingId: id, viewUrl };
             }
             await abortRecordingUpload(
@@ -2274,36 +2284,16 @@ async function startNativeFullscreenRecording(
               id,
               err instanceof Error ? err.message : String(err),
             );
-            // Still take the user to the clip status page. If the server
-            // marked the upload failed, that page shows the failure state; if
-            // the abort request could not land, it keeps polling instead of
-            // leaving the user on an empty desktop.
-            try {
-              await openExternal(
-                `${params.serverUrl.replace(
-                  /\/+$/,
-                  "",
-                )}${viewUrl}?saveFailed=1`,
-              );
-            } catch (openErr) {
-              console.error("[clips-recorder] openExternal failed:", openErr);
-            }
             throw err;
           }
 
-          await openNativeUploadUrl(
-            uploadResult.recordingId,
-            `${params.serverUrl.replace(/\/+$/, "")}${viewUrl}`,
-          );
           return {
             recordingId: uploadResult.recordingId,
             viewUrl,
           };
         } finally {
           streamCleanups.forEach((cleanup) => cleanup());
-          invoke("hide_finalizing").catch((err) =>
-            console.error("[clips-recorder] hide_finalizing failed:", err),
-          );
+          await releaseFinalizingFeedback();
         }
       })();
       return stopPromise;
@@ -3223,15 +3213,6 @@ async function startRecordingInner(
     }).catch(() => {});
   }
 
-  async function openFailedRecordingPage() {
-    const viewUrl = `/r/${id}?saveFailed=1`;
-    try {
-      await openExternal(`${params.serverUrl.replace(/\/+$/, "")}${viewUrl}`);
-    } catch (err) {
-      console.error("[clips-recorder] openExternal failed:", err);
-    }
-  }
-
   // 5. Wire toolbar events.
   const toolbarUnlistens = await Promise.all([
     listen("clips:recorder-pause", () => {
@@ -3346,6 +3327,7 @@ async function startRecordingInner(
       // chunk — but NOT the transcript-finalize + thumbnail + upload awaits that
       // follow, which add ~seconds and would overstate the saved duration.
       let stoppedAt = 0;
+      const viewUrl = `/r/${id}`;
       console.log("[clips-recorder] stop requested");
       showFinalizingFeedback();
       if (tickHandle) clearInterval(tickHandle);
@@ -3354,12 +3336,20 @@ async function startRecordingInner(
 
       // Flush the in-flight recorder buffer, then wait for it to fully stop
       // so we get the trailing dataavailable event.
-      await new Promise<void>((resolve) => {
+      const recorderStopped = new Promise<void>((resolve) => {
         if (recorder.state === "inactive") {
+          stoppedAt = Date.now();
           resolve();
           return;
         }
-        recorder.addEventListener("stop", () => resolve(), { once: true });
+        recorder.addEventListener(
+          "stop",
+          () => {
+            stoppedAt = Date.now();
+            resolve();
+          },
+          { once: true },
+        );
         try {
           if (recorder.state === "paused") {
             recorder.resume();
@@ -3380,10 +3370,18 @@ async function startRecordingInner(
           // ignore
         }
       });
+      // `recorder.stop()` has already been requested, so recorded duration is
+      // fixed even if launching the browser takes a moment. Open the existing
+      // recording row now and let its page poll while upload/finalize continues.
+      try {
+        await openExternal(`${params.serverUrl.replace(/\/+$/, "")}${viewUrl}`);
+      } catch (err) {
+        console.error("[clips-recorder] openExternal failed:", err);
+      }
+      await recorderStopped;
       // Recorder has fully stopped and flushed its trailing chunk — this is the
       // true end of recorded content. Everything after (transcript, thumbnail,
       // upload) is post-processing and must not count toward duration.
-      stoppedAt = Date.now();
 
       const thumbnailUploadPromise = captureAndUploadRecordingThumbnail({
         serverUrl: params.serverUrl,
@@ -3497,7 +3495,6 @@ async function startRecordingInner(
       await invoke("hide_recording_chrome").catch((err) =>
         console.error(`[clips-recorder] hide_recording_chrome failed:`, err),
       );
-      await invoke("set_recording_state", { active: false }).catch(() => {});
 
       // Wait for any in-flight chunk uploads to settle before sending the
       // final chunk. Otherwise the server could finalize before the last
@@ -3511,19 +3508,19 @@ async function startRecordingInner(
         await Promise.allSettled(pending);
       }
       inflight.clear();
-      // Ensure the local backup is fully written before we either delete it
-      // (on success) or leave it in place for recovery (on failure).
-      await Promise.allSettled([...backupWrites]);
       if (failed) {
-        console.error("[clips-recorder] chunk upload failed:", failed);
-        await markBrowserRecordingBackupError(id, failed.message).catch(
-          () => {},
-        );
-        await abortRecordingUpload(params.serverUrl, id, failed.message);
-        invoke("hide_finalizing").catch((err) =>
-          console.error("[clips-recorder] hide_finalizing failed:", err),
-        );
-        await openFailedRecordingPage();
+        try {
+          // Keep the guard until the final metadata and every trailing chunk
+          // backup are durable, even though this upload cannot be finalized.
+          await Promise.allSettled([...backupWrites]);
+          console.error("[clips-recorder] chunk upload failed:", failed);
+          await markBrowserRecordingBackupError(id, failed.message).catch(
+            () => {},
+          );
+          await abortRecordingUpload(params.serverUrl, id, failed.message);
+        } finally {
+          await releaseFinalizingFeedback();
+        }
         throw failed;
       }
 
@@ -3553,78 +3550,58 @@ async function startRecordingInner(
         uploadMode,
         anyFailed: !!failed,
       });
-      try {
-        const finalRes = await fetch(finalizeUrl, {
-          method: "POST",
-          headers: { "Content-Type": "application/octet-stream" },
-          credentials: "include",
-          body: finalBody,
-          signal: AbortSignal.timeout(FINALIZE_UPLOAD_TIMEOUT_MS),
-        });
-        const bodyText = await finalRes.text().catch(() => "");
-        console.log(
-          "[clips-recorder] finalize response:",
-          finalRes.status,
-          bodyText.slice(0, 500),
-        );
-        if (!finalRes.ok) {
-          throw new Error(
-            `Finalize failed (${finalRes.status}): ${bodyText.slice(0, 200)}`,
-          );
-        }
-      } 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}`;
+      return finalizeAfterDurableBackup({
+        // Opening the browser must not make the desktop look idle until every
+        // trailing backup write and the final metadata are durable.
+        ensureBackupDurable: async () => {
+          await Promise.allSettled([...backupWrites]);
+        },
+        attemptFinalize: async () => {
           try {
-            await openExternal(
-              `${params.serverUrl.replace(/\/+$/, "")}${viewUrl}`,
+            const finalRes = await fetch(finalizeUrl, {
+              method: "POST",
+              headers: { "Content-Type": "application/octet-stream" },
+              credentials: "include",
+              body: finalBody,
+              signal: AbortSignal.timeout(FINALIZE_UPLOAD_TIMEOUT_MS),
+            });
+            const bodyText = await finalRes.text().catch(() => "");
+            console.log(
+              "[clips-recorder] finalize response:",
+              finalRes.status,
+              bodyText.slice(0, 500),
+            );
+            if (!finalRes.ok) {
+              throw new Error(
+                `Finalize failed (${finalRes.status}): ${bodyText.slice(0, 200)}`,
+              );
+            }
+          } 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,
+              })
+            ) {
+              return { recordingId: id, viewUrl };
+            }
+            await markBrowserRecordingBackupError(id, error.message).catch(
+              () => {},
             );
-          } catch (openErr) {
-            console.error("[clips-recorder] openExternal failed:", openErr);
+            await abortRecordingUpload(params.serverUrl, id, error.message);
+            throw error;
           }
-          invoke("hide_finalizing").catch((hideErr) =>
-            console.error("[clips-recorder] hide_finalizing failed:", hideErr),
-          );
+          await deleteBrowserRecordingBackup(id).catch((err) => {
+            console.warn("[clips-recorder] local backup cleanup failed:", err);
+          });
+
           return { recordingId: id, viewUrl };
-        }
-        await markBrowserRecordingBackupError(id, error.message).catch(
-          () => {},
-        );
-        await abortRecordingUpload(params.serverUrl, id, error.message);
-        invoke("hide_finalizing").catch((hideErr) =>
-          console.error("[clips-recorder] hide_finalizing failed:", hideErr),
-        );
-        await openFailedRecordingPage();
-        throw error;
-      }
-      await deleteBrowserRecordingBackup(id).catch((err) => {
-        console.warn("[clips-recorder] local backup cleanup failed:", err);
+        },
+        releaseGuard: releaseFinalizingFeedback,
       });
-
-      // Finalize done (or tried and failed — the player page shows a clear
-      // error state in either case). Open the browser to the playback URL
-      // and THEN close the finalizing spinner. Closing before the browser
-      // opens would leave the user staring at an empty desktop for the
-      // brief moment while the OS launches / focuses the default browser.
-      const viewUrl = `/r/${id}`;
-      try {
-        await openExternal(`${params.serverUrl.replace(/\/+$/, "")}${viewUrl}`);
-      } catch (err) {
-        console.error("[clips-recorder] openExternal failed:", err);
-      }
-      invoke("hide_finalizing").catch((err) =>
-        console.error("[clips-recorder] hide_finalizing failed:", err),
-      );
-
-      return { recordingId: id, viewUrl };
     },
 
     async cancel() {

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

@@ -27,6 +27,10 @@ let pendingUpdate: Update | null = null;
 const listeners = new Set<StatusListener>();
 let started = false;
 let checkInFlight: Promise<void> | null = null;
+let lastCheckStartedAt = 0;
+
+const UPDATE_CHECK_INTERVAL_MS = 60 * 60 * 1000;
+const UPDATE_FOCUS_CHECK_MIN_INTERVAL_MS = 15 * 60 * 1000;
 
 function canRunUpdateChecks() {
   // Dev and local release builds are for testing the current checkout. Do not
@@ -40,8 +44,10 @@ function setStatus(next: UpdateStatus) {
 }
 
 async function runCheck() {
+  if (cachedStatus.state === "downloaded") return;
   if (checkInFlight) return checkInFlight;
 
+  lastCheckStartedAt = Date.now();
   checkInFlight = (async () => {
     try {
       setStatus({ state: "checking" });
@@ -90,14 +96,30 @@ async function runCheck() {
   return checkInFlight;
 }
 
+function maybeCheckForUpdate() {
+  if (!canRunUpdateChecks()) return;
+  if (cachedStatus.state === "downloaded") return;
+  if (
+    checkInFlight ||
+    Date.now() - lastCheckStartedAt < UPDATE_FOCUS_CHECK_MIN_INTERVAL_MS
+  ) {
+    return;
+  }
+  void runCheck();
+}
+
 function startUpdateLoop() {
   if (started) return;
   started = true;
   if (!canRunUpdateChecks()) return;
-  // Check 3s after launch (let the popover finish first paint), then every
-  // 4 hours. Matches the cadence used by the Electron app.
-  setTimeout(runCheck, 3000);
-  setInterval(runCheck, 4 * 60 * 60 * 1000);
+  // Check 3s after launch (let the popover finish first paint), hourly while
+  // Clips stays open, and when the user returns after at least 15 minutes.
+  setTimeout(() => void runCheck(), 3000);
+  setInterval(() => void runCheck(), UPDATE_CHECK_INTERVAL_MS);
+  window.addEventListener("focus", maybeCheckForUpdate);
+  document.addEventListener("visibilitychange", () => {
+    if (document.visibilityState === "visible") maybeCheckForUpdate();
+  });
 }
 
 export function useUpdateStatus(): UpdateStatus {

package/corpus/templates/clips/desktop/src/overlays/finalizing.tsx

@@ -25,17 +25,13 @@ type NativeUploadFinished = {
 
 /**
  * Full-screen transparent feedback overlay. Rendered the moment the user
- * clicks Stop on the recording toolbar and kept visible until the browser
- * opens at `/r/:id`. This fills the gap between `hide_recording_chrome`
- * tearing down the toolbar + bubble and `openExternal` actually opening
- * the browser — a gap that can stretch for several seconds while
- * MediaRecorder flushes trailing chunks and the server finalize POST
- * completes.
+ * clicks Stop on the recording toolbar and kept visible while the desktop
+ * finishes its durable backup and first upload/finalize attempt. The browser
+ * can open `/r/:id` earlier so the page shows live progress.
  *
  * The window ignores cursor events on the Rust side, so the compact
  * bottom-left card does not block the user's screen while compression or
- * upload continues. The recorder.ts stop path invokes `hide_finalizing`
- * right after `openExternal` to close this window.
+ * upload runs.
  */
 export function Finalizing() {
   const [progress, setProgress] = useState<ProcessingProgress>({

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

@@ -1,7 +1,7 @@
 [package]
 name = "clips-tray"
 version = "0.1.1"
-description = "Clips — menu-bar tray app (Tauri 2)"
+description = "Clips — cross-platform tray app (Tauri 2)"
 authors = ["Clips"]
 license = "MIT"
 edition = "2021"

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

@@ -498,8 +498,8 @@ pub async fn show_finalizing(app: AppHandle) -> Result<(), String> {
     Ok(())
 }
 
-/// Close the finalizing spinner overlay. Called from the recorder stop path
-/// right after `openExternal` opens the browser to the recording URL.
+/// Close the finalizing spinner overlay after the recorder's durable
+/// backup/upload boundary settles.
 #[tauri::command]
 pub async fn hide_finalizing(app: AppHandle) -> Result<(), String> {
     if let Some(w) = app.get_webview_window(FINALIZING_LABEL) {

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

@@ -19,14 +19,18 @@ pub fn check_permission_statuses() -> PermissionStatuses {
     }
     #[cfg(not(target_os = "macos"))]
     {
-        // TODO: implement
+        // Windows and Linux permissions are granted through the WebView and,
+        // on Linux, the XDG desktop portal. There is no reliable synchronous
+        // preflight equivalent to macOS TCC here, so report unavailable rather
+        // than claiming permissions were granted. The non-macOS UI relies on
+        // the actual media prompt and does not render these values.
         PermissionStatuses {
-            screen: true,
-            camera: true,
-            microphone: true,
-            speech: true,
-            accessibility: true,
-            input_monitoring: true,
+            screen: false,
+            camera: false,
+            microphone: false,
+            speech: false,
+            accessibility: false,
+            input_monitoring: false,
         }
     }
 }

package/corpus/templates/clips/desktop/src-tauri/tauri.linux.conf.json

@@ -0,0 +1,11 @@
+{
+  "$schema": "https://schema.tauri.app/config/2",
+  "bundle": {
+    "targets": ["appimage", "deb", "rpm"],
+    "linux": {
+      "appimage": {
+        "bundleMediaFramework": true
+      }
+    }
+  }
+}

package/corpus/templates/clips/netlify.toml

@@ -9,6 +9,9 @@ GA_MEASUREMENT_ID = "G-ESF7FYXGN9"
 NITRO_PRESET = "netlify"
 NPM_CONFIG_PRODUCTION = "false"
 AUTO_CREATE_DEFAULT_ORG = "1"
+# Emit the shared 15-minute Netlify background function used by agent chat and
+# Clips post-recording transcription/seekability workers.
+AGENT_CHAT_DURABLE_BACKGROUND = "true"
 # Netlify Functions run on linux/x64 (AWS Lambda). This tells the deploy build
 # to bundle the matching ffmpeg-static binary into the server bundle so the
 # server-side audio-only transcription fallback (analyzeAudioSignal / audio