@xopcai/xopc 0.0.367 → 0.0.369

package/dist/browser-ext/dist/background.js

@@ -1,4 +1,343 @@
-import { n as endpointToolContentSchema, E as ENDPOINT_PROTOCOL_VERSION, g as canonicalJson, T as TAB_BINDING_PREFIX, h as captureContextMenuSelection, P as PENDING_CONTEXT_KEY, H as t, y as readProfile, z as registerBrowserEndpoint, q as getAccessProfile, a as RealtimeClient, j as createBrowserEndpointHello, p as gatewayFetch, R as REALTIME_PROTOCOL_VERSION } from './assets/auth-beGtbLPS.js';
+import { y as readProfile, p as gatewayFetch, n as endpointToolContentSchema, E as ENDPOINT_PROTOCOL_VERSION, g as canonicalJson, T as TAB_BINDING_PREFIX, h as captureContextMenuSelection, P as PENDING_CONTEXT_KEY, H as t, z as registerBrowserEndpoint, q as getAccessProfile, a as RealtimeClient, j as createBrowserEndpointHello, R as REALTIME_PROTOCOL_VERSION } from './assets/page-context-BeworyNB.js';
+
+const LOG_COLORS = {
+  debug: "color: #888",
+  info: "color: #3b82f6",
+  warn: "color: #f59e0b",
+  error: "color: #ef4444"
+};
+function createLogger(prefix) {
+  function log(level, message, data) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().slice(11, 23);
+    const formatted = `[${timestamp}] [${prefix}] ${message}`;
+    if (data && Object.keys(data).length > 0) {
+      console[level](`%c${formatted}`, LOG_COLORS[level], data);
+    } else {
+      console[level](`%c${formatted}`, LOG_COLORS[level]);
+    }
+  }
+  return {
+    debug: (msg, data) => log("debug", msg, data),
+    info: (msg, data) => log("info", msg, data),
+    warn: (msg, data) => log("warn", msg, data),
+    error: (msg, data) => log("error", msg, data)
+  };
+}
+
+const log$2 = createLogger("SessionManager");
+const XOPC_TAB_GROUP_TITLE = "xopc";
+const busySessions = /* @__PURE__ */ new Set();
+function holdAutomationSession(id) {
+  busySessions.add(id);
+}
+function releaseAutomationSession(id) {
+  busySessions.delete(id);
+  resetWindowIdleTimer(id);
+}
+const automationSessions = /* @__PURE__ */ new Map();
+const WINDOW_IDLE_TIMEOUT = 12e4;
+const DEFAULT_WORKSPACE = "default";
+function resetWindowIdleTimer(workspace = DEFAULT_WORKSPACE) {
+  const session = automationSessions.get(workspace);
+  if (!session) return;
+  if (session.idleTimer) clearTimeout(session.idleTimer);
+  session.idleDeadlineAt = Date.now() + WINDOW_IDLE_TIMEOUT;
+  session.idleTimer = setTimeout(async () => {
+    const current = automationSessions.get(workspace);
+    if (!current) return;
+    if (busySessions.has(workspace)) {
+      resetWindowIdleTimer(workspace);
+      return;
+    }
+    try {
+      const tabs = await chrome.tabs.query({ groupId: current.groupId });
+      for (const t of tabs) {
+        if (t.id != null) await chrome.tabs.remove(t.id).catch(() => {
+        });
+      }
+    } catch {
+    }
+    automationSessions.delete(workspace);
+    log$2.info("Automation tab group cleared due to idle timeout", { workspace });
+  }, WINDOW_IDLE_TIMEOUT);
+}
+async function waitForTabLoad(tabId, timeoutMs = 3e4) {
+  return new Promise((resolve) => {
+    const timeout = setTimeout(resolve, timeoutMs);
+    const listener = (id, info) => {
+      if (id === tabId && info.status === "complete") {
+        clearTimeout(timeout);
+        chrome.tabs.onUpdated.removeListener(listener);
+        resolve();
+      }
+    };
+    chrome.tabs.onUpdated.addListener(listener);
+    chrome.tabs.get(tabId).then((tab) => {
+      if (tab.status === "complete") {
+        clearTimeout(timeout);
+        chrome.tabs.onUpdated.removeListener(listener);
+        resolve();
+      }
+    }).catch(() => {
+      clearTimeout(timeout);
+      chrome.tabs.onUpdated.removeListener(listener);
+      resolve();
+    });
+  });
+}
+async function resolveTargetWindowId() {
+  const w = await chrome.windows.getLastFocused({ windowTypes: ["normal"] });
+  if (w?.id != null) return w.id;
+  const all = await chrome.windows.getAll({ windowTypes: ["normal"] });
+  const first = all.find((x) => x.id != null);
+  if (first?.id != null) return first.id;
+  throw new Error("No normal browser window — open a Chrome window, then run automation again.");
+}
+async function getOrCreateAutomationWindow(workspace = DEFAULT_WORKSPACE) {
+  const existing = automationSessions.get(workspace);
+  if (existing) {
+    try {
+      await chrome.tabGroups.get(existing.groupId);
+      const tabsInGroup = await chrome.tabs.query({ groupId: existing.groupId });
+      if (tabsInGroup.length === 0) throw new Error("empty group");
+      existing.tabIds = tabsInGroup.map((t) => t.id).filter(Boolean);
+      const active = tabsInGroup.find((t) => t.active);
+      existing.activeTabId = active?.id ?? tabsInGroup[0]?.id ?? null;
+      resetWindowIdleTimer(workspace);
+      return existing;
+    } catch {
+      automationSessions.delete(workspace);
+    }
+  }
+  const windowId = await resolveTargetWindowId();
+  const tab = await chrome.tabs.create({
+    windowId,
+    url: "about:blank",
+    active: false
+  });
+  if (tab.id == null) throw new Error("Failed to create automation tab");
+  const groupId = await chrome.tabs.group({
+    tabIds: [tab.id],
+    createProperties: { windowId }
+  });
+  await chrome.tabGroups.update(groupId, {
+    title: XOPC_TAB_GROUP_TITLE,
+    collapsed: false,
+    color: "blue"
+  });
+  const session = {
+    windowId,
+    groupId,
+    tabIds: [tab.id],
+    activeTabId: tab.id,
+    idleTimer: null,
+    idleDeadlineAt: 0,
+    createdAt: Date.now()
+  };
+  automationSessions.set(workspace, session);
+  resetWindowIdleTimer(workspace);
+  log$2.info("Created automation tab group", { workspace, windowId, groupId, tabId: tab.id });
+  return session;
+}
+async function getActiveTabId(workspace = DEFAULT_WORKSPACE) {
+  const session = await getOrCreateAutomationWindow(workspace);
+  if (session.activeTabId != null) {
+    const ok = await chrome.tabs.get(session.activeTabId).catch(() => null);
+    if (ok) return session.activeTabId;
+  }
+  const tabs = await chrome.tabs.query({ groupId: session.groupId });
+  const tabId = tabs.find((t) => t.active)?.id ?? tabs[0]?.id;
+  if (tabId == null) throw new Error("No tab in xopc automation group");
+  session.activeTabId = tabId;
+  return tabId;
+}
+async function addTabToAutomationGroup(url, workspace = DEFAULT_WORKSPACE) {
+  const session = await getOrCreateAutomationWindow(workspace);
+  const tab = await chrome.tabs.create({
+    windowId: session.windowId,
+    url,
+    active: false
+  });
+  if (tab.id == null) throw new Error("Failed to create tab");
+  const inGroup = await chrome.tabs.query({ groupId: session.groupId });
+  const mergedIds = [...inGroup.map((t) => t.id).filter(Boolean), tab.id];
+  await chrome.tabs.group({ tabIds: mergedIds, groupId: session.groupId });
+  session.activeTabId = tab.id;
+  session.tabIds = mergedIds;
+  resetWindowIdleTimer(workspace);
+  return { tabId: tab.id, session };
+}
+async function closeSession(workspace = DEFAULT_WORKSPACE) {
+  const session = automationSessions.get(workspace);
+  if (!session) return;
+  if (session.idleTimer) clearTimeout(session.idleTimer);
+  const tabs = await chrome.tabs.query({ groupId: session.groupId }).catch(() => []);
+  for (const t of tabs) {
+    if (t.id != null) await chrome.tabs.remove(t.id).catch(() => {
+    });
+  }
+  automationSessions.delete(workspace);
+  log$2.info("Closed automation session", { workspace });
+}
+
+async function browserDom(input) {
+  const root = globalThis;
+  const doc = root.document;
+  const normalize = (value) => String(value || "").trim().replace(/\s+/g, " ").slice(0, 240);
+  const sensitive = (element) => element.type === "password" || element.type === "file" || /cc-|one-time-code|transaction-|password|token|secret|otp|cvv|cvc|card.?number|验证码|密码|银行卡|卡号/i.test([
+    element.autocomplete,
+    element.name,
+    element.id,
+    element.getAttribute("aria-label"),
+    name(element)
+  ].join(" "));
+  const role = (element) => element.getAttribute("role") || {
+    A: "link",
+    BUTTON: "button",
+    SUMMARY: "button",
+    SELECT: "combobox",
+    TEXTAREA: "textbox",
+    FORM: "form",
+    FIELDSET: "group",
+    SECTION: "region"
+  }[element.tagName] || (element.tagName === "INPUT" ? element.type === "checkbox" ? "checkbox" : element.type === "radio" ? "radio" : ["submit", "button", "reset"].includes(element.type) ? "button" : "textbox" : "text");
+  const name = (element) => normalize(
+    (element.getAttribute("aria-labelledby") || "").split(/\s+/).map((id) => doc.getElementById(id)?.textContent || "").join(" ") || element.getAttribute("aria-label") || element.labels?.[0]?.textContent || (element.tagName === "FIELDSET" ? element.querySelector("legend")?.textContent : "") || element.getAttribute("alt") || element.getAttribute("placeholder") || (["submit", "button", "reset"].includes(element.type) ? element.value : "") || element.innerText || element.getAttribute("title") || ""
+  );
+  const describe = (element) => {
+    const container = element.parentElement?.closest('form,fieldset,section,[role="region"],[role="group"],[role="dialog"]');
+    return {
+      role: role(element),
+      name: name(element),
+      ...element.getAttribute("data-testid") ? { testId: element.getAttribute("data-testid") } : {},
+      ...container && name(container) ? { scope: { role: role(container), name: name(container) } } : {}
+    };
+  };
+  const selector = 'a[href],button,input:not([type="hidden"]),textarea,select,summary,[role],[data-testid],label,p,span,h1,h2,h3,td,output';
+  if (input.operation === "resolve") {
+    const target = input.target;
+    const matches = Array.from(doc.querySelectorAll(selector)).filter((element2) => {
+      const rect = element2.getBoundingClientRect();
+      const style = root.getComputedStyle(element2);
+      if (!rect.width || !rect.height || style.display === "none" || style.visibility === "hidden") return false;
+      const descriptor = describe(element2);
+      return descriptor.role === target.role && (!target.name || descriptor.name === target.name) && (!target.nameIncludes || descriptor.name?.includes(target.nameIncludes)) && (!target.testId || descriptor.testId === target.testId) && (!target.scope || descriptor.scope?.role === target.scope.role && descriptor.scope?.name === target.scope.name);
+    });
+    if (matches.length !== 1) return { matches: matches.length };
+    const element = matches[0];
+    const ref = `xopc-e${++root.__xopcRefCounter || (root.__xopcRefCounter = 1)}`;
+    element.setAttribute("data-xopc-ref", ref);
+    return { matches: 1, node: {
+      ref,
+      role: role(element),
+      name: name(element),
+      value: !sensitive(element) && "value" in element ? String(element.value).slice(0, 4096) : void 0,
+      description: !sensitive(element) ? normalize(element.textContent) : void 0,
+      href: element.tagName === "A" ? element.href : void 0,
+      states: [sensitive(element) ? "sensitive" : "", element.disabled ? "disabled" : "", element.checked ? "checked" : "", ["BUTTON", "INPUT"].includes(element.tagName) && element.type === "submit" ? "submit" : ""].filter(Boolean)
+    } };
+  }
+  const prior = root.__xopcRecorder;
+  if (input.operation === "record" && prior?.recordingId === input.recordingId && prior?.generation === input.generation) return { recording: true };
+  if (prior) {
+    await prior.stop();
+    delete root.__xopcRecorder;
+  }
+  if (input.operation === "stop") return { stopped: true };
+  let sourceSeq = 0;
+  const pending = /* @__PURE__ */ new Set();
+  const dirty = /* @__PURE__ */ new Set();
+  const lastValues = /* @__PURE__ */ new WeakMap();
+  const listeners = [];
+  const cleanUrl = () => {
+    const url = new URL(root.location.href);
+    url.username = "";
+    url.password = "";
+    url.hash = "";
+    for (const key of [...url.searchParams.keys()]) if (/token|secret|password|key|code/i.test(key)) url.searchParams.delete(key);
+    return url.toString();
+  };
+  const documentId = `${root.performance.timeOrigin}:${input.generation}`;
+  let failed = false;
+  let ended = false;
+  let enterTarget;
+  let enterAt = 0;
+  const emit = (event) => {
+    const task = root.chrome.runtime.sendMessage({
+      type: "browser/recording-event",
+      recordingId: input.recordingId,
+      generation: input.generation,
+      event: { ...event, id: root.crypto.randomUUID(), sourceSeq: ++sourceSeq, documentId, url: cleanUrl() }
+    }).then((ack) => {
+      if (!ack?.ok) failed = true;
+    }).catch(() => {
+      failed = true;
+    });
+    pending.add(task);
+    void task.finally(() => pending.delete(task));
+  };
+  const flush = (element) => {
+    if (!dirty.delete(element) || sensitive(element)) return;
+    const value = String(element.value || "").slice(0, 4096);
+    if (lastValues.get(element) === value) return;
+    lastValues.set(element, value);
+    emit({ action: element.tagName === "SELECT" ? "select" : "fill", target: describe(element), value });
+  };
+  const listen = (type, handler) => {
+    listeners.push([type, handler]);
+    (type === "pagehide" ? root : doc).addEventListener(type, handler, true);
+  };
+  listen("input", (event) => {
+    if (event.isTrusted && !sensitive(event.target) && !["checkbox", "radio"].includes(event.target.type) && "value" in event.target) dirty.add(event.target);
+  });
+  listen("dragstart", (event) => {
+    if (event.isTrusted) emit({ action: "unsupported", value: "Drag actions are not supported by the recorder." });
+  });
+  listen("change", (event) => {
+    if (!event.isTrusted || sensitive(event.target)) return;
+    if (["checkbox", "radio"].includes(event.target.type)) emit({ action: "check", target: describe(event.target), checked: !!event.target.checked });
+    else {
+      dirty.add(event.target);
+      flush(event.target);
+    }
+  });
+  listen("focusout", (event) => flush(event.target));
+  listen("click", (event) => {
+    if (!event.isTrusted) return;
+    for (const element2 of dirty) flush(element2);
+    const element = event.target.closest('a[href],button,summary,[role="button"],input[type="submit"],input[type="button"]');
+    if (element && event.detail === 0 && Date.now() - enterAt < 500 && (element === enterTarget || element.form && element.form === enterTarget?.form)) return;
+    if (element && !sensitive(element)) emit({ action: "click", target: describe(element) });
+    else if (event.target.closest('canvas,[contenteditable="true"],input[type="file"]')) emit({ action: "unsupported", value: "Canvas, rich text and file actions require an assistant to complete the workflow." });
+  });
+  listen("pagehide", () => {
+    for (const element of dirty) flush(element);
+    emit({ action: "checkpoint" });
+    ended = true;
+    for (const [type, handler] of listeners) (type === "pagehide" ? root : doc).removeEventListener(type, handler, true);
+  });
+  listen("keydown", (event) => {
+    if (!event.isTrusted || event.isComposing || sensitive(event.target) || !["Enter", "Escape"].includes(event.key)) return;
+    flush(event.target);
+    if (event.key === "Enter") {
+      enterTarget = event.target;
+      enterAt = Date.now();
+    }
+    emit({ action: "press", target: describe(event.target), key: event.key });
+  });
+  root.__xopcRecorder = { recordingId: input.recordingId, generation: input.generation, stop: async () => {
+    for (const [type, handler] of listeners) (type === "pagehide" ? root : doc).removeEventListener(type, handler, true);
+    for (const element of dirty) flush(element);
+    if (!ended) {
+      emit({ action: "checkpoint" });
+      ended = true;
+    }
+    await Promise.all([...pending]);
+    if (failed) throw new Error("Recording events could not be saved.");
+  } };
+  emit({ action: "navigate" });
+  return { recording: true, documentId };
+}
 
 const BROWSER_EXTENSION_PROTOCOL_VERSION = 5;
 const BROWSER_CONTROL_ENDPOINT_TOOL_NAME = "browser.control";
