@xopcai/xopc 0.0.265 → 0.0.267

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

@@ -1,26 +1,592 @@
-import { T as TAB_BINDING_PREFIX, d as captureTabPage, P as PENDING_CONTEXT_KEY, r as readProfile, u as signBrowserBridgeChallenge } from './assets/auth-CknJ00ae.js';
+import { h as endpointToolContentSchema, E as ENDPOINT_PROTOCOL_VERSION, c as canonicalJson, T as TAB_BINDING_PREFIX, b as captureTabPage, P as PENDING_CONTEXT_KEY, r as readProfile, k as registerBrowserEndpoint, j as getAccessProfile, R as RealtimeClient, e as createBrowserEndpointHello, i as gatewayFetch } from './assets/auth-D_IL6naL.js';
 
 const BROWSER_EXTENSION_PROTOCOL_VERSION = 4;
-function browserWireAuthenticationPayload(input) {
-  return [
-    "xopc-browser-extension-v4",
-    input.connectionId,
-    input.challenge,
-    String(input.issuedAt),
-    input.principalId,
-    input.extensionId,
-    input.extensionVersion
-  ].join("\n");
+const BROWSER_CONTROL_ENDPOINT_TOOL_NAME = "browser.control";
+const BROWSER_CONTROL_ENDPOINT_INPUT_SCHEMA = {
+  type: "object",
+  additionalProperties: false,
+  required: ["input"],
+  properties: {
+    input: { type: "object" },
+    timeoutMs: { type: "integer", minimum: 1, maximum: 12e4 },
+    visualFallback: { type: "boolean" }
+  }
+};
+const BROWSER_CONTROL_ENDPOINT_OUTPUT_SCHEMA = {
+  type: "array",
+  minItems: 1,
+  maxItems: 1,
+  items: {
+    type: "object",
+    additionalProperties: false,
+    required: ["type", "value"],
+    properties: {
+      type: { const: "json" },
+      value: {}
+    }
+  }
+};
+const BROWSER_CONTROL_ENDPOINT_DESCRIPTOR = {
+  name: BROWSER_CONTROL_ENDPOINT_TOOL_NAME,
+  title: "Browser control transport",
+  description: "Internal authenticated transport for xopc browser-control actions.",
+  inputSchema: BROWSER_CONTROL_ENDPOINT_INPUT_SCHEMA,
+  outputSchema: BROWSER_CONTROL_ENDPOINT_OUTPUT_SCHEMA,
+  policyId: "browser.control",
+  sensitivity: "personal",
+  effect: "write",
+  confirmation: "never",
+  requiresForeground: false,
+  requiredPermissions: ["browser-control"],
+  timeoutMs: 12e4,
+  maxConcurrency: 4,
+  supportsCancellation: true,
+  idempotent: false,
+  resultKinds: ["json"]
+};
+
+/**
+ * Utilities for hex, bytes, CSPRNG.
+ * @module
+ */
+/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+// We use WebCrypto aka globalThis.crypto, which exists in browsers and node.js 16+.
+// node.js versions earlier than v19 don't declare it in global scope.
+// For node.js, package.json#exports field mapping rewrites import
+// from `crypto` to `cryptoNode`, which imports native module.
+// Makes the utils un-importable in browsers without a bundler.
+// Once node.js 18 is deprecated (2025-04-30), we can just drop the import.
+/** Checks if something is Uint8Array. Be careful: nodejs Buffer will return true. */
+function isBytes(a) {
+    return a instanceof Uint8Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array');
+}
+/** Asserts something is Uint8Array. */
+function abytes(b, ...lengths) {
+    if (!isBytes(b))
+        throw new Error('Uint8Array expected');
+    if (lengths.length > 0 && !lengths.includes(b.length))
+        throw new Error('Uint8Array expected of length ' + lengths + ', got length=' + b.length);
+}
+/** Asserts a hash instance has not been destroyed / finished */
+function aexists(instance, checkFinished = true) {
+    if (instance.destroyed)
+        throw new Error('Hash instance has been destroyed');
+    if (checkFinished && instance.finished)
+        throw new Error('Hash#digest() has already been called');
+}
+/** Asserts output is properly-sized byte array */
+function aoutput(out, instance) {
+    abytes(out);
+    const min = instance.outputLen;
+    if (out.length < min) {
+        throw new Error('digestInto() expects output buffer of length at least ' + min);
+    }
+}
+/** Zeroize a byte array. Warning: JS provides no guarantees. */
+function clean(...arrays) {
+    for (let i = 0; i < arrays.length; i++) {
+        arrays[i].fill(0);
+    }
+}
+/** Create DataView of an array for easy byte-level manipulation. */
+function createView(arr) {
+    return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+/** The rotate right (circular right shift) operation for uint32 */
+function rotr(word, shift) {
+    return (word << (32 - shift)) | (word >>> shift);
+}
+/**
+ * Converts string to bytes using UTF8 encoding.
+ * @example utf8ToBytes('abc') // Uint8Array.from([97, 98, 99])
+ */
+function utf8ToBytes(str) {
+    if (typeof str !== 'string')
+        throw new Error('string expected');
+    return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809
+}
+/**
+ * Normalizes (non-hex) string or Uint8Array to Uint8Array.
+ * Warning: when Uint8Array is passed, it would NOT get copied.
+ * Keep in mind for future mutable operations.
+ */
+function toBytes(data) {
+    if (typeof data === 'string')
+        data = utf8ToBytes(data);
+    abytes(data);
+    return data;
+}
+/** For runtime check if class implements interface */
+class Hash {
+}
+/** Wraps hash function, creating an interface on top of it */
+function createHasher(hashCons) {
+    const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
+    const tmp = hashCons();
+    hashC.outputLen = tmp.outputLen;
+    hashC.blockLen = tmp.blockLen;
+    hashC.create = () => hashCons();
+    return hashC;
+}
+
+/**
+ * Internal Merkle-Damgard hash utils.
+ * @module
+ */
+/** Polyfill for Safari 14. https://caniuse.com/mdn-javascript_builtins_dataview_setbiguint64 */
+function setBigUint64(view, byteOffset, value, isLE) {
+    if (typeof view.setBigUint64 === 'function')
+        return view.setBigUint64(byteOffset, value, isLE);
+    const _32n = BigInt(32);
+    const _u32_max = BigInt(0xffffffff);
+    const wh = Number((value >> _32n) & _u32_max);
+    const wl = Number(value & _u32_max);
+    const h = isLE ? 4 : 0;
+    const l = isLE ? 0 : 4;
+    view.setUint32(byteOffset + h, wh, isLE);
+    view.setUint32(byteOffset + l, wl, isLE);
+}
+/** Choice: a ? b : c */
+function Chi(a, b, c) {
+    return (a & b) ^ (~a & c);
+}
+/** Majority function, true if any two inputs is true. */
+function Maj(a, b, c) {
+    return (a & b) ^ (a & c) ^ (b & c);
+}
+/**
+ * Merkle-Damgard hash construction base class.
+ * Could be used to create MD5, RIPEMD, SHA1, SHA2.
+ */
+class HashMD extends Hash {
+    constructor(blockLen, outputLen, padOffset, isLE) {
+        super();
+        this.finished = false;
+        this.length = 0;
+        this.pos = 0;
+        this.destroyed = false;
+        this.blockLen = blockLen;
+        this.outputLen = outputLen;
+        this.padOffset = padOffset;
+        this.isLE = isLE;
+        this.buffer = new Uint8Array(blockLen);
+        this.view = createView(this.buffer);
+    }
+    update(data) {
+        aexists(this);
+        data = toBytes(data);
+        abytes(data);
+        const { view, buffer, blockLen } = this;
+        const len = data.length;
+        for (let pos = 0; pos < len;) {
+            const take = Math.min(blockLen - this.pos, len - pos);
+            // Fast path: we have at least one block in input, cast it to view and process
+            if (take === blockLen) {
+                const dataView = createView(data);
+                for (; blockLen <= len - pos; pos += blockLen)
+                    this.process(dataView, pos);
+                continue;
+            }
+            buffer.set(data.subarray(pos, pos + take), this.pos);
+            this.pos += take;
+            pos += take;
+            if (this.pos === blockLen) {
+                this.process(view, 0);
+                this.pos = 0;
+            }
+        }
+        this.length += data.length;
+        this.roundClean();
+        return this;
+    }
+    digestInto(out) {
+        aexists(this);
+        aoutput(out, this);
+        this.finished = true;
+        // Padding
+        // We can avoid allocation of buffer for padding completely if it
+        // was previously not allocated here. But it won't change performance.
+        const { buffer, view, blockLen, isLE } = this;
+        let { pos } = this;
+        // append the bit '1' to the message
+        buffer[pos++] = 0b10000000;
+        clean(this.buffer.subarray(pos));
+        // we have less than padOffset left in buffer, so we cannot put length in
+        // current block, need process it and pad again
+        if (this.padOffset > blockLen - pos) {
+            this.process(view, 0);
+            pos = 0;
+        }
+        // Pad until full block byte with zeros
+        for (let i = pos; i < blockLen; i++)
+            buffer[i] = 0;
+        // Note: sha512 requires length to be 128bit integer, but length in JS will overflow before that
+        // You need to write around 2 exabytes (u64_max / 8 / (1024**6)) for this to happen.
+        // So we just write lowest 64 bits of that value.
+        setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE);
+        this.process(view, 0);
+        const oview = createView(out);
+        const len = this.outputLen;
+        // NOTE: we do division by 4 later, which should be fused in single op with modulo by JIT
+        if (len % 4)
+            throw new Error('_sha2: outputLen should be aligned to 32bit');
+        const outLen = len / 4;
+        const state = this.get();
+        if (outLen > state.length)
+            throw new Error('_sha2: outputLen bigger than state');
+        for (let i = 0; i < outLen; i++)
+            oview.setUint32(4 * i, state[i], isLE);
+    }
+    digest() {
+        const { buffer, outputLen } = this;
+        this.digestInto(buffer);
+        const res = buffer.slice(0, outputLen);
+        this.destroy();
+        return res;
+    }
+    _cloneInto(to) {
+        to || (to = new this.constructor());
+        to.set(...this.get());
+        const { blockLen, buffer, length, finished, destroyed, pos } = this;
+        to.destroyed = destroyed;
+        to.finished = finished;
+        to.length = length;
+        to.pos = pos;
+        if (length % blockLen)
+            to.buffer.set(buffer);
+        return to;
+    }
+    clone() {
+        return this._cloneInto();
+    }
+}
+/**
+ * Initial SHA-2 state: fractional parts of square roots of first 16 primes 2..53.
+ * Check out `test/misc/sha2-gen-iv.js` for recomputation guide.
+ */
+/** Initial SHA256 state. Bits 0..32 of frac part of sqrt of primes 2..19 */
+const SHA256_IV = /* @__PURE__ */ Uint32Array.from([
+    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
+]);
+
+/**
+ * SHA2 hash function. A.k.a. sha256, sha384, sha512, sha512_224, sha512_256.
+ * SHA256 is the fastest hash implementable in JS, even faster than Blake3.
+ * Check out [RFC 4634](https://datatracker.ietf.org/doc/html/rfc4634) and
+ * [FIPS 180-4](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf).
+ * @module
+ */
+/**
+ * Round constants:
+ * First 32 bits of fractional parts of the cube roots of the first 64 primes 2..311)
+ */
+// prettier-ignore
+const SHA256_K = /* @__PURE__ */ Uint32Array.from([
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
+]);
+/** Reusable temporary buffer. "W" comes straight from spec. */
+const SHA256_W = /* @__PURE__ */ new Uint32Array(64);
+class SHA256 extends HashMD {
+    constructor(outputLen = 32) {
+        super(64, outputLen, 8, false);
+        // We cannot use array here since array allows indexing by variable
+        // which means optimizer/compiler cannot use registers.
+        this.A = SHA256_IV[0] | 0;
+        this.B = SHA256_IV[1] | 0;
+        this.C = SHA256_IV[2] | 0;
+        this.D = SHA256_IV[3] | 0;
+        this.E = SHA256_IV[4] | 0;
+        this.F = SHA256_IV[5] | 0;
+        this.G = SHA256_IV[6] | 0;
+        this.H = SHA256_IV[7] | 0;
+    }
+    get() {
+        const { A, B, C, D, E, F, G, H } = this;
+        return [A, B, C, D, E, F, G, H];
+    }
+    // prettier-ignore
+    set(A, B, C, D, E, F, G, H) {
+        this.A = A | 0;
+        this.B = B | 0;
+        this.C = C | 0;
+        this.D = D | 0;
+        this.E = E | 0;
+        this.F = F | 0;
+        this.G = G | 0;
+        this.H = H | 0;
+    }
+    process(view, offset) {
+        // Extend the first 16 words into the remaining 48 words w[16..63] of the message schedule array
+        for (let i = 0; i < 16; i++, offset += 4)
+            SHA256_W[i] = view.getUint32(offset, false);
+        for (let i = 16; i < 64; i++) {
+            const W15 = SHA256_W[i - 15];
+            const W2 = SHA256_W[i - 2];
+            const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ (W15 >>> 3);
+            const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ (W2 >>> 10);
+            SHA256_W[i] = (s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16]) | 0;
+        }
+        // Compression function main loop, 64 rounds
+        let { A, B, C, D, E, F, G, H } = this;
+        for (let i = 0; i < 64; i++) {
+            const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
+            const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) | 0;
+            const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
+            const T2 = (sigma0 + Maj(A, B, C)) | 0;
+            H = G;
+            G = F;
+            F = E;
+            E = (D + T1) | 0;
+            D = C;
+            C = B;
+            B = A;
+            A = (T1 + T2) | 0;
+        }
+        // Add the compressed chunk to the current hash value
+        A = (A + this.A) | 0;
+        B = (B + this.B) | 0;
+        C = (C + this.C) | 0;
+        D = (D + this.D) | 0;
+        E = (E + this.E) | 0;
+        F = (F + this.F) | 0;
+        G = (G + this.G) | 0;
+        H = (H + this.H) | 0;
+        this.set(A, B, C, D, E, F, G, H);
+    }
+    roundClean() {
+        clean(SHA256_W);
+    }
+    destroy() {
+        this.set(0, 0, 0, 0, 0, 0, 0, 0);
+        clean(this.buffer);
+    }
 }
