@opengeni/runtime 3.1.3-canary.38890816741001 → 3.3.0

package/dist/{chunk-462CH77G.js → chunk-EK7IW2FR.js}

@@ -9697,6 +9697,9 @@ async function transferEditorFile(input) {
   return { recovered: false };
 }
 
+// src/sandbox/browser-control-http.ts
+var BROWSER_CONTROL_HTTP_REPLY_GRACE_MS = 5e3;
+
 // src/sandbox/selfhosted/retry-policy.ts
 var SELFHOSTED_IDEMPOTENT_READONLY_OPS = /* @__PURE__ */ new Set([
   "ping",
@@ -10920,6 +10923,7 @@ var SelfhostedSession = class {
   resourcePolicySupported;
   operationCpuQuotaSupported;
   transactionalFsWriteSupported;
+  browserControlHttpSupported;
   defaultOpStream;
   connectionInstanceId;
   resolveOperationAdmission;
@@ -10980,6 +10984,7 @@ var SelfhostedSession = class {
     this.resourcePolicySupported = deps.operationResourcePolicySupported === true;
     this.operationCpuQuotaSupported = deps.operationCpuQuotaSupported === true;
     this.transactionalFsWriteSupported = deps.transactionalFsWriteSupported === true;
+    this.browserControlHttpSupported = deps.browserControlHttpSupported === true;
     this.defaultOpStream = deps.opStream;
     this.connectionInstanceId = deps.connectionInstanceId;
     this.resolveOperationAdmission = deps.resolveOperationAdmission;
@@ -10992,7 +10997,8 @@ var SelfhostedSession = class {
       subject: this.subject,
       resourcePolicy: this.resourcePolicy,
       opStream: deps.opStream,
-      transactionalFsWriteSupported: this.transactionalFsWriteSupported
+      transactionalFsWriteSupported: this.transactionalFsWriteSupported,
+      browserControlHttpSupported: this.browserControlHttpSupported
     }) : void 0;
     this.state = {
       agentId: deps.agentId,
@@ -11053,7 +11059,8 @@ var SelfhostedSession = class {
         subject: this.subject,
         resourcePolicy: commandPolicy ? this.resourcePolicy : void 0,
         opStream: this.defaultOpStream,
-        transactionalFsWriteSupported: this.transactionalFsWriteSupported
+        transactionalFsWriteSupported: this.transactionalFsWriteSupported,
+        browserControlHttpSupported: this.browserControlHttpSupported
       };
     }
     const resolved = await this.resolveOperationAdmission();
@@ -11087,7 +11094,8 @@ var SelfhostedSession = class {
       ),
       resourcePolicy: commandPolicy ? resourcePolicy : void 0,
       opStream: resolved.opStream,
-      transactionalFsWriteSupported: resolved.transactionalFsWriteSupported === true
+      transactionalFsWriteSupported: resolved.transactionalFsWriteSupported === true,
+      browserControlHttpSupported: resolved.browserControlHttpSupported === true
     };
   }
   async admitCommand() {
@@ -12078,6 +12086,90 @@ var SelfhostedSession = class {
     }
     return result.browserControlEnsure;
   }
+  /** Send one request to the agent-owned controller of an exact authority
+   * scope, served inside the runner over loopback without starting a process.
+   * `unsupported` means this connection's runner does not serve it and nothing
+   * was sent. `controller_absent` means no controller for that scope and
+   * generation accepted the request, so it was not delivered and the caller may
+   * ensure the controller and send again. A body too large for one reply is
+   * drained from the runner's spool; the request is never repeated. */
+  async browserControlHttp(request) {
+    const admission = await this.admitOperation(false);
+    if (!admission.browserControlHttpSupported) return { kind: "unsupported" };
+    const rpcTimeoutMs = request.timeoutMs + BROWSER_CONTROL_HTTP_REPLY_GRACE_MS;
+    let result;
+    try {
+      result = await this.call(
+        {
+          $case: "browserControlHttp",
+          browserControlHttp: {
+            scopeId: request.scopeId,
+            scopeGeneration: request.scopeGeneration,
+            method: request.method,
+            path: request.path,
+            bearerToken: request.bearerToken,
+            body: request.body ?? new Uint8Array(),
+            hasBody: request.body !== void 0,
+            timeoutMs: request.timeoutMs,
+            maxResponseBytes: String(request.maxResponseBytes)
+          }
+        },
+        rpcTimeoutMs,
+        admission
+      );
+    } catch (error) {
+      if (error instanceof SelfhostedControlError && error.code === ErrorCode2.ERROR_CODE_NOT_FOUND) {
+        return { kind: "controller_absent" };
+      }
+      throw error;
+    }
+    if (result.$case !== "browserControlHttp") {
+      throw new Error(`selfhosted browserControlHttp: unexpected result ${result.$case}`);
+    }
+    const response = result.browserControlHttp;
+    const totalBytes = Number(response.totalBytes);
+    if (!Number.isSafeInteger(totalBytes) || totalBytes < response.body.byteLength || totalBytes > request.maxResponseBytes) {
+      throw new Error("selfhosted browserControlHttp: response length is invalid");
+    }
+    let body = response.body;
+    if (response.spoolId) {
+      const complete = new Uint8Array(totalBytes);
+      complete.set(response.body, 0);
+      let offset = response.body.byteLength;
+      for (; ; ) {
+        const read = await this.call(
+          {
+            $case: "browserControlHttpRead",
+            browserControlHttpRead: { spoolId: response.spoolId, offset: String(offset) }
+          },
+          this.timeoutMs,
+          admission
+        );
+        if (read.$case !== "browserControlHttpRead") {
+          throw new Error(`selfhosted browserControlHttpRead: unexpected result ${read.$case}`);
+        }
+        const part = read.browserControlHttpRead;
+        if (offset + part.data.byteLength > totalBytes) {
+          throw new Error("selfhosted browserControlHttpRead: response exceeds its length");
+        }
+        complete.set(part.data, offset);
+        offset += part.data.byteLength;
+        if (part.done) break;
+        if (part.data.byteLength === 0) {
+          throw new Error("selfhosted browserControlHttpRead: spool made no progress");
+        }
+      }
+      if (offset !== totalBytes) {
+        throw new Error("selfhosted browserControlHttpRead: response is incomplete");
+      }
+      body = complete;
+    } else if (response.body.byteLength !== totalBytes) {
+      throw new Error("selfhosted browserControlHttp: response is incomplete");
+    }
+    const headers = /* @__PURE__ */ new Map();
+    for (const header of response.headers) headers.set(header.name.toLowerCase(), header.value);
+    return { kind: "response", status: response.status, headers, body };
+  }
   /** Open one browser-native frame producer and return its canonical relay
    * endpoint. This does not route through `resolveExposedPort`: that legacy
    * method allocates PTY/desktop resources based on fixed ports, while this op
@@ -12222,6 +12314,7 @@ var SelfhostedSandboxClient = class {
   operationResourcePolicySupported;
   operationCpuQuotaSupported;
   transactionalFsWriteSupported;
+  browserControlHttpSupported;
   resolveOperationAdmission;
   adoptBackgroundCommand;
   settleBackgroundCommand;
@@ -12245,6 +12338,7 @@ var SelfhostedSandboxClient = class {
     this.operationResourcePolicySupported = opts.operationResourcePolicySupported;
     this.operationCpuQuotaSupported = opts.operationCpuQuotaSupported;
     this.transactionalFsWriteSupported = opts.transactionalFsWriteSupported;
+    this.browserControlHttpSupported = opts.browserControlHttpSupported;
     this.resolveOperationAdmission = opts.resolveOperationAdmission;
     this.adoptBackgroundCommand = opts.adoptBackgroundCommand;
     this.settleBackgroundCommand = opts.settleBackgroundCommand;
@@ -12279,6 +12373,7 @@ var SelfhostedSandboxClient = class {
       } : {},
       ...this.operationCpuQuotaSupported !== void 0 ? { operationCpuQuotaSupported: this.operationCpuQuotaSupported } : {},
       transactionalFsWriteSupported: this.transactionalFsWriteSupported === true,
+      browserControlHttpSupported: this.browserControlHttpSupported === true,
       ...this.resolveOperationAdmission !== void 0 ? { resolveOperationAdmission: this.resolveOperationAdmission } : {},
       ...this.adoptBackgroundCommand !== void 0 ? { adoptBackgroundCommand: this.adoptBackgroundCommand } : {},
       ...this.settleBackgroundCommand !== void 0 ? { settleBackgroundCommand: this.settleBackgroundCommand } : {},
@@ -12350,6 +12445,7 @@ async function buildSelfhostedBackendSession(deps) {
     } : {},
     ...deps.operationCpuQuotaSupported !== void 0 ? { operationCpuQuotaSupported: deps.operationCpuQuotaSupported } : {},
     transactionalFsWriteSupported: deps.transactionalFsWriteSupported === true,
+    browserControlHttpSupported: deps.browserControlHttpSupported === true,
     ...deps.resolveOperationAdmission !== void 0 ? { resolveOperationAdmission: deps.resolveOperationAdmission } : {},
     ...deps.adoptBackgroundCommand !== void 0 ? { adoptBackgroundCommand: deps.adoptBackgroundCommand } : {},
     ...deps.settleBackgroundCommand !== void 0 ? { settleBackgroundCommand: deps.settleBackgroundCommand } : {},
@@ -15000,6 +15096,18 @@ var BrowserControlClient = class {
         "signed Channel B requires a host-fetch controller endpoint"
       );
     }
+    const native = await this.requestNative(input, BROWSER_CONTROL_MAX_JSON_BYTES);
+    if (native) {
+      let text;
+      try {
+        text = new TextDecoder("utf-8", { fatal: true }).decode(native.body);
+      } catch (error) {
+        throw new BrowserControlProtocolError("browser controller response is not UTF-8", {
+          cause: error
+        });
+      }
+      return parseEnvelope(text, native.status);
+    }
     if (this.session.execWithInput && (input.body === void 0 || Buffer.byteLength(JSON.stringify(input.body)) <= 32 * 1024)) {
       try {
         const response = await this.requestStream(input, BROWSER_CONTROL_MAX_JSON_BYTES);
@@ -15144,6 +15252,17 @@ var BrowserControlClient = class {
         "signed Channel B requires a host-fetch controller endpoint"
       );
     }
+    const nativeFrame = await this.requestNative(
+      input,
+      input.surface === "browser" ? 24 * 1024 * 1024 : COMPUTER_SCREENSHOT_MAX_BYTES
+    );
+    if (nativeFrame) {
+      if (nativeFrame.status < 200 || nativeFrame.status >= 300) {
+        parseEnvelope(new TextDecoder().decode(nativeFrame.body), nativeFrame.status);
+        throw new BrowserControlProtocolError("browser controller image response is invalid");
+      }
+      return controllerImageFrame(nativeFrame.body, nativeFrame.headers, input);
+    }
     if (this.session.execWithInput) {
       try {
         const response = await this.requestStream(
@@ -15286,8 +15405,61 @@ var BrowserControlClient = class {
     }
   }
   async controllerPort() {
+    if (!this.nativeAuthority || !this.session.ensureBrowserControl) return this.port;
+    return await this.ensureControllerPort(false);
+  }
+  /** The agent-native transport: one in-process loopback request on the
+   * Connected Machine, addressed by authority scope, with no process started.
+   * Null when the placement does not serve it; the caller then keeps its
+   * command transport. A controller that is not running receives nothing, so
+   * it is ensured and the request sent once more whatever its method. */
+  async requestNative(input, maxResponseBytes, retry = true) {
+    const authority = this.nativeAuthority;
+    if (!authority || !this.session.browserControlHttp || !this.session.ensureBrowserControl) {
+      return null;
+    }
+    const method = input.method;
+    if (method !== "GET" && method !== "POST" && method !== "PUT" && method !== "DELETE") {
+      throw new BrowserControlProtocolError("browser controller request method is invalid");
+    }
+    localControllerUrl(this.port, input.path);
+    const body = input.body === void 0 ? void 0 : new TextEncoder().encode(JSON.stringify(input.body));
+    if (body !== void 0 && body.byteLength > BROWSER_CONTROL_MAX_JSON_BYTES) {
+      throw new RangeError("browser controller request body is too large");
+    }
+    let outcome;
+    try {
+      outcome = await this.session.browserControlHttp({
+        scopeId: authority.scopeId,
+        scopeGeneration: authority.scopeGeneration,
+        method,
+        path: input.path,
+        bearerToken: requireToken(input.token, "browser controller token"),
+        ...body === void 0 ? {} : { body },
+        timeoutMs: boundedTimeout2(input.timeoutMs ?? this.timeoutMs),
+        maxResponseBytes
+      });
+    } catch (error) {
+      if (retry && method === "GET") {
+        await this.ensureControllerPort(true);
+        return await this.requestNative(input, maxResponseBytes, false);
+      }
+      throw new BrowserControlTransportError("browser controller request transport failed", {
+        cause: error
+      });
+    }
+    if (outcome.kind === "unsupported") return null;
+    if (outcome.kind === "controller_absent") {
+      if (!retry) throw new BrowserControlTransportError("browser controller is not running");
+      await this.ensureControllerPort(true);
+      return await this.requestNative(input, maxResponseBytes, false);
+    }
+    return outcome;
+  }
+  async ensureControllerPort(replace) {
     if (!this.nativeAuthority || !this.session.ensureBrowserControl) return this.port;
     const key = nativeControllerKey(this.nativeAuthority);
+    if (replace) nativeControllerPorts.delete(key);
     const cached = nativeControllerPorts.get(key);
     if (cached !== void 0) return cached;
     const ensured = await this.session.ensureBrowserControl({
@@ -18876,6 +19048,7 @@ function makeActiveBackendResolver(deps) {
         operationResourcePolicySupported: connection.operationResourcePolicySupported,
         operationCpuQuotaSupported: connection.operationCpuQuotaSupported,
         transactionalFsWriteSupported: connection.transactionalFsWriteSupported === true,
+        browserControlHttpSupported: connection.browserControlHttpSupported === true,
         // The routing proxy caches this session by sandbox+epoch, but command
         // policy and runner authority are mutable. Re-read one coherent DB
         // snapshot only when a new exec/Git is admitted.
@@ -20381,4 +20554,4 @@ export {
   collectSandboxEnvironment2 as collectSandboxEnvironment,
   parseExposedPorts2 as parseExposedPorts
 };
-//# sourceMappingURL=chunk-462CH77G.js.map
+//# sourceMappingURL=chunk-EK7IW2FR.js.map