@agent-native/core 0.90.11 → 0.91.0

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

@@ -55,7 +55,12 @@ type PopupMessage =
   | { type: "CLIPS_POPUP_STOP" }
   | { type: "CLIPS_POPUP_CANCEL" }
   | { type: "CLIPS_POPUP_OPEN" }
-  | { type: "CLIPS_POPUP_SIGN_IN"; settings?: Partial<ExtensionSettings> };
+  | { type: "CLIPS_POPUP_SIGN_IN"; settings?: Partial<ExtensionSettings> }
+  | {
+      type: "CLIPS_POPUP_PREPARE_PERMISSION_START";
+      settings?: Partial<ExtensionSettings>;
+      targetTabId?: number;
+    };
 
 type ExternalMessage =
   | {
@@ -82,6 +87,7 @@ type ExternalMessage =
 
 type ChromeTab = {
   id?: number;
+  windowId?: number;
   title?: string;
   url?: string;
 };
@@ -312,6 +318,7 @@ function overlayStateForBroadcast(): {
 // the overlay can't be injected) the recorder must still start. Without this,
 // recording would silently never begin on those pages.
 const COUNTDOWN_SECONDS = 3;
+const PENDING_PERMISSION_START_TTL_MS = 5 * 60 * 1000;
 
 function clearCountdownTimer(): void {
   countdownEndsAtMs = 0;
@@ -861,6 +868,33 @@ function queryActiveTab(): Promise<ChromeTab | null> {
   });
 }
 
+function getTab(tabId: number): Promise<ChromeTab | null> {
+  return new Promise((resolve) => {
+    chrome.tabs.get(tabId, (tab) => {
+      const error = chromeLastError();
+      resolve(error ? null : ((tab as ChromeTab | undefined) ?? null));
+    });
+  });
+}
+
+async function activateTab(tab: ChromeTab): Promise<void> {
+  if (typeof tab.id !== "number") return;
+  await new Promise<void>((resolve) => {
+    chrome.tabs.update(tab.id as number, { active: true }, () => {
+      void chrome.runtime.lastError;
+      resolve();
+    });
+  });
+  if (typeof tab.windowId === "number") {
+    await new Promise<void>((resolve) => {
+      chrome.windows.update(tab.windowId as number, { focused: true }, () => {
+        void chrome.runtime.lastError;
+        resolve();
+      });
+    });
+  }
+}
+
 function createTab(url: string): Promise<void> {
   return new Promise((resolve, reject) => {
     chrome.tabs.create({ url }, () => {
@@ -871,6 +905,44 @@ function createTab(url: string): Promise<void> {
   });
 }
 
+type PendingPermissionStart = {
+  settings: ExtensionSettings;
+  targetTabId: number;
+  createdAtMs: number;
+};
+
+async function writePendingPermissionStart(
+  pending: PendingPermissionStart,
+): Promise<void> {
+  await sessionStorageSet({ pendingPermissionStart: pending }).catch(
+    () => undefined,
+  );
+}
+
+async function clearPendingPermissionStart(): Promise<void> {
+  await sessionStorageRemove("pendingPermissionStart").catch(() => undefined);
+}
+
+async function readPendingPermissionStart(): Promise<PendingPermissionStart | null> {
+  const raw = (await sessionStorageGet(["pendingPermissionStart"]))
+    .pendingPermissionStart;
+  if (!raw || typeof raw !== "object") return null;
+  const pending = raw as Partial<PendingPermissionStart>;
+  if (
+    !pending.settings ||
+    typeof pending.targetTabId !== "number" ||
+    typeof pending.createdAtMs !== "number"
+  ) {
+    await clearPendingPermissionStart();
+    return null;
+  }
+  if (Date.now() - pending.createdAtMs > PENDING_PERMISSION_START_TTL_MS) {
+    await clearPendingPermissionStart();
+    return null;
+  }
+  return pending as PendingPermissionStart;
+}
+
 function debuggerAttach(tabId: number): Promise<void> {
   return new Promise((resolve, reject) => {
     chrome.debugger.attach({ tabId }, DEBUGGER_PROTOCOL_VERSION, () => {
@@ -974,9 +1046,9 @@ async function ensureOffscreenDocument(): Promise<void> {
 
   await chrome.offscreen.createDocument({
     url: path,
-    reasons: ["USER_MEDIA"],
+    reasons: ["USER_MEDIA", "CLIPBOARD"],
     justification:
-      "Record tab, camera, and microphone streams after the user starts Clips.",
+      "Record tab, camera, and microphone streams after the user starts Clips, then copy the finished clip link.",
   });
 }
 
@@ -1003,6 +1075,24 @@ function recordingUrl(
   return `${recording.clipsBaseUrl}/r/${encodeURIComponent(recording.recordingId)}`;
 }
 
+async function copyRecordingUrlToClipboard(
+  recording: NativeRecording,
+): Promise<void> {
+  try {
+    await ensureOffscreenDocument();
+    await sendOffscreenMessage({
+      type: "CLIPS_OFFSCREEN_COPY_TEXT",
+      text: recording.recordingUrl,
+    });
+  } catch (err) {
+    console.warn("[clips-bg] could not copy recording URL", err);
+    captureExtensionError(err, {
+      tags: { surface: "background", recordingStep: "copy-recording-url" },
+      extra: { recordingId: recording.recordingId },
+    });
+  }
+}
+
 function settingsFromRecording(recording: NativeRecording): ExtensionSettings {
   return {
     clipsBaseUrl: recording.clipsBaseUrl,
@@ -1049,6 +1139,19 @@ function createSession(
 }
 
 async function handlePopupStart(message: PopupStartMessage) {
+  const tab = await queryActiveTab();
+  if (!tab || typeof tab.id !== "number") {
+    return { ok: false, error: "No active tab is available to record." };
+  }
+  const settings = await readSettings(message.settings);
+  return startRecordingFromTab({ tab, settings });
+}
+
+async function startRecordingFromTab(args: {
+  tab: ChromeTab;
+  settings: ExtensionSettings;
+}) {
+  const { tab, settings } = args;
   // The persisted value is authoritative (survives a worker suspension during
   // arming); the in-memory var is only a same-tick fast path on top of it.
   // Stale (past-TTL) or legacy-shaped guards are treated as absent — see
@@ -1067,18 +1170,14 @@ async function handlePopupStart(message: PopupStartMessage) {
       error: "Clips is already recording. Stop the active clip first.",
     };
   }
+  if (typeof tab.id !== "number") {
+    return { ok: false, error: "No active tab is available to record." };
+  }
 
   const sessionId = crypto.randomUUID();
   await setArmingGuard(sessionId);
   try {
-    const tab = await queryActiveTab();
-    if (!tab || typeof tab.id !== "number") {
-      return { ok: false, error: "No active tab is available to record." };
-    }
-
-    const settings = await readSettings(message.settings);
     await storageSet(settings);
-
     return await armRecording({ sessionId, tab, settings });
   } finally {
     if (armingNativeRecordingSessionId === sessionId) {
@@ -1087,6 +1186,43 @@ async function handlePopupStart(message: PopupStartMessage) {
   }
 }
 
+async function handlePopupPreparePermissionStart(message: {
+  settings?: Partial<ExtensionSettings>;
+  targetTabId?: number;
+}) {
+  const settings = await readSettings(message.settings);
+  const tab =
+    typeof message.targetTabId === "number"
+      ? await getTab(message.targetTabId)
+      : await queryActiveTab();
+  if (!tab || typeof tab.id !== "number") {
+    return { ok: false, error: "No active tab is available to record." };
+  }
+  await writePendingPermissionStart({
+    settings,
+    targetTabId: tab.id,
+    createdAtMs: Date.now(),
+  });
+  return { ok: true };
+}
+
+async function handlePermissionStartAfterGrant() {
+  const pending = await readPendingPermissionStart();
+  if (!pending) {
+    return {
+      ok: false,
+      error: "Start the recording again from the Clips icon.",
+    };
+  }
+  await clearPendingPermissionStart();
+  const tab = await getTab(pending.targetTabId);
+  if (!tab || typeof tab.id !== "number") {
+    return { ok: false, error: "The original tab is no longer available." };
+  }
+  await activateTab(tab);
+  return startRecordingFromTab({ tab, settings: pending.settings });
+}
+
 // Arm a Loom-style in-page recording: show the native picker, create the row,
 // then hand the recorder its pre-roll delay. The MediaRecorder starts inside the
 // offscreen document after that delay, which reports "recording" back here
@@ -1390,6 +1526,10 @@ async function handleOverlayRestart() {
   overlayBaseElapsedMs = 0;
   overlayBaseEpochMs = nowMs();
   countdownEndsAtMs = nowMs() + COUNTDOWN_SECONDS * 1000;
+  const cameraInvolved =
+    recording.captureSurface === "camera" || recording.includeCamera;
+  overlayShowsBubble = cameraInvolved;
+  recordingShowsBubble = cameraInvolved;
   recording.status = "recording";
   const restartAuthToken = (
     await readAuthSession(settingsFromRecording(recording))
@@ -1403,9 +1543,8 @@ async function handleOverlayRestart() {
       recordingId: recording.recordingId,
       uploadUrl: recording.uploadUrl,
       uploadMode: recording.uploadMode ?? "buffered",
-      hasCamera:
-        recording.captureSurface === "camera" || recording.includeCamera,
-      startDelayMs: COUNTDOWN_SECONDS * 1000,
+      hasCamera: cameraInvolved,
+      startDelayMs: cameraInvolved ? 20000 : COUNTDOWN_SECONDS * 1000 + 1000,
       authToken: restartAuthToken,
     });
   } catch (err) {
@@ -1460,6 +1599,7 @@ async function finishSaving(
   await deleteSession(recording.sessionId);
   await broadcastUnmount();
   broadcastOverlayState();
+  await copyRecordingUrlToClipboard(recording);
   await clearNativeRecording();
   await createTab(recording.recordingUrl);
   return true;
@@ -2288,6 +2428,15 @@ async function dispatchRuntimeMessage(message: unknown): Promise<unknown> {
       return handlePopupSignIn(
         message as { settings?: Partial<ExtensionSettings> },
       );
+    case "CLIPS_POPUP_PREPARE_PERMISSION_START":
+      return handlePopupPreparePermissionStart(
+        message as {
+          settings?: Partial<ExtensionSettings>;
+          targetTabId?: number;
+        },
+      );
+    case "CLIPS_PERMISSION_START_AFTER_GRANT":
+      return handlePermissionStartAfterGrant();
     case "CLIPS_OVERLAY_COUNTDOWN_DONE":
       // Skip button on the countdown overlay: start the recorder now.
       return handleOverlaySkip();

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

@@ -350,6 +350,7 @@
   let cameraReady = false;
   let countdownDeferred = false;
   let countdownFallbackTimer: ReturnType<typeof setTimeout> | undefined;
+  let lastWantedParts = new Set<OverlayPart>();
 
   function showConnecting(container: HTMLDivElement): void {
     if (document.getElementById(CONNECTING_ID)) return;
@@ -430,6 +431,10 @@
   function reconcile(parts: OverlayPart[]): void {
     console.log("[clips-cs] reconcile parts:", parts, "on", location.href);
     const wanted = new Set(parts.filter((p) => ALL_PARTS.includes(p)));
+    const enteringCameraCountdown =
+      wanted.has("countdown") &&
+      wanted.has("bubble") &&
+      !lastWantedParts.has("countdown");
     // Leaving the countdown phase (recording / saving / idle): cancel any pending
     // deferred countdown + spinner so a late fallback timer can't pop the "3-2-1"
     // back up over a later overlay (this was the "countdown over the saving card"
@@ -438,13 +443,21 @@
       countdownDeferred = false;
       clearTimeout(countdownFallbackTimer);
       hideConnecting();
+      setBubbleHidden(false);
     }
     if (wanted.size === 0) {
       document.getElementById(CONTAINER_ID)?.remove();
       cameraReady = false;
+      lastWantedParts = wanted;
       return;
     }
     const container = ensureContainer();
+    if (enteringCameraCountdown) {
+      cameraReady = false;
+      hideConnecting();
+      setBubbleHidden(false);
+      document.getElementById(partFrameId("bubble"))?.remove();
+    }
     const gateCountdown =
       wanted.has("countdown") && wanted.has("bubble") && !cameraReady;
     for (const part of ALL_PARTS) {
@@ -467,6 +480,7 @@
       }
     }
     if (gateCountdown) showConnecting(container);
+    lastWantedParts = wanted;
   }
 
   // Guard against rare double-injection (SPA soft-reloads re-running the script).

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

@@ -60,6 +60,34 @@ function waitForRetry(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+async function copyTextToClipboard(
+  message: CopyTextMessage,
+): Promise<{ ok: boolean }> {
+  const text = message.text.trim();
+  if (!text) throw new Error("Missing text to copy.");
+
+  if (navigator.clipboard?.writeText) {
+    await navigator.clipboard.writeText(text);
+    return { ok: true };
+  }
+
+  const textarea = document.createElement("textarea");
+  textarea.value = text;
+  textarea.style.position = "fixed";
+  textarea.style.opacity = "0";
+  document.body.appendChild(textarea);
+  textarea.focus();
+  textarea.select();
+  try {
+    if (!document.execCommand("copy")) {
+      throw new Error("Clipboard copy was rejected.");
+    }
+    return { ok: true };
+  } finally {
+    textarea.remove();
+  }
+}
+
 function isFinalUploadRecoveryCandidate(error: Error): boolean {
   const tagged = error as {
     finalUploadRecoveryAttempted?: boolean;
@@ -114,6 +142,11 @@ type SimpleMessage = {
   sessionId: string;
 };
 
+type CopyTextMessage = {
+  type: "CLIPS_OFFSCREEN_COPY_TEXT";
+  text: string;
+};
+
 type StatusName = "recording" | "paused" | "uploading" | "complete" | "error";
 
 type UploadResult = {
@@ -1679,6 +1712,9 @@ chrome.runtime.onMessage.addListener((message, _sender, sendResponse) => {
     case "CLIPS_OFFSCREEN_START_NOW":
       task = Promise.resolve(startNow(message as SimpleMessage));
       break;
+    case "CLIPS_OFFSCREEN_COPY_TEXT":
+      task = copyTextToClipboard(message as CopyTextMessage);
+      break;
     default:
       return false;
   }

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

@@ -201,40 +201,114 @@ async function initBubble(): Promise<void> {
 
   root.appendChild(bubble);
 
-  try {
-    const videoDeviceId = await new Promise<string>((resolve) => {
-      try {
-        chrome.storage.sync.get("videoDeviceId", (v) =>
-          resolve(typeof v.videoDeviceId === "string" ? v.videoDeviceId : ""),
-        );
-      } catch {
-        resolve("");
-      }
-    });
-    const stream = await getCameraBubbleStream(videoDeviceId);
-    const video = document.createElement("video");
-    video.muted = true;
-    video.autoplay = true;
-    video.playsInline = true;
-    video.srcObject = stream;
-    ring.appendChild(video);
-    await video.play().catch(() => undefined);
-    console.log("[clips-overlay] camera bubble live");
+  let currentStream: MediaStream | null = null;
+  let currentVideo: HTMLVideoElement | null = null;
+  let healthTimer: number | undefined;
+  let reconnectTimer: number | undefined;
+  let unhealthyTicks = 0;
+  let readyPosted = false;
+
+  const postReadyOnce = (): void => {
+    if (readyPosted) return;
+    readyPosted = true;
     // Tell the host the feed is live so it can start the countdown — the "3"
     // shouldn't appear until the camera is actually showing.
     postBubble("camera-ready");
-  } catch (err) {
-    console.warn("[clips-overlay] camera getUserMedia failed:", err);
-    captureExtensionError(err, {
-      tags: { surface: "overlay", overlayPart: "bubble" },
-    });
+  };
+
+  const videoDeviceId = await new Promise<string>((resolve) => {
+    try {
+      chrome.storage.sync.get("videoDeviceId", (v) =>
+        resolve(typeof v.videoDeviceId === "string" ? v.videoDeviceId : ""),
+      );
+    } catch {
+      resolve("");
+    }
+  });
+
+  const stopCurrentStream = (): void => {
+    if (healthTimer !== undefined) window.clearInterval(healthTimer);
+    healthTimer = undefined;
+    if (reconnectTimer !== undefined) window.clearTimeout(reconnectTimer);
+    reconnectTimer = undefined;
+    currentVideo?.remove();
+    currentVideo = null;
+    currentStream?.getTracks().forEach((track) => track.stop());
+    currentStream = null;
+    unhealthyTicks = 0;
+  };
+
+  const showCameraUnavailable = (): void => {
+    stopCurrentStream();
+    ring.replaceChildren();
     const empty = document.createElement("div");
     empty.className = "bubble-empty";
     empty.innerHTML = ICONS.cameraOff;
     ring.appendChild(empty);
     // Still release the countdown — a blocked/failed camera must not hang it.
-    postBubble("camera-ready");
+    postReadyOnce();
+  };
+
+  const scheduleReconnect = (reason: string): void => {
+    if (reconnectTimer !== undefined) return;
+    reconnectTimer = window.setTimeout(() => {
+      reconnectTimer = undefined;
+      void connectCamera(reason);
+    }, 500);
+  };
+
+  const watchCameraHealth = (
+    video: HTMLVideoElement,
+    track: MediaStreamTrack,
+  ) => {
+    healthTimer = window.setInterval(() => {
+      const unhealthy =
+        track.readyState !== "live" ||
+        track.muted ||
+        video.readyState < HTMLMediaElement.HAVE_CURRENT_DATA ||
+        video.videoWidth === 0;
+      unhealthyTicks = unhealthy ? unhealthyTicks + 1 : 0;
+      if (unhealthyTicks >= 3) scheduleReconnect("camera stream stalled");
+    }, 2000);
+  };
+
+  async function connectCamera(reason = "initial"): Promise<void> {
+    stopCurrentStream();
+    try {
+      const stream = await getCameraBubbleStream(videoDeviceId);
+      const video = document.createElement("video");
+      video.muted = true;
+      video.autoplay = true;
+      video.playsInline = true;
+      video.srcObject = stream;
+      ring.replaceChildren(video);
+      currentStream = stream;
+      currentVideo = video;
+      const track = stream.getVideoTracks()[0];
+      track?.addEventListener("ended", () => scheduleReconnect("track ended"));
+      track?.addEventListener("mute", () => scheduleReconnect("track muted"));
+      video.addEventListener("stalled", () =>
+        scheduleReconnect("video stalled"),
+      );
+      video.addEventListener("emptied", () =>
+        scheduleReconnect("video emptied"),
+      );
+      await video.play().catch(() => undefined);
+      console.log("[clips-overlay] camera bubble live", reason);
+      postReadyOnce();
+      if (track) watchCameraHealth(video, track);
+    } catch (err) {
+      console.warn("[clips-overlay] camera getUserMedia failed:", err);
+      captureExtensionError(err, {
+        tags: { surface: "overlay", overlayPart: "bubble" },
+        extra: { reason },
+      });
+      showCameraUnavailable();
+    }
   }
+
+  window.addEventListener("pagehide", stopCurrentStream, { once: true });
+  await connectCamera();
 }
 
 /* ------------------------------------------------------------- countdown --- */

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

@@ -23,6 +23,13 @@ const checkCam = document.getElementById("check-cam") as HTMLSpanElement;
 
 const CHECK = "✓";
 const DOT = "●";
+const params = new URLSearchParams(location.search);
+const startAfterGrant = params.get("startAfterGrant") === "1";
+const shouldRequestCamera = params.get("needsCamera") !== "false";
+const shouldRequestMicrophone = params.get("needsMicrophone") !== "false";
+
+if (!shouldRequestMicrophone) rowMic.hidden = true;
+if (!shouldRequestCamera) rowCam.hidden = true;
 
 function setStatus(text: string, isError = false): void {
   statusEl.textContent = text;
@@ -40,8 +47,9 @@ function showSuccess(title: string): void {
   enableBtn.hidden = true;
   enableBtn.disabled = true;
   successTitle.textContent = title;
-  successCopy.textContent =
-    "You can close this tab and start recording from the Clips icon.";
+  successCopy.textContent = startAfterGrant
+    ? "Opening Chrome's screen picker now."
+    : "You can close this tab and start recording from the Clips icon.";
   successEl.hidden = false;
   setStatus(
     "Chrome still asks you what to share before each recording starts.",
@@ -83,14 +91,53 @@ async function requestOne(kind: "mic" | "cam"): Promise<boolean> {
   }
 }
 
-function finish(camOk: boolean, micOk: boolean): void {
-  void chrome.storage.local.set({
-    clipsMediaPermission: { camera: camOk, microphone: micOk },
+function requiredPermissionsReady(camOk: boolean, micOk: boolean): boolean {
+  return (!shouldRequestCamera || camOk) && (!shouldRequestMicrophone || micOk);
+}
+
+function writePermissionCache(camOk: boolean, micOk: boolean): Promise<void> {
+  return new Promise((resolve) => {
+    chrome.storage.local.get("clipsMediaPermission", (value) => {
+      const current =
+        value.clipsMediaPermission &&
+        typeof value.clipsMediaPermission === "object"
+          ? (value.clipsMediaPermission as {
+              camera?: boolean;
+              microphone?: boolean;
+            })
+          : {};
+      const next = {
+        ...current,
+        ...(shouldRequestCamera ? { camera: camOk } : {}),
+        ...(shouldRequestMicrophone ? { microphone: micOk } : {}),
+      };
+      chrome.storage.local.set({ clipsMediaPermission: next }, () => resolve());
+    });
   });
+}
+
+async function startPendingRecording(): Promise<void> {
+  const response = (await chrome.runtime.sendMessage({
+    type: "CLIPS_PERMISSION_START_AFTER_GRANT",
+  })) as { ok?: boolean; error?: string } | undefined;
+  if (response?.ok) {
+    window.close();
+    return;
+  }
+  showEnableButton("Try again", false);
+  setStatus(
+    response?.error || "Start the recording again from the Clips icon.",
+    true,
+  );
+}
+
+async function finish(camOk: boolean, micOk: boolean): Promise<void> {
+  await writePermissionCache(camOk, micOk);
   markRow("mic", micOk);
   markRow("cam", camOk);
-  if (camOk || micOk) {
-    showSuccess(camOk && micOk ? "You're all done" : "Saved");
+  if (requiredPermissionsReady(camOk, micOk)) {
+    showSuccess(startAfterGrant ? "Starting recording..." : "You're all done");
+    if (startAfterGrant) await startPendingRecording();
   } else {
     showEnableButton("Try again", false);
     setStatus(
@@ -104,9 +151,9 @@ async function enable(): Promise<void> {
   showEnableButton(enableBtn.textContent ?? "Enable camera & microphone", true);
   setStatus("Waiting for Chrome's permission prompt…");
   // Request separately so a camera denial doesn't also block the microphone.
-  const micOk = await requestOne("mic");
-  const camOk = await requestOne("cam");
-  finish(camOk, micOk);
+  const micOk = shouldRequestMicrophone ? await requestOne("mic") : true;
+  const camOk = shouldRequestCamera ? await requestOne("cam") : true;
+  await finish(camOk, micOk);
 }
 
 enableBtn.addEventListener("click", () => void enable());
@@ -117,9 +164,11 @@ void (async () => {
     permissionState("camera"),
     permissionState("microphone"),
   ]);
-  markRow("mic", mic === "granted");
-  markRow("cam", cam === "granted");
-  if (cam === "granted" && mic === "granted") {
-    showSuccess("You're all done");
+  const micOk = !shouldRequestMicrophone || mic === "granted";
+  const camOk = !shouldRequestCamera || cam === "granted";
+  markRow("mic", micOk);
+  markRow("cam", camOk);
+  if (requiredPermissionsReady(camOk, micOk)) {
+    await finish(camOk, micOk);
   }
 })();