@arbidocs/blocks 0.5.126 → 0.5.127

package/dist/{chunk-OHHKBURG.cjs → chunk-2SU37RZA.cjs}

@@ -61,20 +61,353 @@ var renderConnectedUser = (user, { tooltip, variant = "icon" }) => /* @__PURE__
     showTooltip: tooltip
   }
 );
-function createRemoteControl(session, guided) {
+
+// src/connection/report-problem/screen-capture.ts
+var ScreenCaptureError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "ScreenCaptureError";
+  }
+  code;
+};
+function canCaptureScreen() {
+  return typeof navigator !== "undefined" && !!navigator.mediaDevices?.getDisplayMedia;
+}
+async function captureCurrentTab() {
+  if (!canCaptureScreen()) {
+    throw new ScreenCaptureError("unsupported", "This browser can't capture the screen.");
+  }
+  let stream;
+  try {
+    stream = await navigator.mediaDevices.getDisplayMedia({
+      video: { displaySurface: "browser" },
+      audio: false,
+      // Chromium hints: offer this tab first, and don't let the person switch surfaces mid-capture.
+      preferCurrentTab: true,
+      selfBrowserSurface: "include",
+      surfaceSwitching: "exclude"
+    });
+  } catch (error) {
+    const name = error instanceof DOMException ? error.name : "";
+    if (name === "NotAllowedError" || name === "AbortError") {
+      throw new ScreenCaptureError("cancelled", "Screen capture was cancelled.");
+    }
+    throw new ScreenCaptureError("failed", "Couldn't start screen capture.");
+  }
+  try {
+    return await grabFrame(stream);
+  } finally {
+    stream.getTracks().forEach((track) => track.stop());
+  }
+}
+async function grabFrame(stream) {
+  const video = document.createElement("video");
+  video.muted = true;
+  video.playsInline = true;
+  video.srcObject = stream;
+  await video.play();
+  for (let i = 0; i < 50 && (!video.videoWidth || !video.videoHeight); i++) {
+    await new Promise((resolve) => setTimeout(resolve, 40));
+  }
+  await new Promise((resolve) => requestAnimationFrame(() => resolve(null)));
+  const canvas = document.createElement("canvas");
+  canvas.width = video.videoWidth;
+  canvas.height = video.videoHeight;
+  const ctx = canvas.getContext("2d");
+  if (!ctx || !canvas.width) throw new ScreenCaptureError("failed", "Couldn't read the screen.");
+  ctx.drawImage(video, 0, 0);
+  video.srcObject = null;
+  return canvasToBlob(canvas);
+}
+function canvasToBlob(canvas) {
+  return new Promise(
+    (resolve, reject) => canvas.toBlob(
+      (blob) => blob ? resolve(blob) : reject(new ScreenCaptureError("failed", "Couldn't save the image.")),
+      "image/png"
+    )
+  );
+}
+
+// src/connection/remote-control/browser-diagnostics.ts
+function collectBrowserDiagnostics() {
+  const lines = [];
+  const add = (message) => {
+    lines.push(`${(/* @__PURE__ */ new Date()).toISOString()} ${sanitizeDiagnostic(message).slice(0, 1800)}`);
+    if (lines.length > 30) lines.shift();
+  };
+  const stringify = (value) => {
+    if (value instanceof Error)
+      return chunkT73BHNQX_cjs.formatErrorReport({ error: value, url: safeUrl(location.href) });
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean")
+      return String(value);
+    return "[object omitted]";
+  };
+  const originalError = console.error;
+  const originalWarn = console.warn;
+  const error = (...args) => {
+    add(`error: ${args.map(stringify).join(" ")}`);
+    originalError.apply(console, args);
+  };
+  const warn = (...args) => {
+    add(`warning: ${args.map(stringify).join(" ")}`);
+    originalWarn.apply(console, args);
+  };
+  console.error = error;
+  console.warn = warn;
+  const onError = (event) => add(`uncaught: ${stringify(event.error ?? event.message)}`);
+  const onRejection = (event) => add(`unhandled rejection: ${stringify(event.reason)}`);
+  window.addEventListener("error", onError);
+  window.addEventListener("unhandledrejection", onRejection);
+  const originalFetch = window.fetch;
+  const wrappedFetch = async (...args) => {
+    const input = args[0];
+    const url = safeUrl(
+      typeof input === "string" ? input : input instanceof URL ? input.href : input.url
+    );
+    try {
+      const response = await originalFetch.apply(window, args);
+      if (!response.ok) add(`HTTP ${response.status}: ${url}`);
+      return response;
+    } catch (failure) {
+      add(`request failed: ${url}`);
+      throw failure;
+    }
+  };
+  window.fetch = wrappedFetch;
+  let resources;
+  if (typeof PerformanceObserver !== "undefined") {
+    try {
+      resources = new PerformanceObserver((list) => {
+        for (const entry of list.getEntries()) {
+          const resource = entry;
+          if ("responseStatus" in resource && Number(resource.responseStatus) >= 400)
+            add(`HTTP ${resource.responseStatus}: ${safeUrl(resource.name)}`);
+        }
+      });
+      resources.observe({ type: "resource" });
+    } catch {
+      resources = void 0;
+    }
+  }
+  return {
+    snapshot: () => [
+      `ARBI tab: ${safeUrl(location.href)}`,
+      `Viewport: ${innerWidth} x ${innerHeight}; DPR ${devicePixelRatio}`,
+      "Visible ARBI controls (selectors for control_ui):",
+      ...Array.from(
+        document.querySelectorAll(
+          'button[data-testid],a[data-testid],input[data-testid]:not([type="password"]),select[data-testid],[role="button"][data-testid]'
+        )
+      ).filter(
+        (el) => el.getBoundingClientRect().width > 0 && !el.closest("[data-remote-control-surface]")
+      ).slice(0, 60).map(
+        (el) => `[data-testid=${JSON.stringify(el.dataset.testid)}] ${sanitizeDiagnostic(el.getAttribute("aria-label") ?? el.getAttribute("title") ?? el.textContent ?? "").slice(0, 80)}`
+      ),
+      ...lines
+    ].join("\n").slice(-18e3),
+    stop: () => {
+      if (console.error === error) console.error = originalError;
+      if (console.warn === warn) console.warn = originalWarn;
+      if (window.fetch === wrappedFetch) window.fetch = originalFetch;
+      window.removeEventListener("error", onError);
+      window.removeEventListener("unhandledrejection", onRejection);
+      resources?.disconnect();
+      lines.length = 0;
+    }
+  };
+}
+function safeUrl(value) {
+  try {
+    const url = new URL(value, location.href);
+    return `${url.origin}${url.pathname}`;
+  } catch {
+    return "[invalid URL]";
+  }
+}
+function sanitizeDiagnostic(value) {
+  return value.replace(/https?:\/\/[^\s<>"']+/g, (url) => safeUrl(url)).replace(/\bBearer\s+[^\s,;]+/gi, "Bearer [redacted]").replace(
+    /\b(token|password|secret|authorization|api[_-]?key)\s*[:=]\s*[^\s,;]+/gi,
+    "$1=[redacted]"
+  ).replace(/\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/g, "[redacted token]");
+}
+
+// src/connection/remote-control/screen-sharing.ts
+function createScreenSharing() {
+  let stream = null;
+  let diagnostics = null;
+  let generation = 0;
+  const stop = () => {
+    generation++;
+    const previous = stream;
+    stream = null;
+    previous?.getTracks().forEach((track) => track.stop());
+    diagnostics?.stop();
+    diagnostics = null;
+  };
+  return {
+    get active() {
+      return !!stream?.getVideoTracks().some((track) => track.readyState === "live");
+    },
+    async start(onEnded) {
+      const token = ++generation;
+      if (!navigator.mediaDevices?.getDisplayMedia)
+        throw new ScreenCaptureError(
+          "unsupported",
+          "Screen sharing is unavailable in this browser."
+        );
+      const next = await navigator.mediaDevices.getDisplayMedia({
+        video: { displaySurface: "browser" },
+        audio: false,
+        preferCurrentTab: true,
+        selfBrowserSurface: "include",
+        surfaceSwitching: "exclude"
+      });
+      if (token !== generation) {
+        next.getTracks().forEach((track) => track.stop());
+        throw new ScreenCaptureError("cancelled", "Sharing stopped.");
+      }
+      stream = next;
+      diagnostics = collectBrowserDiagnostics();
+      next.getVideoTracks().forEach(
+        (track) => track.addEventListener(
+          "ended",
+          () => {
+            if (stream === next) {
+              stop();
+              onEnded();
+            }
+          },
+          { once: true }
+        )
+      );
+    },
+    async frame() {
+      if (!stream) throw new ScreenCaptureError("cancelled", "Sharing stopped.");
+      const token = generation;
+      const blob = await grabFrame(stream);
+      if (token !== generation) throw new ScreenCaptureError("cancelled", "Sharing stopped.");
+      if (blob.size > 8 * 1024 * 1024)
+        throw new ScreenCaptureError(
+          "failed",
+          "The shared screen image is too large. Share a smaller window."
+        );
+      const screenshot_png = await new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onload = () => resolve(String(reader.result).split(",")[1]);
+        reader.onerror = () => reject(new Error("Could not read the screen frame."));
+        reader.readAsDataURL(blob);
+      });
+      if (token !== generation) throw new ScreenCaptureError("cancelled", "Sharing stopped.");
+      return { screenshot_png, diagnostics: diagnostics?.snapshot() ?? "" };
+    },
+    stop
+  };
+}
+
+// src/connection/remote-control/remoteControl.ts
+var screenRuntimes = /* @__PURE__ */ new WeakMap();
+function screenRuntime(session) {
+  let runtime = screenRuntimes.get(session);
+  if (!runtime) {
+    runtime = { sharing: createScreenSharing(), generation: 0, setup: "" };
+    screenRuntimes.set(session, runtime);
+  }
+  return runtime;
+}
+function stopScreen(session) {
+  const runtime = screenRuntimes.get(session);
+  if (!runtime) return;
+  runtime.generation++;
+  runtime.sharing.stop();
+  runtime.setup = "";
+  const actions = react.remoteControlActions(session);
+  if (react.remoteControlStateOf(session.getState()).sharing) actions.setSharing(false);
+}
+function createRemoteControl(session, guided, screenTransport) {
   const actions = react.remoteControlActions(session);
   const state = () => react.remoteControlStateOf(session.getState());
+  const runtime = screenRuntime(session);
+  const reply = async (req, status) => {
+    if ((req.screenRequestId || req.actionRequestId) && screenTransport) {
+      await screenTransport.reply(req.screenRequestId || req.actionRequestId, { status }).catch(() => {
+      });
+    }
+  };
+  const disable = () => {
+    const pending = state().pending;
+    if (pending) void reply(pending, "stopped");
+    stopScreen(session);
+    actions.setEnabled(false);
+    chunkORELHENJ_cjs.cancelGuidedRun();
+  };
+  const inspect = async (req, keepSharing) => {
+    if (!req.screenRequestId || !screenTransport) return;
+    const workspace = session.getState().workspaceId;
+    if (workspace !== req.workspaceExtId) {
+      await reply(req, "unavailable");
+      return;
+    }
+    const token = runtime.generation;
+    const current = () => token === runtime.generation && session.getState().workspaceId === workspace;
+    actions.setControllingAgent({ name: req.agentName, extId: req.agentExtId });
+    try {
+      if (!runtime.sharing.active) {
+        await runtime.sharing.start(disable);
+        if (!current()) {
+          runtime.sharing.stop();
+          await reply(req, "stopped");
+          return;
+        }
+        actions.setSharing(true);
+        if (screenTransport.diagnose)
+          runtime.setup = await screenTransport.diagnose().catch(() => "Setup checks unavailable.");
+      }
+      if (!current()) {
+        await reply(req, "stopped");
+        return;
+      }
+      const frame = await runtime.sharing.frame();
+      if (!current()) {
+        await reply(req, "stopped");
+        return;
+      }
+      await screenTransport.reply(req.screenRequestId, {
+        status: "captured",
+        ...frame,
+        diagnostics: `${frame.diagnostics}
+${runtime.setup}`.slice(0, 24e3)
+      });
+    } catch {
+      await reply(req, current() ? "unavailable" : "stopped");
+      if (current()) disable();
+    } finally {
+      if (current()) {
+        actions.setControllingAgent(null);
+        if (!keepSharing) disable();
+      }
+    }
+  };
   const resolveRun = (req) => {
     if (req.steps && req.steps.length > 0) return req.steps;
     if (req.sequenceId && guided.isSequenceId(req.sequenceId)) return req.sequenceId;
     return null;
   };
-  const runRemoteRequest = async (req) => {
+  const runRemoteRequest = async (req, keepSharing = state().enabled) => {
+    if (req.screenRequestId) {
+      await inspect(req, keepSharing);
+      return;
+    }
     const run = resolveRun(req);
     if (!run) return;
+    const token = runtime.generation;
     actions.setControllingAgent({ name: req.agentName, extId: req.agentExtId });
     try {
       await guided.run(run, { remote: true });
+      if (req.actionRequestId)
+        await reply(req, token === runtime.generation ? "action_finished" : "stopped");
+    } catch {
+      await reply(req, "unavailable");
     } finally {
       const current = state().controllingAgent;
       if (current && current.name === req.agentName && current.extId === req.agentExtId) {
@@ -94,31 +427,49 @@ function createRemoteControl(session, guided) {
       }
       const req = react.toRemoteControlRequest(msg, guided.isSequenceId);
       if (!req) return;
-      if (state().enabled) {
+      if ((req.screenRequestId || req.actionRequestId) && (!screenTransport || session.getState().workspaceId !== req.workspaceExtId)) {
+        void reply(req, "unavailable");
+        return;
+      }
+      if (state().enabled && (!req.screenRequestId || runtime.sharing.active)) {
         client.logger.info("[RemoteControl] Enabled \u2014 running requested action from", req.agentName);
         void runRemoteRequest(req);
         return;
       }
       client.logger.info("[RemoteControl] Consent required \u2014 prompting for", req.agentName);
+      if (state().pending) void reply(state().pending, "denied");
       actions.request(req);
     },
     grantAndRun(opts) {
       const pending = state().pending;
+      const keepSharing = opts.forSession || state().enabled;
       actions.grant(opts);
-      if (pending) void runRemoteRequest(pending);
+      if (pending) void runRemoteRequest(pending, keepSharing);
     },
-    deny: () => actions.deny(),
-    disable() {
-      actions.setEnabled(false);
-      chunkORELHENJ_cjs.cancelGuidedRun();
+    deny: () => {
+      const pending = state().pending;
+      actions.deny();
+      if (pending) void reply(pending, "denied");
     },
+    disable,
     enable: () => actions.setEnabled(true)
   };
 }
 function useRemoteControlActions() {
   const session = react.useArbiSessionStore();
   const guided = chunkORELHENJ_cjs.useGuidedRuns();
-  return React6.useMemo(() => createRemoteControl(session, guided), [session, guided]);
+  const { arbi } = react.useArbiHost();
+  return React6.useMemo(
+    () => createRemoteControl(
+      session,
+      guided,
+      arbi ? {
+        reply: (id, result) => arbi.remoteControl.replyScreen(id, result),
+        diagnose: async () => JSON.stringify(await arbi.diagnose())
+      } : void 0
+    ),
+    [session, guided, arbi]
+  );
 }
 function useRemoteControlSessionReset() {
   const session = react.useArbiSessionStore();
@@ -126,6 +477,7 @@ function useRemoteControlSessionReset() {
   const userId = react.useArbiSession().user?.external_id ?? null;
   React6.useEffect(() => {
     const reset = () => {
+      stopScreen(session);
       react.remoteControlActions(session).reset();
       chunkORELHENJ_cjs.cancelGuidedRun();
     };
@@ -141,6 +493,7 @@ function useRemoteControlSessionReset() {
   React6.useEffect(() => {
     if (lastUser.current === userId) return;
     lastUser.current = userId;
+    stopScreen(session);
     react.remoteControlActions(session).reset();
     chunkORELHENJ_cjs.cancelGuidedRun();
   }, [userId, session]);
@@ -149,6 +502,16 @@ function useRemoteControlHandlers() {
   useRemoteControlSessionReset();
   const remote = useRemoteControlActions();
   const { remoteControl } = chunkORELHENJ_cjs.useGuidedRuns();
+  const session = react.useArbiSessionStore();
+  const workspaceId = react.useArbiSessionState((s) => s.workspaceId);
+  React6.useEffect(
+    () => () => {
+      stopScreen(session);
+      react.remoteControlActions(session).setEnabled(false);
+      chunkORELHENJ_cjs.cancelGuidedRun();
+    },
+    [session, workspaceId]
+  );
   return React6.useMemo(
     () => remoteControl ? {
       remote_control: (message) => remote.handleMessage(message)
@@ -5221,8 +5584,12 @@ exports.PENDING_RECOVERY_KEY = PENDING_RECOVERY_KEY;
 exports.PREMIUM_TIER_TAG = PREMIUM_TIER_TAG;
 exports.RunningSubagents = RunningSubagents;
 exports.STANDARD_TIER_TAG = STANDARD_TIER_TAG;
+exports.ScreenCaptureError = ScreenCaptureError;
 exports.WorkflowStepMessage = WorkflowStepMessage;
 exports.backUpOnSignup = backUpOnSignup;
+exports.canCaptureScreen = canCaptureScreen;
+exports.canvasToBlob = canvasToBlob;
+exports.captureCurrentTab = captureCurrentTab;
 exports.completeSsoSignIn = completeSsoSignIn;
 exports.createRemoteControl = createRemoteControl;
 exports.defaultHost = defaultHost;
@@ -5240,5 +5607,5 @@ exports.useRemoteControlHandlers = useRemoteControlHandlers;
 exports.useRemoteControlSessionReset = useRemoteControlSessionReset;
 exports.useSsoSignIn = useSsoSignIn;
 exports.useWorkspaceDocTitles = useWorkspaceDocTitles;
-//# sourceMappingURL=chunk-OHHKBURG.cjs.map
-//# sourceMappingURL=chunk-OHHKBURG.cjs.map
+//# sourceMappingURL=chunk-2SU37RZA.cjs.map
+//# sourceMappingURL=chunk-2SU37RZA.cjs.map