@@ -44,6 +383,285 @@ const BROWSER_CONTROL_ENDPOINT_DESCRIPTOR = {
   idempotent: false,
   resultKinds: ["json"]
 };
+const BROWSER_RECORDING_ENDPOINT_INPUT_SCHEMA = {
+  type: "object",
+  additionalProperties: false,
+  required: ["operation"],
+  properties: { operation: { type: "string", enum: ["start", "pause", "resume", "finish", "status"] } }
+};
+const BROWSER_RECORDING_ENDPOINT_DESCRIPTOR = {
+  ...BROWSER_CONTROL_ENDPOINT_DESCRIPTOR,
+  name: "browser.recording",
+  title: "Browser workflow recording",
+  description: "Record a workflow in the active browser tab and save it as an automation.",
+  inputSchema: BROWSER_RECORDING_ENDPOINT_INPUT_SCHEMA,
+  maxConcurrency: 1
+};
+
+function open() {
+  return new Promise((resolve, reject) => {
+    const request2 = indexedDB.open("xopc-browser-recordings", 1);
+    request2.onupgradeneeded = () => {
+      request2.result.createObjectStore("sessions", { keyPath: "id" });
+      request2.result.createObjectStore("events", { keyPath: ["recordingId", "seq"] });
+    };
+    request2.onsuccess = () => resolve(request2.result);
+    request2.onerror = () => reject(request2.error);
+  });
+}
+function request(value) {
+  return new Promise((resolve, reject) => {
+    value.onsuccess = () => resolve(value.result);
+    value.onerror = () => reject(value.error);
+  });
+}
+async function transaction(mode, work) {
+  const db = await open();
+  const tx = db.transaction(["sessions", "events"], mode);
+  const done = new Promise((resolve, reject) => {
+    tx.oncomplete = () => resolve();
+    tx.onerror = () => reject(tx.error);
+    tx.onabort = () => reject(tx.error);
+  });
+  try {
+    const result = await work(tx);
+    await done;
+    return result;
+  } catch (error) {
+    try {
+      tx.abort();
+    } catch {
+    }
+    await done.catch(() => {
+    });
+    throw error;
+  } finally {
+    db.close();
+  }
+}
+function recordings() {
+  return transaction("readonly", async (tx) => {
+    const rows = await request(tx.objectStore("sessions").getAll());
+    return rows.sort((a, b) => a.createdAtMs - b.createdAtMs);
+  });
+}
+function saveRecording(session) {
+  return transaction("readwrite", async (tx) => {
+    await request(tx.objectStore("sessions").put(session));
+  });
+}
+function recordingEvents(id, after = 0) {
+  return transaction("readonly", async (tx) => {
+    const rows = await request(tx.objectStore("events").getAll(IDBKeyRange.bound([id, after + 1], [id, Number.MAX_SAFE_INTEGER]), 100));
+    return rows.map(({ recordingId: _recordingId, ...event }) => event);
+  });
+}
+function appendRecordingEvent(id, generation, tabId, event) {
+  return transaction("readwrite", async (tx) => {
+    const sessions = tx.objectStore("sessions");
+    const session = await request(sessions.get(id));
+    if (!session || session.state !== "recording" || session.generation !== generation || session.tabId !== tabId) throw new Error("Recording is no longer active.");
+    if (session.count >= 1e4) throw new Error("Recording event limit reached. Finish this recording.");
+    const bytes = session.bytes + new TextEncoder().encode(JSON.stringify(event)).length;
+    if (bytes > 20 * 1024 * 1024) throw new Error("Recording storage limit reached.");
+    const seq = session.count + 1;
+    await request(tx.objectStore("events").add({ ...event, recordingId: id, seq }));
+    await request(sessions.put({ ...session, count: seq, bytes }));
+  });
+}
+function deleteRecordingEvents(id, through) {
+  return transaction("readwrite", async (tx) => {
+    await request(tx.objectStore("events").delete(IDBKeyRange.bound([id, 1], [id, through])));
+  });
+}
+function patchRecording(id, patch) {
+  return transaction("readwrite", async (tx) => {
+    const store = tx.objectStore("sessions");
+    const current = await request(store.get(id));
+    if (!current) throw new Error("Recording not found.");
+    await request(store.put({ ...current, ...patch }));
+  });
+}
+
+let uploadTask;
+let resyncRequested = false;
+let controlTask;
+let claim;
+function setRecordingClaim(value) {
+  claim = value;
+  void syncRecordings();
+}
+async function inject(tabId, input) {
+  const result = await chrome.scripting.executeScript({ target: { tabId }, func: browserDom, args: [input] });
+  return result[0]?.result;
+}
+async function recordingCommand(operation, tabId) {
+  if (operation === "status") return recordings();
+  if (controlTask) throw new Error("A recording action is already in progress.");
+  controlTask = control(operation, tabId);
+  try {
+    return await controlTask;
+  } finally {
+    controlTask = void 0;
+  }
+}
+async function control(operation, tabId) {
+  const all = await recordings();
+  const active = all.find((item) => item.state === "recording" || item.state === "paused");
+  if (operation === "start") {
+    if (active) return active;
+    const profile = await readProfile();
+    if (!profile) throw new Error("Connect to your Gateway first.");
+    if (tabId !== void 0 && (!Number.isInteger(tabId) || tabId <= 0)) throw new Error("Invalid recording tab.");
+    const tab = tabId !== void 0 ? await chrome.tabs.get(tabId) : (await chrome.tabs.query({ active: true, lastFocusedWindow: true }))[0];
+    if (!tab?.id || !tab.url?.match(/^https?:\/\//)) throw new Error("RECORDING_PAGE_UNAVAILABLE");
+    if ([...automationSessions.values()].some((session3) => session3.tabIds.includes(tab.id))) throw new Error("This page belongs to a running browser task. Select your workflow page to record.");
+    const session2 = {
+      id: crypto.randomUUID(),
+      state: "recording",
+      tabId: tab.id,
+      gatewayId: profile.gatewayId,
+      deviceId: profile.deviceId,
+      generation: 1,
+      count: 0,
+      ack: 0,
+      bytes: 0,
+      createdAtMs: Date.now()
+    };
+    await saveRecording(session2);
+    try {
+      await inject(tab.id, { operation: "record", recordingId: session2.id, generation: session2.generation });
+    } catch (error) {
+      await patchRecording(session2.id, { state: "interrupted", error: String(error) });
+      throw error;
+    }
+    await chrome.action.setBadgeText({ text: "REC" });
+    return session2;
+  }
+  if (!active) throw new Error("There is no active recording.");
+  if (operation === "resume") {
+    if (active.state !== "paused") return active;
+    const session2 = { ...active, state: "recording", generation: active.generation + 1 };
+    await patchRecording(session2.id, { state: session2.state, generation: session2.generation });
+    try {
+      await inject(session2.tabId, { operation: "record", recordingId: session2.id, generation: session2.generation });
+    } catch (error) {
+      await patchRecording(session2.id, { state: "interrupted", error: String(error) });
+      throw error;
+    }
+    await chrome.action.setBadgeText({ text: "REC" });
+    return session2;
+  }
+  if (operation !== "pause" && operation !== "finish") throw new Error("Unknown recording operation.");
+  try {
+    await inject(active.tabId, { operation: "stop" });
+  } catch (error) {
+    const current2 = (await recordings()).find((item) => item.id === active.id);
+    await patchRecording(current2.id, { state: "interrupted", error: `Recording may be incomplete: ${String(error)}` });
+    throw error;
+  }
+  const current = (await recordings()).find((item) => item.id === active.id);
+  const session = { ...current, state: operation === "pause" ? "paused" : "stopped" };
+  await patchRecording(session.id, { state: session.state });
+  await chrome.action.setBadgeText({ text: operation === "pause" ? "Ⅱ" : "" });
+  void syncRecordings();
+  return session;
+}
+async function acceptRecordingEvent(message, sender) {
+  if (sender.id !== chrome.runtime.id || !sender.tab?.id || sender.frameId !== 0) throw new Error("Invalid recording source.");
+  const event = message.event;
+  if (!event || JSON.stringify(event).length > 16384 || !["navigate", "click", "fill", "select", "check", "press", "checkpoint", "unsupported"].includes(event.action)) throw new Error("Invalid recording event.");
+  try {
+    await appendRecordingEvent(message.recordingId, message.generation, sender.tab.id, event);
+  } catch (error) {
+    if (/limit reached/.test(String(error))) {
+      await patchRecording(message.recordingId, { state: "interrupted", error: String(error) });
+      void inject(sender.tab.id, { operation: "stop" }).catch(() => void 0);
+      await chrome.action.setBadgeText({ text: "" });
+    }
+    throw error;
+  }
+  void syncRecordings();
+}
+function syncRecordings() {
+  if (uploadTask) {
+    resyncRequested = true;
+    return uploadTask;
+  }
+  uploadTask = upload().catch(() => void 0).finally(() => {
+    uploadTask = void 0;
+    if (resyncRequested) {
+      resyncRequested = false;
+      void syncRecordings();
+    }
+  });
+  return uploadTask;
+}
+async function upload() {
+  if (!claim) return;
+  const profile = await readProfile();
+  if (!profile) return;
+  for (const session of await recordings()) {
+    if (session.gatewayId !== profile.gatewayId || session.deviceId !== profile.deviceId || session.automationId) continue;
+    try {
+      const post = async (operation, body) => {
+        const response = await gatewayFetch(`/api/browser/recordings/${session.id}/${operation}`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json", "x-endpoint-id": claim.endpointId, "x-endpoint-claim": claim.token },
+          body: JSON.stringify(body)
+        }, profile);
+        const data = await response.json();
+        if (!response.ok) throw new Error(data.error || "Recording could not be synchronized.");
+        return data;
+      };
+      let ack = session.ack;
+      let events = await recordingEvents(session.id, ack);
+      while (events.length) {
+        while (JSON.stringify({ events }).length > 24e4) events.pop();
+        const data = await post("events", { events });
+        if (data.ackThrough <= ack) throw new Error("Recording synchronization did not advance.");
+        ack = data.ackThrough;
+        const current2 = (await recordings()).find((item) => item.id === session.id);
+        await patchRecording(current2.id, { ack, error: void 0 });
+        events = await recordingEvents(session.id, ack);
+      }
+      const current = (await recordings()).find((item) => item.id === session.id);
+      if (current.state === "stopped" && current.count === ack) {
+        const data = await post("finish", { finalSeq: current.count });
+        await patchRecording(current.id, { ack, automationId: data.automation.id, error: void 0 });
+        await deleteRecordingEvents(session.id, current.count);
+      }
+    } catch (error) {
+      const current = (await recordings()).find((item) => item.id === session.id);
+      await patchRecording(current.id, { error: error instanceof Error ? error.message : String(error) });
+    }
+  }
+}
+chrome.tabs.onUpdated.addListener((tabId, info) => {
+  if (info.status !== "complete") return;
+  void recordings().then(async (all) => {
+    const session = all.find((item) => item.tabId === tabId && item.state === "recording");
+    if (!session) return;
+    try {
+      await patchRecording(session.id, { generation: session.generation + 1 });
+      await inject(tabId, { operation: "record", recordingId: session.id, generation: session.generation + 1 });
+    } catch (error) {
+      await patchRecording(session.id, { state: "interrupted", error: String(error) });
+    }
+  });
+});
+chrome.tabs.onRemoved.addListener((tabId) => {
+  void recordings().then(async (all) => {
+    for (const session of all.filter((item) => item.tabId === tabId && ["recording", "paused"].includes(item.state))) {
+      await patchRecording(session.id, { state: "interrupted", error: "The recorded tab was closed. The partial recording is saved locally." });
+    }
+  });
+});
+chrome.runtime.onStartup.addListener(() => {
+  void recordings().then(async (all) => {
+    for (const session of all.filter((item) => item.state === "recording")) await patchRecording(session.id, { state: "interrupted", error: "Browser restarted. The recording was stopped." });
+  });
+});
 
 /**
  * Utilities for hex, bytes, CSPRNG.
@@ -594,31 +1212,7 @@ class EndpointToolHostController {
   }
 }
 
-const LOG_COLORS = {
-  debug: "color: #888",
-  info: "color: #3b82f6",
-  warn: "color: #f59e0b",
-  error: "color: #ef4444"
-};
-function createLogger(prefix) {
-  function log(level, message, data) {
-    const timestamp = (/* @__PURE__ */ new Date()).toISOString().slice(11, 23);
-    const formatted = `[${timestamp}] [${prefix}] ${message}`;
-    if (data && Object.keys(data).length > 0) {
-      console[level](`%c${formatted}`, LOG_COLORS[level], data);
-    } else {
-      console[level](`%c${formatted}`, LOG_COLORS[level]);
-    }
-  }
-  return {
-    debug: (msg, data) => log("debug", msg, data),
-    info: (msg, data) => log("info", msg, data),
-    warn: (msg, data) => log("warn", msg, data),
-    error: (msg, data) => log("error", msg, data)
-  };
-}
-
-const log$2 = createLogger("CDP");
+const log$1 = createLogger("CDP");
 const attached = /* @__PURE__ */ new Set();
 function isDebuggableUrl(url) {
   if (!url) return true;
@@ -660,7 +1254,7 @@ async function ensureAttached(tabId) {
       attached.add(tabId);
       await chrome.debugger.sendCommand({ tabId }, "Runtime.enable", {});
       await chrome.debugger.sendCommand({ tabId }, "Page.enable", {});
-      log$2.debug("Attached to tab", { tabId, attempt });
+      log$1.debug("Attached to tab", { tabId, attempt });
       return;
     } catch (e) {
       lastError = e instanceof Error ? e.message : String(e);
@@ -701,151 +1295,8 @@ chrome.debugger.onDetach.addListener((source) => {
   if (source.tabId) attached.delete(source.tabId);
 });
 
-const log$1 = createLogger("SessionManager");
-const XOPC_TAB_GROUP_TITLE = "xopc";
-const automationSessions = /* @__PURE__ */ new Map();
-const WINDOW_IDLE_TIMEOUT = 12e4;
-const DEFAULT_WORKSPACE = "default";
-function resetWindowIdleTimer(workspace = DEFAULT_WORKSPACE) {
-  const session = automationSessions.get(workspace);
-  if (!session) return;
-  if (session.idleTimer) clearTimeout(session.idleTimer);
-  session.idleDeadlineAt = Date.now() + WINDOW_IDLE_TIMEOUT;
-  session.idleTimer = setTimeout(async () => {
-    const current = automationSessions.get(workspace);
-    if (!current) return;
-    try {
-      const tabs = await chrome.tabs.query({ groupId: current.groupId });
-      for (const t of tabs) {
-        if (t.id != null) await chrome.tabs.remove(t.id).catch(() => {
-        });
-      }
-    } catch {
-    }
-    automationSessions.delete(workspace);
-    log$1.info("Automation tab group cleared due to idle timeout", { workspace });
-  }, WINDOW_IDLE_TIMEOUT);
-}
-async function waitForTabLoad(tabId, timeoutMs = 3e4) {
-  return new Promise((resolve) => {
-    const timeout = setTimeout(resolve, timeoutMs);
-    const listener = (id, info) => {
-      if (id === tabId && info.status === "complete") {
-        clearTimeout(timeout);
-        chrome.tabs.onUpdated.removeListener(listener);
-        resolve();
-      }
-    };
-    chrome.tabs.onUpdated.addListener(listener);
-    chrome.tabs.get(tabId).then((tab) => {
-      if (tab.status === "complete") {
-        clearTimeout(timeout);
-        chrome.tabs.onUpdated.removeListener(listener);
-        resolve();
-      }
-    }).catch(() => {
-      clearTimeout(timeout);
-      chrome.tabs.onUpdated.removeListener(listener);
-      resolve();
-    });
-  });
-}
-async function resolveTargetWindowId() {
-  const w = await chrome.windows.getLastFocused({ windowTypes: ["normal"] });
-  if (w?.id != null) return w.id;
-  const all = await chrome.windows.getAll({ windowTypes: ["normal"] });
-  const first = all.find((x) => x.id != null);
-  if (first?.id != null) return first.id;
-  throw new Error("No normal browser window — open a Chrome window, then run automation again.");
-}
-async function getOrCreateAutomationWindow(workspace = DEFAULT_WORKSPACE) {
-  const existing = automationSessions.get(workspace);
-  if (existing) {
-    try {
-      await chrome.tabGroups.get(existing.groupId);
-      const tabsInGroup = await chrome.tabs.query({ groupId: existing.groupId });
-      if (tabsInGroup.length === 0) throw new Error("empty group");
-      existing.tabIds = tabsInGroup.map((t) => t.id).filter(Boolean);
-      const active = tabsInGroup.find((t) => t.active);
-      existing.activeTabId = active?.id ?? tabsInGroup[0]?.id ?? null;
-      resetWindowIdleTimer(workspace);
-      return existing;
-    } catch {
-      automationSessions.delete(workspace);
-    }
-  }
-  const windowId = await resolveTargetWindowId();
-  const tab = await chrome.tabs.create({
-    windowId,
-    url: "about:blank",
-    active: false
-  });
-  if (tab.id == null) throw new Error("Failed to create automation tab");
-  const groupId = await chrome.tabs.group({
-    tabIds: [tab.id],
-    createProperties: { windowId }
-  });
-  await chrome.tabGroups.update(groupId, {
-    title: XOPC_TAB_GROUP_TITLE,
-    collapsed: false,
-    color: "blue"
-  });
-  const session = {
-    windowId,
-    groupId,
-    tabIds: [tab.id],
-    activeTabId: tab.id,
-    idleTimer: null,
-    idleDeadlineAt: 0,
-    createdAt: Date.now()
-  };
-  automationSessions.set(workspace, session);
-  resetWindowIdleTimer(workspace);
-  log$1.info("Created automation tab group", { workspace, windowId, groupId, tabId: tab.id });
-  return session;
-}
-async function getActiveTabId(workspace = DEFAULT_WORKSPACE) {
-  const session = await getOrCreateAutomationWindow(workspace);
-  if (session.activeTabId != null) {
-    const ok = await chrome.tabs.get(session.activeTabId).catch(() => null);
-    if (ok) return session.activeTabId;
-  }
-  const tabs = await chrome.tabs.query({ groupId: session.groupId });
-  const tabId = tabs.find((t) => t.active)?.id ?? tabs[0]?.id;
-  if (tabId == null) throw new Error("No tab in xopc automation group");
-  session.activeTabId = tabId;
-  return tabId;
-}
-async function addTabToAutomationGroup(url, workspace = DEFAULT_WORKSPACE) {
-  const session = await getOrCreateAutomationWindow(workspace);
-  const tab = await chrome.tabs.create({
-    windowId: session.windowId,
-    url,
-    active: false
-  });
-  if (tab.id == null) throw new Error("Failed to create tab");
-  const inGroup = await chrome.tabs.query({ groupId: session.groupId });
-  const mergedIds = [...inGroup.map((t) => t.id).filter(Boolean), tab.id];
-  await chrome.tabs.group({ tabIds: mergedIds, groupId: session.groupId });
-  session.activeTabId = tab.id;
-  session.tabIds = mergedIds;
-  resetWindowIdleTimer(workspace);
-  return { tabId: tab.id, session };
-}
-async function closeSession(workspace = DEFAULT_WORKSPACE) {
-  const session = automationSessions.get(workspace);
-  if (!session) return;
-  if (session.idleTimer) clearTimeout(session.idleTimer);
-  const tabs = await chrome.tabs.query({ groupId: session.groupId }).catch(() => []);
-  for (const t of tabs) {
-    if (t.id != null) await chrome.tabs.remove(t.id).catch(() => {
-    });
-  }
-  automationSessions.delete(workspace);
-  log$1.info("Closed automation session", { workspace });
-}
-
 const observations = /* @__PURE__ */ new Map();
+const activeCommands = /* @__PURE__ */ new Set();
 async function markerDigest(tabId) {
   const marker = await evaluate(tabId, `({ url: location.href, timeOrigin: performance.timeOrigin })`);
   const url = new URL(marker.url);
@@ -867,9 +1318,9 @@ async function resolveAttachedTarget(input) {
   if (input.action === "navigate" || input.action === "tabs" || input.action === "sequence") {
     return fail("INVALID_INPUT", `${input.action} is unavailable for an attached tab.`);
   }
-  const needsAct = !["observe", "wait", "close"].includes(input.action);
+  const needsAct = !["observe", "resolve", "wait", "close"].includes(input.action);
   if (needsAct && binding.mode !== "act") {
-    return fail("APPROVAL_REQUIRED", "This tab is attached in read-only mode. Enable Control tab in the side panel.");
+    return fail("INVALID_INPUT", "This tab is attached in read-only mode. Enable Control tab in the side panel.");
   }
   const tabId = Number(binding.tabId);
   const tab = Number.isInteger(tabId) ? await chrome.tabs.get(tabId).catch(() => null) : null;
@@ -890,10 +1341,15 @@ async function resolveAttachedTarget(input) {
   }
   return { binding, tabId, stateKey: `attached:${binding.id}` };
 }
-async function executeBrowserCommand(command) {
+async function executeBrowserCommand(command, signal) {
   const startedAt = Date.now();
+  const lockKey = command.input.target?.kind === "attached_tab" ? command.input.target.bindingId : command.input.sessionId;
+  if (activeCommands.has(lockKey)) return { id: command.id, connectionId: command.connectionId, result: fail("INVALID_INPUT", "This browser page is already executing an action.") };
+  activeCommands.add(lockKey);
+  holdAutomationSession(command.input.sessionId);
   try {
-    const result = await execute(command.input, command.timeoutMs, command.visualFallback, startedAt);
+    if (signal?.aborted) return { id: command.id, connectionId: command.connectionId, result: fail("ABORTED", "Operation was cancelled.") };
+    const result = await execute(command.input, command.timeoutMs, command.visualFallback, startedAt, signal);
     return { id: command.id, connectionId: command.connectionId, result };
   } catch (error) {
     return {
@@ -902,18 +1358,26 @@ async function executeBrowserCommand(command) {
       result: {
         ok: false,
         error: {
-          code: /timeout/i.test(String(error)) ? "TIMEOUT" : "DRIVER_UNAVAILABLE",
+          code: signal?.aborted ? "ABORTED" : /timeout/i.test(String(error)) ? "TIMEOUT" : "DRIVER_UNAVAILABLE",
           message: error instanceof Error ? error.message : String(error)
         }
       }
     };
+  } finally {
+    activeCommands.delete(lockKey);
+    releaseAutomationSession(command.input.sessionId);
   }
 }
-async function execute(input, timeoutMs, visualFallback, startedAt) {
+async function execute(input, timeoutMs, visualFallback, startedAt, signal) {
   const sessionId = input.sessionId;
   if (!sessionId) return fail("INVALID_INPUT", "Extension actions require a session id.");
   const attached = await resolveAttachedTarget(input);
   if (attached && !("binding" in attached)) return attached;
+  if (attached && !["observe", "resolve", "wait", "close"].includes(input.action)) {
+    const activeRecording = (await recordings()).some((item) => item.tabId === attached.tabId && ["recording", "paused"].includes(item.state));
+    if (activeRecording) return fail("INVALID_INPUT", "This page is being recorded. Finish recording before running an automation.");
+  }
+  if (signal?.aborted) return fail("ABORTED", "Operation was cancelled.");
   const stateKey = attached?.stateKey ?? sessionId;
   if (input.action === "close") {
     if (!attached) await closeSession(sessionId);
@@ -935,6 +1399,15 @@ async function execute(input, timeoutMs, visualFallback, startedAt) {
   }
   if (input.action === "tabs") return tabs(sessionId, input, startedAt, timeoutMs);
   if (input.action === "sequence") return fail("INVALID_INPUT", "Sequences are expanded by the browser runtime.");
+  if (input.action === "resolve") {
+    const tabId2 = attached?.tabId ?? await getActiveTabId(sessionId);
+    const resolved = await evaluate(tabId2, `(${browserDom.toString()})(${JSON.stringify({ operation: "resolve", target: input.semanticTarget })})`);
+    if (resolved.matches !== 1 || !resolved.node) return fail("TARGET_NOT_FOUND", `Semantic target must match exactly one element; matched ${resolved.matches}.`);
+    const observation2 = await observe(sessionId, "never", attached);
+    observation2.nodes = [resolved.node];
+    observations.get(stateKey).nodes = observation2.nodes;
+    return success("resolve", "read", startedAt, observation2);
+  }
   const current = observations.get(stateKey);
   if (!current || current.revision !== input.revision) {
     return fail("STALE_OBSERVATION", "The page changed. Observe it again.", await observe(sessionId, "never", attached));
@@ -965,6 +1438,13 @@ async function execute(input, timeoutMs, visualFallback, startedAt) {
     }`, input.value);
     if (!changed) return fail("TARGET_NOT_FOUND", `Target ${input.ref} was not found.`);
     if (input.submit) await pressKey(tabId, "Enter");
+  } else if (input.action === "check") {
+    const changed = await evaluateRef(tabId, input.ref, `(element, checked) => {
+      if (!['checkbox', 'radio'].includes(element.type)) return false;
+      if (element.checked !== checked) element.click();
+      return element.checked === checked;
+    }`, input.checked);
+    if (!changed) return fail("INVALID_INPUT", "The checkbox could not be set to the requested state.");
   } else if (input.action === "select") {
     const changed = await evaluateRef(tabId, input.ref, `(element, value) => {
       element.value = value;
@@ -983,7 +1463,7 @@ async function execute(input, timeoutMs, visualFallback, startedAt) {
       await dispatchInput(tabId, "dispatchMouseEvent", { type: "mouseWheel", x: 640, y: 360, deltaX: 0, deltaY: input.deltaY });
     }
   } else if (input.action === "wait") {
-    await wait(tabId, input, timeoutMs);
+    await wait(tabId, input, timeoutMs, signal);
   } else if (input.action === "upload") {
     const document = await sendCommand(tabId, "DOM.getDocument", { depth: 1 });
     const query = await sendCommand(tabId, "DOM.querySelectorAll", {
@@ -1089,10 +1569,11 @@ async function tabs(sessionId, input, startedAt, timeoutMs) {
     }
   };
 }
-async function wait(tabId, input, defaultTimeout) {
+async function wait(tabId, input, defaultTimeout, signal) {
   const timeout = input.timeoutMs ?? defaultTimeout;
   const deadline = Date.now() + timeout;
   while (Date.now() < deadline) {
+    if (signal?.aborted) throw new Error("Operation aborted.");
     if (input.condition === "page_idle") {
       const tab = await chrome.tabs.get(tabId);
       if (tab.status === "complete") return;
@@ -1228,7 +1709,7 @@ function scheduleReconnectAlarm() {
 }
 const browserToolRegistry = new EndpointToolRegistry([{
   descriptor: BROWSER_CONTROL_ENDPOINT_DESCRIPTOR,
-  execute: async (args) => {
+  execute: async (args, context) => {
     const input = args.input;
     if (!input || typeof input !== "object") throw new TypeError("Browser control input is required");
     const result = await executeBrowserCommand({
@@ -1238,9 +1719,12 @@ const browserToolRegistry = new EndpointToolRegistry([{
       input,
       timeoutMs: typeof args.timeoutMs === "number" ? args.timeoutMs : 3e4,
       visualFallback: args.visualFallback !== false
-    });
+    }, context.signal);
     return { content: [{ type: "json", value: fitBrowserControlResultToFrame(result.result) }] };
   }
+}, {
+  descriptor: BROWSER_RECORDING_ENDPOINT_DESCRIPTOR,
+  execute: async (args) => ({ content: [{ type: "json", value: await recordingCommand(String(args.operation)) }] })
 }]);
 const endpointHost = new EndpointToolHostController({
   registry: browserToolRegistry,
@@ -1300,6 +1784,7 @@ async function connect(generation) {
     createHello: () => createBrowserEndpointHello(browserToolRegistry.descriptors()),
     onReady: ({ endpointId, turnToken }) => {
       endpointClaim = { endpointId, token: turnToken };
+      setRecordingClaim(endpointClaim);
       lastConnectionError = void 0;
       clearReconnectAlarm();
       endpointHost.connect((message) => client.sendEndpointMessage(message));
@@ -1311,6 +1796,7 @@ async function connect(generation) {
     },
     onDisconnected: () => {
       endpointClaim = void 0;
+      setRecordingClaim(void 0);
       endpointHost.disconnect();
       scheduleReconnectAlarm();
     }
@@ -1339,7 +1825,15 @@ function connectWithLogging() {
   });
 }
 chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
-  if (message.type === "browser/get-status") {
+  if (message.type === "browser/recording-event") {
+    void acceptRecordingEvent(message, sender).then(() => sendResponse({ ok: true })).catch((error) => sendResponse({ ok: false, error: String(error) }));
+  } else if (message.type === "browser/recording-command") {
+    if (!sender.url?.startsWith(`chrome-extension://${chrome.runtime.id}/`) || sender.tab) {
+      sendResponse({ ok: false, error: "Invalid recording control source." });
+      return true;
+    }
+    void recordingCommand(message.operation ?? "status", message.tabId).then((value) => sendResponse({ ok: true, value })).catch((error) => sendResponse({ ok: false, error: error instanceof Error ? error.message : String(error) }));
+  } else if (message.type === "browser/get-status") {
     sendResponse({ connected: Boolean(endpointClaim), transport: "gateway-realtime", error: lastConnectionError });
   } else if (message.type === "browser/get-endpoint-claim") {
     sendResponse({ claim: endpointClaim, error: lastConnectionError });
@@ -1402,3 +1896,7 @@ chrome.storage.onChanged.addListener((changes, area) => {
 });
 void chrome.sidePanel.setPanelBehavior({ openPanelOnActionClick: true });
 connectWithLogging();
+chrome.alarms.create("xopc-recording-sync", { periodInMinutes: 0.5 });
+chrome.alarms.onAlarm.addListener((alarm) => {
+  if (alarm.name === "xopc-recording-sync") void syncRecordings();
+});