+/**
+ * SHA2-256 hash function from RFC 4634.
+ *
+ * It is the fastest JS hash, even faster than Blake3.
+ * To break sha256 using birthday attack, attackers need to try 2^128 hashes.
+ * BTC network is doing 2^70 hashes/sec (2^95 hashes/year) as per 2025.
+ */
+const sha256$1 = /* @__PURE__ */ createHasher(() => new SHA256());
 
-const XOPC_EXT_PORT = 19820;
-const XOPC_EXT_HOST = "127.0.0.1";
-const XOPC_EXT_WS_URL = `ws://${XOPC_EXT_HOST}:${XOPC_EXT_PORT}/browser-ext`;
-const WS_RECONNECT_BASE_DELAY = 2e3;
-const WS_RECONNECT_MAX_DELAY = 5e3;
-const WS_KEEPALIVE_INTERVAL = 2e4;
-const WS_WATCHDOG_ALARM = "xopc-ws-watchdog";
-const WS_WATCHDOG_PERIOD_MINUTES = 0.5;
+/**
+ * SHA2-256 a.k.a. sha256. In JS, it is the fastest hash, even faster than Blake3.
+ *
+ * To break sha256 using birthday attack, attackers need to try 2^128 hashes.
+ * BTC network is doing 2^70 hashes/sec (2^95 hashes/year) as per 2025.
+ *
+ * Check out [FIPS 180-4](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf).
+ * @module
+ * @deprecated
+ */
+/** @deprecated Use import from `noble/hashes/sha2` module */
+const sha256 = sha256$1;
+
+class EndpointToolClientError extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "EndpointToolClientError";
+  }
+  code;
+}
+function endpointToolRevision(descriptor) {
+  return [...sha256(new TextEncoder().encode(canonicalJson(descriptor)))].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+class EndpointToolRegistry {
+  tools = /* @__PURE__ */ new Map();
+  constructor(definitions) {
+    for (const definition of definitions) {
+      const name = definition.descriptor.name;
+      if (this.tools.has(name)) throw new Error(`Duplicate endpoint tool: ${name}`);
+      this.tools.set(name, {
+        definition,
+        revision: endpointToolRevision(definition.descriptor)
+      });
+    }
+  }
+  descriptors() {
+    return [...this.tools.values()].map(({ definition }) => definition.descriptor);
+  }
+  get(name) {
+    return this.tools.get(name);
+  }
+}
+class EndpointToolHostController {
+  constructor(options) {
+    this.options = options;
+    this.now = options.now ?? Date.now;
+  }
+  options;
+  active = /* @__PURE__ */ new Map();
+  now;
+  sendMessage;
+  generation = 0;
+  connect(sendMessage) {
+    this.disconnect();
+    this.sendMessage = sendMessage;
+  }
+  disconnect() {
+    this.generation += 1;
+    this.sendMessage = void 0;
+    for (const invocation of this.active.values()) invocation.controller.abort();
+    this.active.clear();
+  }
+  publishAvailability() {
+    this.send("endpoint.availability_changed", {
+      availability: this.options.getAvailability()
+    });
+  }
+  async handleMessage(message) {
+    if (message.type === "tool.cancel") {
+      this.cancel(message.payload.invocationId);
+      return;
+    }
+    await this.invoke(message);
+  }
+  async invoke(message) {
+    const {
+      invocationId,
+      toolName,
+      arguments: args,
+      descriptorRevision,
+      confirmationRequired,
+      deadlineAt,
+      uploadGrant
+    } = message.payload;
+    if (this.active.has(invocationId)) {
+      this.sendError(invocationId, "PROTOCOL_ERROR", "Endpoint invocation is already running");
+      return;
+    }
+    this.send("tool.received", { invocationId });
+    const registered = this.options.registry.get(toolName);
+    if (!registered) {
+      this.sendError(invocationId, "TOOL_NOT_FOUND", "Endpoint tool is not registered");
+      return;
+    }
+    if (registered.revision !== descriptorRevision) {
+      this.sendError(invocationId, "TOOL_REVISION_MISMATCH", "Endpoint tool contract changed");
+      return;
+    }
+    const descriptor = registered.definition.descriptor;
+    const localConfirmationRequired = descriptor.confirmation === "always";
+    if (confirmationRequired !== localConfirmationRequired) {
+      this.sendError(invocationId, "PROTOCOL_ERROR", "Endpoint confirmation policy mismatch");
+      return;
+    }
+    const invocation = {
+      controller: new AbortController(),
+      generation: this.generation
+    };
+    this.active.set(invocationId, invocation);
+    try {
+      this.assertExecutable(invocationId, invocation, descriptor, deadlineAt);
+      const authorizationRequest = {
+        invocationId,
+        descriptor,
+        arguments: args,
+        deadlineAt,
+        signal: invocation.controller.signal
+      };
+      await this.options.authorize?.(authorizationRequest);
+      this.assertExecutable(invocationId, invocation, descriptor, deadlineAt);
+      if (localConfirmationRequired) {
+        this.send("tool.progress", { invocationId, message: "Waiting for approval" });
+        const allowed = await this.options.confirm(authorizationRequest);
+        this.assertExecutable(invocationId, invocation, descriptor, deadlineAt);
+        if (!allowed) throw new EndpointToolClientError("USER_DENIED", "User denied the endpoint tool call");
+      }
+      const result = await registered.definition.execute(args, {
+        invocationId,
+        signal: invocation.controller.signal,
+        reportProgress: (progress) => {
+          if (this.isCurrent(invocationId, invocation)) {
+            this.send("tool.progress", { invocationId, ...progress });
+          }
+        },
+        uploadFile: (file) => this.options.uploadFile(uploadGrant, file)
+      });
+      this.assertExecutable(invocationId, invocation, descriptor, deadlineAt);
+      const content = endpointToolContentSchema.array().min(1).max(20).parse(result.content);
+      this.send("tool.result", {
+        invocationId,
+        content,
+        ...result.details ? { details: result.details } : {}
+      });
+      this.active.delete(invocationId);
+      if (result.afterSend) {
+        const generation = invocation.generation;
+        setTimeout(() => {
+          if (this.generation === generation && this.now() < deadlineAt && (!descriptor.requiresForeground || this.options.getAvailability() === "foreground")) {
+            result.afterSend?.();
+          }
+        }, this.options.afterSendDelayMs ?? 50);
+      }
+    } catch (error) {
+      if (!this.isCurrent(invocationId, invocation)) return;
+      this.active.delete(invocationId);
+      const normalized = this.normalizeError(error);
+      this.sendError(invocationId, normalized.code, normalized.message);
+    }
+  }
+  cancel(invocationId) {
+    const invocation = this.active.get(invocationId);
+    if (!invocation) return;
+    this.active.delete(invocationId);
+    invocation.controller.abort();
+    this.send("tool.cancelled", { invocationId });
+  }
+  assertExecutable(invocationId, invocation, descriptor, deadlineAt) {
+    if (!this.isCurrent(invocationId, invocation) || invocation.controller.signal.aborted) {
+      throw new EndpointToolClientError("TOOL_CANCELLED", "Endpoint tool call was cancelled");
+    }
+    if (this.now() >= deadlineAt) {
+      throw new EndpointToolClientError("TOOL_TIMEOUT", "Endpoint tool deadline expired");
+    }
+    if (descriptor.requiresForeground && this.options.getAvailability() !== "foreground") {
+      throw new EndpointToolClientError("ENDPOINT_NOT_FOREGROUND", "Endpoint is not foreground");
+    }
+  }
+  isCurrent(invocationId, invocation) {
+    return this.active.get(invocationId) === invocation && invocation.generation === this.generation && this.sendMessage !== void 0;
+  }
+  normalizeError(error) {
+    if (error instanceof EndpointToolClientError) return error;
+    if (error instanceof TypeError) {
+      return new EndpointToolClientError("INVALID_ARGUMENTS", error.message);
+    }
+    if (error instanceof Error && error.name === "AbortError") {
+      return new EndpointToolClientError("USER_DENIED", error.message);
+    }
+    if (error instanceof Error && error.name === "NotAllowedError") {
+      return new EndpointToolClientError("PERMISSION_DENIED", error.message);
+    }
+    return new EndpointToolClientError(
+      "PROTOCOL_ERROR",
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+  sendError(invocationId, code, message) {
+    this.send("tool.error", { invocationId, code, message });
+  }
+  send(type, payload) {
+    this.sendMessage?.({
+      protocolVersion: ENDPOINT_PROTOCOL_VERSION,
+      messageId: this.options.createMessageId(),
+      type,
+      sentAt: this.now(),
+      payload
+    });
+  }
+}
 
 const LOG_COLORS = {
   debug: "color: #888",
@@ -320,16 +886,6 @@ async function resolveAttachedTarget(input) {
 }
 async function executeBrowserCommand(command) {
   const startedAt = Date.now();
-  if (command.protocolVersion !== BROWSER_EXTENSION_PROTOCOL_VERSION) {
-    return {
-      id: command.id,
-      connectionId: command.connectionId,
-      result: fail(
-        "DRIVER_UNAVAILABLE",
-        `Browser protocol mismatch. Expected ${BROWSER_EXTENSION_PROTOCOL_VERSION}; reload the xopc extension.`
-      )
-    };
-  }
   try {
     const result = await execute(command.input, command.timeoutMs, command.visualFallback, startedAt);
     return { id: command.id, connectionId: command.connectionId, result };
@@ -586,145 +1142,125 @@ function diff(previous, next) {
 }
 
 const log = createLogger("Background");
-let ws = null;
-let reconnectTimer = null;
-let keepAliveTimer = null;
-let reconnectDelay = WS_RECONNECT_BASE_DELAY;
-let intentionalClose = false;
-let authenticatedConnectionId = null;
-async function authenticate(socket, challenge) {
-  if (challenge.protocolVersion !== BROWSER_EXTENSION_PROTOCOL_VERSION) {
-    socket.close(4406, "Browser protocol mismatch");
-    return;
-  }
-  const profile = await readProfile();
-  if (!profile) {
-    socket.close(4401, "Browser is not paired");
-    return;
-  }
-  const extensionVersion = chrome.runtime.getManifest().version;
-  const unsigned = {
-    connectionId: challenge.connectionId,
-    challenge: challenge.challenge,
-    issuedAt: challenge.issuedAt,
-    principalId: profile.deviceId,
-    extensionId: chrome.runtime.id,
-    extensionVersion
-  };
-  const message = {
-    type: "authenticate",
-    protocolVersion: BROWSER_EXTENSION_PROTOCOL_VERSION,
-    connectionId: challenge.connectionId,
-    principalId: profile.deviceId,
-    extensionId: chrome.runtime.id,
-    extensionVersion,
-    signature: await signBrowserBridgeChallenge(browserWireAuthenticationPayload(unsigned))
-  };
-  socket.send(JSON.stringify(message));
-  authenticatedConnectionId = challenge.connectionId;
-  sendStatus(profile.deviceId);
-  startKeepAlive();
-}
-async function connect() {
-  if (!await readProfile()) return;
-  if (ws && (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING)) return;
-  intentionalClose = false;
-  authenticatedConnectionId = null;
-  const socket = new WebSocket(XOPC_EXT_WS_URL);
-  ws = socket;
-  socket.onopen = () => {
-    if (ws !== socket) socket.close();
-  };
-  socket.onmessage = async (event) => {
-    if (ws !== socket) return;
-    try {
-      const value = JSON.parse(String(event.data));
-      if (value.type === "auth_challenge") {
-        await authenticate(socket, value);
-        reconnectDelay = WS_RECONNECT_BASE_DELAY;
-        log.info("Authenticated with xopc browser bridge");
-        return;
-      }
-      if (!authenticatedConnectionId || value.connectionId !== authenticatedConnectionId) {
-        throw new Error("Browser command arrived before authentication or for a stale connection");
-      }
-      const result = await executeBrowserCommand(value);
-      if (socket.readyState === WebSocket.OPEN) socket.send(JSON.stringify(result));
-    } catch (error) {
-      log.error("Failed to process browser bridge message", {
-        error: error instanceof Error ? error.message : String(error)
-      });
-    }
-  };
-  socket.onclose = (event) => {
-    if (ws !== socket) return;
-    stopKeepAlive();
-    ws = null;
-    authenticatedConnectionId = null;
-    log.warn("Disconnected from xopc browser bridge", {
-      code: event.code,
-      reason: event.reason,
-      wasClean: event.wasClean
+const BACKGROUND_CLIENT_ID_KEY = "xopc.browser.background-client-id";
+let realtime;
+let endpointClaim;
+let lastConnectionError;
+let connectTask;
+let connectionGeneration = 0;
+const browserToolRegistry = new EndpointToolRegistry([{
+  descriptor: BROWSER_CONTROL_ENDPOINT_DESCRIPTOR,
+  execute: async (args) => {
+    const input = args.input;
+    if (!input || typeof input !== "object") throw new TypeError("Browser control input is required");
+    const result = await executeBrowserCommand({
+      id: crypto.randomUUID(),
+      protocolVersion: BROWSER_EXTENSION_PROTOCOL_VERSION,
+      connectionId: "gateway-realtime",
+      input,
+      timeoutMs: typeof args.timeoutMs === "number" ? args.timeoutMs : 3e4,
+      visualFallback: args.visualFallback !== false
     });
-    if (!intentionalClose && event.code !== 4401) scheduleReconnect();
-  };
-}
-function sendStatus(principalId) {
-  if (ws?.readyState !== WebSocket.OPEN || !authenticatedConnectionId) return;
-  const status = {
-    type: "status",
-    protocolVersion: BROWSER_EXTENSION_PROTOCOL_VERSION,
-    extensionVersion: chrome.runtime.getManifest().version,
-    connectionId: authenticatedConnectionId,
-    principalId,
-    connected: true,
-    sessionCount: automationSessions.size
-  };
-  ws.send(JSON.stringify(status));
+    return { content: [{ type: "json", value: result.result }] };
+  }
+}]);
+const endpointHost = new EndpointToolHostController({
+  registry: browserToolRegistry,
+  getAvailability: () => "background",
+  confirm: async () => false,
+  uploadFile: async () => {
+    throw new Error("Browser control does not upload endpoint files");
+  },
+  createMessageId: () => crypto.randomUUID()
+});
+async function backgroundClientId() {
+  const stored = await chrome.storage.local.get(BACKGROUND_CLIENT_ID_KEY);
+  if (typeof stored[BACKGROUND_CLIENT_ID_KEY] === "string") return stored[BACKGROUND_CLIENT_ID_KEY];
+  const value = crypto.randomUUID();
+  await chrome.storage.local.set({ [BACKGROUND_CLIENT_ID_KEY]: value });
+  return value;
 }
-function startKeepAlive() {
-  stopKeepAlive();
-  keepAliveTimer = setInterval(() => {
-    if (ws?.readyState !== WebSocket.OPEN || !authenticatedConnectionId) {
-      stopKeepAlive();
-      return;
+async function connect(generation) {
+  if (realtime || !await readProfile()) return;
+  await registerBrowserEndpoint();
+  const profile = await getAccessProfile();
+  const id = await backgroundClientId();
+  const client = new RealtimeClient({
+    clientId: id,
+    clientKind: "browser_extension",
+    getWebSocketUrl: () => {
+      const url = new URL(profile.gatewayUrl);
+      url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+      url.pathname = "/api/realtime/v1/ws";
+      url.search = "";
+      url.hash = "";
+      return url.toString();
+    },
+    issueTicket: async (signal) => {
+      const response = await gatewayFetch("/api/realtime/tickets", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ clientId: id, clientKind: "browser_extension" }),
+        signal
+      });
+      const body = await response.json();
+      if (!response.ok || !body.payload?.ticket) throw new Error(`Realtime ticket failed (${response.status})`);
+      return body.payload.ticket;
+    },
+    createWebSocket: (url) => new WebSocket(url),
+    onStateChange: (state, error) => {
+      lastConnectionError = error;
+      if (state === "connected") lastConnectionError = void 0;
+      if (error) log.warn("Browser Realtime connection changed", { state, error });
     }
-    const message = {
-      type: "keepalive",
-      connectionId: authenticatedConnectionId,
-      timestamp: Date.now()
-    };
-    ws.send(JSON.stringify(message));
-  }, WS_KEEPALIVE_INTERVAL);
-}
-function stopKeepAlive() {
-  if (keepAliveTimer) clearInterval(keepAliveTimer);
-  keepAliveTimer = null;
-}
-function scheduleReconnect() {
-  if (reconnectTimer) clearTimeout(reconnectTimer);
-  reconnectTimer = setTimeout(() => {
-    reconnectTimer = null;
-    reconnectDelay = Math.min(reconnectDelay * 1.5, WS_RECONNECT_MAX_DELAY);
-    void connect();
-  }, reconnectDelay);
+  });
+  client.setEndpoint({
+    createHello: () => createBrowserEndpointHello(browserToolRegistry.descriptors()),
+    onReady: ({ endpointId, turnToken }) => {
+      endpointClaim = { endpointId, token: turnToken };
+      lastConnectionError = void 0;
+      endpointHost.connect((message) => client.sendEndpointMessage(message));
+      void chrome.runtime.sendMessage({ type: "browser/endpoint-ready", claim: endpointClaim }).catch(() => void 0);
+      log.info("Browser control connected through Gateway Realtime", { endpointId });
+    },
+    onMessage: (message) => {
+      void endpointHost.handleMessage(message);
+    },
+    onDisconnected: () => {
+      endpointClaim = void 0;
+      endpointHost.disconnect();
+    }
+  });
+  if (generation !== connectionGeneration || realtime) return;
+  realtime = client;
+  client.connect();
 }
 function disconnect() {
-  intentionalClose = true;
-  stopKeepAlive();
-  if (reconnectTimer) clearTimeout(reconnectTimer);
-  reconnectTimer = null;
-  ws?.close();
-  ws = null;
-  authenticatedConnectionId = null;
+  connectionGeneration += 1;
+  realtime?.disconnect();
+  realtime = void 0;
+  endpointClaim = void 0;
+  endpointHost.disconnect();
+}
+function connectWithLogging() {
+  if (connectTask) return;
+  const generation = connectionGeneration;
+  connectTask = connect(generation).catch((error) => {
+    lastConnectionError = error instanceof Error ? error.message : String(error);
+    log.warn("Could not connect browser Realtime transport", { error: lastConnectionError });
+  }).finally(() => {
+    connectTask = void 0;
+    if (generation !== connectionGeneration && !realtime) connectWithLogging();
+  });
 }
 chrome.runtime.onMessage.addListener((message, _sender, sendResponse) => {
   if (message.type === "browser/get-status") {
-    sendResponse({ connected: Boolean(authenticatedConnectionId), url: XOPC_EXT_WS_URL });
+    sendResponse({ connected: Boolean(endpointClaim), transport: "gateway-realtime", error: lastConnectionError });
+  } else if (message.type === "browser/get-endpoint-claim") {
+    sendResponse({ claim: endpointClaim, error: lastConnectionError });
   } else if (message.type === "browser/reconnect") {
     disconnect();
-    intentionalClose = false;
-    void connect();
+    connectWithLogging();
     sendResponse({ ok: true });
   } else {
     sendResponse({ ok: false, error: `Unknown message: ${message.type}` });
@@ -752,21 +1288,14 @@ chrome.runtime.onInstalled.addListener(() => {
       contexts: ["selection"]
     });
   });
-  void connect();
-});
-chrome.runtime.onStartup.addListener(() => {
-  void connect();
+  connectWithLogging();
 });
+chrome.runtime.onStartup.addListener(connectWithLogging);
 chrome.storage.onChanged.addListener((changes, area) => {
   if (area === "local" && changes["xopc.browser.profile"]) {
     disconnect();
-    intentionalClose = false;
-    void connect();
+    connectWithLogging();
   }
 });
-chrome.alarms.onAlarm.addListener((alarm) => {
-  if (alarm.name === WS_WATCHDOG_ALARM && !intentionalClose) void connect();
-});
-void chrome.alarms.create(WS_WATCHDOG_ALARM, { periodInMinutes: WS_WATCHDOG_PERIOD_MINUTES });
 void chrome.sidePanel.setPanelBehavior({ openPanelOnActionClick: true });
-void connect();
+connectWithLogging();