@agent-native/core 0.77.6 → 0.77.7

package/corpus/templates/clips/app/lib/browser-diagnostics-capture.ts

@@ -26,8 +26,12 @@ function redactString(value: string): string {
   return redactBrowserDiagnosticString(value);
 }
 
+function redactUrlString(value: string): string {
+  return redactBrowserDiagnosticString(value, { redactQueryValues: true });
+}
+
 function sanitizeUrl(raw: string): string {
-  const redacted = redactString(raw);
+  const redacted = redactUrlString(raw);
   try {
     const parsed = new URL(redacted, window.location.href);
     parsed.username = "";

package/corpus/templates/clips/changelog/2026-06-25-chrome-extension-recordings-now-upload-large-capture-bursts.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-06-25
+---
+
+Chrome extension recordings now upload large capture bursts reliably and report extension errors to Sentry.

package/corpus/templates/clips/changelog/2026-06-25-console-diagnostics-keep-more-useful-non-secret-details-when.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-06-25
+---
+
+Console diagnostics keep more useful non-secret details when clips are shared with agents.

package/corpus/templates/clips/changelog/2026-06-25-fixed-owner-recognition-so-clips-created-from-desktop-and-we.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-06-25
+---
+
+Fixed owner recognition so Clips created from desktop and web sessions remain editable by the same signed-in user.

package/corpus/templates/clips/chrome-extension/package.json

@@ -10,6 +10,9 @@
     "typecheck": "tsgo --noEmit",
     "package": "pnpm build && tsx scripts/package.ts"
   },
+  "dependencies": {
+    "@sentry/browser": "^10.61.0"
+  },
   "devDependencies": {
     "@types/chrome": "^0.2.0",
     "@typescript/native-preview": "catalog:",

package/corpus/templates/clips/chrome-extension/public/manifest.json

@@ -2,7 +2,7 @@
   "manifest_version": 3,
   "name": "Agent-Native Clips",
   "short_name": "Clips",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Start Clips recordings from Chrome with optional redacted console and network diagnostics.",
   "minimum_chrome_version": "116",
   "action": {

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

@@ -1,3 +1,7 @@
+import { captureExtensionError, initExtensionSentry } from "./sentry";
+
+initExtensionSentry("background");
+
 const DEFAULT_CLIPS_BASE_URL = "https://clips.agent-native.com";
 const DEBUGGER_PROTOCOL_VERSION = "1.3";
 const MAX_CONSOLE_LOGS = 400;
@@ -149,6 +153,15 @@ type OffscreenStatusMessage = {
   error?: string;
 };
 
+type ExtensionErrorMessage = {
+  type: "CLIPS_EXTENSION_ERROR";
+  surface?: string;
+  name?: string;
+  message?: string;
+  stack?: string;
+  context?: Record<string, unknown>;
+};
+
 type PendingNetworkRequest = {
   requestId: string;
   timestampMs: number;
@@ -516,19 +529,24 @@ function truncate(value: string, maxLength: number): string {
   return value.length > maxLength ? `${value.slice(0, maxLength)}...` : value;
 }
 
-function redactString(value: string): string {
-  return value
+function redactString(
+  value: string,
+  options: { redactQueryValues?: boolean } = {},
+): string {
+  const redacted = value
     .replace(AUTHORIZATION_SCHEME_RE, "$1$2<redacted>")
     .replace(/\b(bearer|basic)\s+[a-z0-9._~+/-]+=*/gi, "$1 <redacted>")
     .replace(DOUBLE_QUOTED_SECRET_VALUE_RE, '$1$2$1$3"<redacted>"')
     .replace(SINGLE_QUOTED_SECRET_VALUE_RE, "$1$2$1$3'<redacted>'")
-    .replace(UNQUOTED_SECRET_VALUE_RE, "$1$2$1$3<redacted>")
-    .replace(/([?&][^=\s&?#]+)=([^&\s#]+)/g, "$1=<redacted>");
+    .replace(UNQUOTED_SECRET_VALUE_RE, "$1$2$1$3<redacted>");
+  return options.redactQueryValues
+    ? redacted.replace(/([?&][^=\s&?#]+)=([^&\s#]+)/g, "$1=<redacted>")
+    : redacted;
 }
 
 function sanitizeUrl(raw: string | null | undefined): string | null {
   if (!raw) return null;
-  const redacted = redactString(raw);
+  const redacted = redactString(raw, { redactQueryValues: true });
   try {
     const parsed = new URL(redacted);
     parsed.username = "";
@@ -1016,6 +1034,17 @@ async function armRecording(args: {
       visibility: "public",
     });
   } catch (err) {
+    captureExtensionError(err, {
+      tags: {
+        surface: "background",
+        recordingStep: "create-recording",
+      },
+      extra: {
+        captureSurface: settings.captureSurface,
+        includeCamera: settings.includeCamera,
+        includeMicrophone: settings.includeMicrophone,
+      },
+    });
     await abortArming();
     throw err;
   }
@@ -1070,6 +1099,18 @@ async function armRecording(args: {
     });
   } catch (err) {
     console.error("[clips-bg] arm: BEGIN failed", err);
+    captureExtensionError(err, {
+      tags: {
+        surface: "background",
+        recordingStep: "offscreen-begin",
+      },
+      extra: {
+        recordingId: created.id,
+        captureSurface: settings.captureSurface,
+        includeCamera: settings.includeCamera,
+        includeMicrophone: settings.includeMicrophone,
+      },
+    });
     await cancelRecording();
     throw err;
   }
@@ -1553,9 +1594,15 @@ function pushConsole(
   const timestampMs = Number.isFinite(entry.timestampMs)
     ? (entry.timestampMs as number)
     : nowMs();
-  const message = truncate(redactString(entry.message), MAX_MESSAGE_LENGTH);
+  const message = truncate(
+    redactString(entry.message, { redactQueryValues: true }),
+    MAX_MESSAGE_LENGTH,
+  );
   const stack = entry.stack
-    ? truncate(redactString(entry.stack), MAX_MESSAGE_LENGTH)
+    ? truncate(
+        redactString(entry.stack, { redactQueryValues: true }),
+        MAX_MESSAGE_LENGTH,
+      )
     : "";
   session.consoleLogs.push({
     timestampMs,
@@ -1762,7 +1809,10 @@ function handleResponseReceived(
     pending.ok = response.status >= 200 && response.status < 400;
   }
   if (typeof response.statusText === "string") {
-    pending.statusText = truncate(redactString(response.statusText), 120);
+    pending.statusText = truncate(
+      redactString(response.statusText, { redactQueryValues: true }),
+      120,
+    );
   }
 }
 
@@ -1792,7 +1842,12 @@ function finalizeNetworkRequest(
     ...(typeof pending.ok === "boolean" ? { ok: pending.ok } : {}),
     durationMs: Math.round(durationMs),
     ...(error
-      ? { error: truncate(redactString(error), MAX_MESSAGE_LENGTH) }
+      ? {
+          error: truncate(
+            redactString(error, { redactQueryValues: true }),
+            MAX_MESSAGE_LENGTH,
+          ),
+        }
       : {}),
   });
 }
@@ -1923,6 +1978,12 @@ chrome.runtime.onMessage.addListener((message, _sender, sendResponse) => {
         (message as { type?: unknown })?.type,
         err,
       );
+      captureExtensionError(err, {
+        tags: {
+          surface: "background",
+          messageType: String((message as { type?: unknown })?.type ?? ""),
+        },
+      });
       response = {
         ok: false,
         error: err instanceof Error ? err.message : "Could not use Clips.",
@@ -1940,6 +2001,21 @@ chrome.runtime.onMessage.addListener((message, _sender, sendResponse) => {
 async function dispatchRuntimeMessage(message: unknown): Promise<unknown> {
   const type = (message as { type?: unknown }).type;
 
+  if (type === "CLIPS_EXTENSION_ERROR") {
+    const report = message as ExtensionErrorMessage;
+    const error = new Error(report.message || "Chrome extension error");
+    error.name = report.name || "ExtensionError";
+    if (report.stack) error.stack = report.stack;
+    captureExtensionError(error, {
+      tags: {
+        surface: report.surface || "content-script",
+        mechanism: "content-script-report",
+      },
+      extra: report.context,
+    });
+    return { ok: true };
+  }
+
   // Status updates streamed from the offscreen recorder.
   if (type === "CLIPS_NATIVE_STATUS") {
     const status = message as OffscreenStatusMessage;

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

@@ -18,6 +18,61 @@
   const ALL_PARTS: OverlayPart[] = ["bubble", "countdown", "toolbar", "saving"];
   const flags = window as unknown as { __clipsOverlayHostReady?: boolean };
 
+  function errorPayload(error: unknown): {
+    name: string;
+    message: string;
+    stack?: string;
+  } {
+    if (error instanceof Error) {
+      return {
+        name: error.name || "Error",
+        message: error.message || "Unknown content-script error",
+        stack: error.stack,
+      };
+    }
+    return {
+      name: "Error",
+      message: String(error ?? "Unknown content-script error"),
+    };
+  }
+
+  function reportContentScriptError(
+    error: unknown,
+    context: Record<string, unknown> = {},
+  ): void {
+    try {
+      chrome.runtime.sendMessage(
+        {
+          type: "CLIPS_EXTENSION_ERROR",
+          surface: "content-script",
+          ...errorPayload(error),
+          context: {
+            ...context,
+            pageUrl: location.href,
+          },
+        },
+        () => void chrome.runtime.lastError,
+      );
+    } catch {
+      /* background unavailable */
+    }
+  }
+
+  window.addEventListener("error", (event) => {
+    reportContentScriptError(event.error || event.message, {
+      mechanism: "global-error",
+      filename: event.filename,
+      lineno: event.lineno,
+      colno: event.colno,
+    });
+  });
+
+  window.addEventListener("unhandledrejection", (event) => {
+    reportContentScriptError(event.reason, {
+      mechanism: "unhandled-rejection",
+    });
+  });
+
   // ----- Draggable, resizable camera bubble ---------------------------------
   // Size + position persist in storage so the bubble stays where the user put it
   // across pages and recordings (like the desktop app). The iframe can't move or

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

@@ -19,6 +19,10 @@
 import { scheduleReadyChime } from "@shared/recording-audio";
 import { chunkUploadUrl, pickMimeType } from "@shared/recording-core";
 
+import { captureExtensionError, initExtensionSentry } from "./sentry";
+
+initExtensionSentry("offscreen");
+
 type CaptureMode = "screen" | "camera";
 
 type AcquireMessage = {
@@ -118,6 +122,8 @@ type ActiveRecording = {
   rejectStopped: (error: Error) => void;
 };
 
+const UPLOAD_SLICE_BYTES = 3 * 1024 * 1024;
+
 let prepared: PreparedStreams | null = null;
 let activeRecording: ActiveRecording | null = null;
 
@@ -399,13 +405,46 @@ async function uploadChunk(
       Boolean(recording.authToken),
       text.slice(0, 200),
     );
-    throw new Error(
+    const error = new Error(
       data?.error || `Upload failed (${res.status}): ${text || res.statusText}`,
     );
+    captureExtensionError(error, {
+      tags: {
+        surface: "offscreen",
+        recordingStep: "chunk-upload",
+        httpStatus: String(res.status),
+        isFinal: extra.isFinal ? "true" : "false",
+      },
+      extra: {
+        recordingId: recording.recordingId,
+        chunkIndex: index,
+        chunkBytes: blob.size,
+        total: extra.total,
+        mimeType: blob.type || recording.mimeType,
+        responseBodyTail: text.slice(0, 2000),
+        hadAuth: Boolean(recording.authToken),
+      },
+    });
+    throw error;
   }
   return data;
 }
 
+async function uploadBlobInSlices(
+  recording: ActiveRecording,
+  blob: Blob,
+): Promise<void> {
+  const totalSlices = Math.max(1, Math.ceil(blob.size / UPLOAD_SLICE_BYTES));
+  for (let sliceIndex = 0; sliceIndex < totalSlices; sliceIndex += 1) {
+    if (recording.cancelled || recording.uploadFailure) return;
+    const start = sliceIndex * UPLOAD_SLICE_BYTES;
+    const end = Math.min(start + UPLOAD_SLICE_BYTES, blob.size);
+    const slice = blob.slice(start, end, blob.type || recording.mimeType);
+    const index = recording.chunkIndex++;
+    await uploadChunk(recording, slice, index);
+  }
+}
+
 function stopStreams(streams: (MediaStream | null)[]): void {
   for (const stream of streams) {
     if (!stream) continue;
@@ -616,14 +655,25 @@ async function begin(message: BeginMessage): Promise<{
     ) {
       return;
     }
-    const index = recording.chunkIndex++;
     // Record the failure and stop, but do NOT re-throw: re-throwing leaves a
     // 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 = uploadChunk(recording, event.data, index).catch((err) => {
+    const upload = 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,
       });
@@ -687,6 +737,20 @@ function startRecorderNow(recording: ActiveRecording): void {
       hasCamera: recording.hasCamera,
     });
   } catch (err) {
+    captureExtensionError(err, {
+      tags: {
+        surface: "offscreen",
+        recordingStep: "recorder-start",
+      },
+      extra: {
+        recordingId: recording.recordingId,
+        mimeType: recording.mimeType,
+        width: recording.dimensions.width,
+        height: recording.dimensions.height,
+        hasAudio: recording.hasAudio,
+        hasCamera: recording.hasCamera,
+      },
+    });
     reportStatus(recording.sessionId, "error", {
       recordingId: recording.recordingId,
       error: err instanceof Error ? err.message : "Could not start recording.",
@@ -766,6 +830,18 @@ async function finalizeStop(recording: ActiveRecording): Promise<void> {
     cleanup(recording);
     if (activeRecording === recording) activeRecording = null;
     const error = err instanceof Error ? err : new Error(String(err));
+    captureExtensionError(error, {
+      tags: {
+        surface: "offscreen",
+        recordingStep: "finalize-stop",
+      },
+      extra: {
+        recordingId: recording.recordingId,
+        chunkCount: recording.chunkIndex,
+        mimeType: recording.mimeType,
+        durationMs: Math.max(0, Date.now() - recording.startedAtMs),
+      },
+    });
     reportStatus(recording.sessionId, "error", {
       recordingId: recording.recordingId,
       error: error.message,

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

@@ -1,3 +1,7 @@
+import { captureExtensionError, initExtensionSentry } from "./sentry";
+
+initExtensionSentry("options");
+
 type CaptureSurface = "browser" | "window" | "monitor" | "camera";
 
 type ExtensionSettings = {
@@ -116,6 +120,9 @@ async function init(): Promise<void> {
         await saveSettings(settings);
         setStatus("Settings saved.");
       } catch (err) {
+        captureExtensionError(err, {
+          tags: { surface: "options", action: "save-settings" },
+        });
         setStatus(
           err instanceof Error ? err.message : "Could not save settings.",
           "error",
@@ -132,6 +139,9 @@ async function init(): Promise<void> {
 }
 
 void init().catch((err) => {
+  captureExtensionError(err, {
+    tags: { surface: "options", action: "init" },
+  });
   setStatus(
     err instanceof Error ? err.message : "Could not load settings.",
     "error",

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

@@ -1,4 +1,7 @@
 import "./overlay.css";
+import { captureExtensionError, initExtensionSentry } from "./sentry";
+
+initExtensionSentry("overlay");
 
 // The overlay runs as an extension-origin iframe injected into the page by the
 // content script. Each iframe renders one "part" of the Loom-style recording UI
@@ -166,6 +169,9 @@ async function initBubble(): Promise<void> {
     postBubble("camera-ready");
   } catch (err) {
     console.warn("[clips-overlay] camera getUserMedia failed:", err);
+    captureExtensionError(err, {
+      tags: { surface: "overlay", overlayPart: "bubble" },
+    });
     const empty = document.createElement("div");
     empty.className = "bubble-empty";
     empty.innerHTML = ICONS.cameraOff;

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

@@ -5,6 +5,10 @@
 // the grant for the whole chrome-extension:// origin — so the offscreen recorder
 // (mic) and the camera-bubble iframe both work afterward.
 
+import { captureExtensionError, initExtensionSentry } from "./sentry";
+
+initExtensionSentry("permission");
+
 const enableBtn = document.getElementById("enable") as HTMLButtonElement;
 const statusEl = document.getElementById("status") as HTMLDivElement;
 const successEl = document.getElementById("success-state") as HTMLDivElement;
@@ -71,7 +75,10 @@ async function requestOne(kind: "mic" | "cam"): Promise<boolean> {
     const stream = await navigator.mediaDevices.getUserMedia(constraints);
     for (const track of stream.getTracks()) track.stop();
     return true;
-  } catch {
+  } catch (err) {
+    captureExtensionError(err, {
+      tags: { surface: "permission", permission: kind },
+    });
     return false;
   }
 }

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

@@ -1,3 +1,7 @@
+import { captureExtensionError, initExtensionSentry } from "./sentry";
+
+initExtensionSentry("popup");
+
 type CaptureSurface = "browser" | "window" | "monitor" | "camera";
 type RecordingModeChoice = "screen-camera" | "screen" | "camera";
 
@@ -1032,6 +1036,9 @@ async function init(): Promise<void> {
         1400,
       );
     } catch (err) {
+      captureExtensionError(err, {
+        tags: { surface: "popup", action: "submit-feedback" },
+      });
       feedbackSubmit.disabled = !feedbackTextarea.value.trim();
       feedbackSubmit.textContent = FEEDBACK_SUBMIT_TEXT;
       feedbackHint.textContent =
@@ -1065,51 +1072,67 @@ async function init(): Promise<void> {
     start.disabled = true;
     signIn.hidden = true;
     setStatus(""); // no chatty "Checking…/Starting…" text — the disabled button is enough
-    authStatus = await readAuthStatus(settings);
-    if (authStatus === "signed-out") {
+    try {
+      authStatus = await readAuthStatus(settings);
+      if (authStatus === "signed-out") {
+        start.disabled = false;
+        start.hidden = true;
+        signIn.hidden = false;
+        setStatus("");
+        return;
+      }
+      const storageConfigured = await readVideoStorageConfigured(settings);
+      if (!storageConfigured) {
+        start.disabled = false;
+        setStatus(
+          "Connect Builder.io or S3 storage in Clips, then start recording.",
+          "error",
+        );
+        await createTab(`${settings.clipsBaseUrl.replace(/\/+$/, "")}/record`);
+        window.close();
+        return;
+      }
+      // Gate at record time: if the user wants camera/mic but hasn't granted the
+      // extension access yet, send them to the onboarding page first. Requesting
+      // there (a real extension page) is the only place Chrome reliably shows the
+      // permission dialog and persists the grant for the offscreen recorder + bubble.
+      if (!(await ensureMediaPermission(settings))) {
+        start.disabled = false;
+        setStatus("Allow camera & microphone, then start recording.", "error");
+        await createTab(chrome.runtime.getURL("src/permission.html"));
+        window.close();
+        return;
+      }
+      await saveSettings(settings);
+      const response = await sendStartMessage(settings);
+      if (response.ok) {
+        window.close();
+        return;
+      }
       start.disabled = false;
-      start.hidden = true;
-      signIn.hidden = false;
-      setStatus("");
-      return;
-    }
-    const storageConfigured = await readVideoStorageConfigured(settings);
-    if (!storageConfigured) {
+      const message = response.error || "Could not start Clips.";
+      if (isSignInError(message)) {
+        start.hidden = true;
+        signIn.hidden = false;
+        setStatus("");
+        return;
+      }
+      setStatus(message, "error");
+    } catch (err) {
+      captureExtensionError(err, {
+        tags: { surface: "popup", action: "start-recording" },
+        extra: {
+          captureSurface: settings.captureSurface,
+          includeCamera: settings.includeCamera,
+          includeMicrophone: settings.includeMicrophone,
+        },
+      });
       start.disabled = false;
       setStatus(
-        "Connect Builder.io or S3 storage in Clips, then start recording.",
+        err instanceof Error ? err.message : "Could not start Clips.",
         "error",
       );
-      await createTab(`${settings.clipsBaseUrl.replace(/\/+$/, "")}/record`);
-      window.close();
-      return;
-    }
-    // Gate at record time: if the user wants camera/mic but hasn't granted the
-    // extension access yet, send them to the onboarding page first. Requesting
-    // there (a real extension page) is the only place Chrome reliably shows the
-    // permission dialog and persists the grant for the offscreen recorder + bubble.
-    if (!(await ensureMediaPermission(settings))) {
-      start.disabled = false;
-      setStatus("Allow camera & microphone, then start recording.", "error");
-      await createTab(chrome.runtime.getURL("src/permission.html"));
-      window.close();
-      return;
     }
-    await saveSettings(settings);
-    const response = await sendStartMessage(settings);
-    if (response.ok) {
-      window.close();
-      return;
-    }
-    start.disabled = false;
-    const message = response.error || "Could not start Clips.";
-    if (isSignInError(message)) {
-      start.hidden = true;
-      signIn.hidden = false;
-      setStatus("");
-      return;
-    }
-    setStatus(message, "error");
   });
 
   signIn.addEventListener("click", async () => {
@@ -1173,6 +1196,9 @@ async function init(): Promise<void> {
 }
 
 void init().catch((err) => {
+  captureExtensionError(err, {
+    tags: { surface: "popup", action: "init" },
+  });
   setStatus(
     err instanceof Error ? err.message : "Could not load popup.",
     "error",