@opengeni/sdk 0.52.1 → 1.0.0

package/dist/{chunk-MZWTWOX6.js → chunk-NC57YMUO.js}

@@ -1,3 +1,13 @@
+import {
+  OpenGeniApiError
+} from "./chunk-V6GIY62B.js";
+
+// ../contracts/src/browser-storage.ts
+var EPHEMERAL_CHROMIUM_DRIVER_ID = "opengeni.cdp.ephemeral-context.v1";
+function browserSessionStorageMode(session) {
+  return session.driverId === EPHEMERAL_CHROMIUM_DRIVER_ID ? "ephemeral_context" : "private_profile";
+}
+
 // src/interaction.ts
 var INTERACTION_PROTOCOL_VERSION = 1;
 var BROWSER_CONTROL_WEBSOCKET_PROTOCOL = "opengeni.browser.v1";
@@ -7,16 +17,262 @@ var BROWSER_CONTROL_MAX_FRAME_HEADER_BYTES = 64 * 1024;
 var BROWSER_FRAME_MAX_BYTES = 24 * 1024 * 1024;
 var BROWSER_FRAME_MAX_DIMENSION = 32768;
 var BROWSER_FRAME_MAX_PIXELS = 1e8;
+function interactionControlFailureFromError(error) {
+  if (!(error instanceof OpenGeniApiError)) return null;
+  const details = error.details;
+  if (!details || details.interactionLayer !== "connected_machine") return null;
+  const surface = details.interactionSurface;
+  const code = details.controlFailureCode;
+  if (surface !== "browser" && surface !== "computer" || !isControlFailureCode(code)) {
+    return null;
+  }
+  const controlRequestId = boundedOpaqueCorrelation(details.controlRequestId);
+  return {
+    layer: "connected_machine",
+    surface,
+    code,
+    retryable: error.retryable,
+    outcomeUnknown: error.outcomeUnknown,
+    requestId: error.correlationId,
+    controlRequestId,
+    message: error.message
+  };
+}
+function isControlFailureCode(value) {
+  return typeof value === "string" && [
+    "unknown",
+    "unsupported",
+    "os",
+    "not_found",
+    "consent_required",
+    "timeout",
+    "draining",
+    "protocol",
+    "stream",
+    "agent_offline",
+    "fenced",
+    "payload_too_large"
+  ].includes(value);
+}
+function boundedOpaqueCorrelation(value) {
+  return typeof value === "string" && value.length <= 128 && /^[A-Za-z0-9._:-]+$/u.test(value) ? value : void 0;
+}
 var OpenGeniInteractionClient = class {
   attachedBrowsers;
+  authRuns;
   browsers;
   computers;
   identities;
+  interventions;
+  networkRoutes;
+  siteAuthConnections;
   constructor(transport) {
     this.attachedBrowsers = new AttachedBrowserDeviceCollection(transport);
+    this.authRuns = new AuthRunCollection(transport);
     this.browsers = new BrowserSessionCollection(transport);
     this.computers = new ComputerSessionCollection(transport);
     this.identities = new BrowserIdentityCollection(transport);
+    this.interventions = new InteractionInterventionCollection(transport);
+    this.networkRoutes = new NetworkRouteCollection(transport);
+    this.siteAuthConnections = new SiteAuthConnectionCollection(transport);
+  }
+};
+var NetworkRouteCollection = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async list(workspaceId, options = {}) {
+    return await this.transport.listNetworkRoutes(workspaceId, options);
+  }
+  route(workspaceId, networkRouteId) {
+    return new NetworkRouteResource(this.transport, workspaceId, networkRouteId);
+  }
+  async create(workspaceId, request, options = {}) {
+    const response = await this.transport.createNetworkRoute(workspaceId, request, options);
+    return this.route(workspaceId, response.route.id);
+  }
+};
+var NetworkRouteResource = class {
+  constructor(transport, workspaceId, id) {
+    this.transport = transport;
+    this.workspaceId = workspaceId;
+    this.id = id;
+  }
+  async get(options = {}) {
+    return await this.transport.getNetworkRoute(this.workspaceId, this.id, options);
+  }
+  async update(request, options = {}) {
+    return await this.transport.updateNetworkRoute(this.workspaceId, this.id, request, options);
+  }
+};
+var SiteAuthConnectionCollection = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async list(workspaceId, options = {}) {
+    return await this.transport.listSiteAuthConnections(workspaceId, options);
+  }
+  connection(workspaceId, connectionId) {
+    return new SiteAuthConnectionResource(this.transport, workspaceId, connectionId);
+  }
+  async create(workspaceId, request, options = {}) {
+    const response = await this.transport.createSiteAuthConnection(workspaceId, request, options);
+    return this.connection(workspaceId, response.connection.id);
+  }
+};
+var SiteAuthConnectionResource = class {
+  constructor(transport, workspaceId, id) {
+    this.transport = transport;
+    this.workspaceId = workspaceId;
+    this.id = id;
+  }
+  async get(options = {}) {
+    return await this.transport.getSiteAuthConnection(this.workspaceId, this.id, options);
+  }
+  async update(request, options = {}) {
+    return await this.transport.updateSiteAuthConnection(
+      this.workspaceId,
+      this.id,
+      request,
+      options
+    );
+  }
+};
+var AuthRunCollection = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async list(workspaceId, options = {}) {
+    return await this.transport.listAuthRuns(workspaceId, options);
+  }
+  async get(workspaceId, authRunId, options = {}) {
+    return await this.transport.getAuthRun(workspaceId, authRunId, options);
+  }
+  run(workspaceId, browserSessionId, authRunId) {
+    return new AuthRunResource(this.transport, workspaceId, browserSessionId, authRunId);
+  }
+};
+var BrowserAuthRunCollection = class {
+  constructor(transport, workspaceId, browserSessionId) {
+    this.transport = transport;
+    this.workspaceId = workspaceId;
+    this.browserSessionId = browserSessionId;
+  }
+  async list(options = {}) {
+    return await this.transport.listAuthRuns(this.workspaceId, {
+      ...options,
+      browserSessionId: this.browserSessionId
+    });
+  }
+  run(authRunId) {
+    return new AuthRunResource(this.transport, this.workspaceId, this.browserSessionId, authRunId);
+  }
+  async start(request, options = {}) {
+    const response = await this.transport.startBrowserAuthRun(
+      this.workspaceId,
+      this.browserSessionId,
+      request,
+      options
+    );
+    return this.run(response.run.id);
+  }
+};
+var AuthRunResource = class {
+  constructor(transport, workspaceId, browserSessionId, id) {
+    this.transport = transport;
+    this.workspaceId = workspaceId;
+    this.browserSessionId = browserSessionId;
+    this.id = id;
+  }
+  async get(options = {}) {
+    const run = await this.transport.getAuthRun(this.workspaceId, this.id, options);
+    if (run.browserSessionId !== this.browserSessionId) {
+      throw new Error("AuthRun belongs to another BrowserSession");
+    }
+    return run;
+  }
+  async report(request, options = {}) {
+    return await this.transport.reportBrowserAuthRun(
+      this.workspaceId,
+      this.browserSessionId,
+      this.id,
+      request,
+      options
+    );
+  }
+  async protectedFill(request, options = {}) {
+    return await this.transport.protectedBrowserAuthFill(
+      this.workspaceId,
+      this.browserSessionId,
+      this.id,
+      request,
+      options
+    );
+  }
+  async advanceExternal(request, options = {}) {
+    return await this.transport.advanceExternalBrowserAuthRun(
+      this.workspaceId,
+      this.browserSessionId,
+      this.id,
+      request,
+      options
+    );
+  }
+  /** Human-session helper. Hosted provider URLs never appear in model tools. */
+  async openExternalFlow(request, options = {}) {
+    return await this.transport.openExternalBrowserAuthFlow(
+      this.workspaceId,
+      this.browserSessionId,
+      this.id,
+      request,
+      options
+    );
+  }
+  async verify(request, options = {}) {
+    return await this.transport.verifyBrowserAuthRun(
+      this.workspaceId,
+      this.browserSessionId,
+      this.id,
+      request,
+      options
+    );
+  }
+};
+var InteractionInterventionCollection = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async list(workspaceId, options = {}) {
+    return await this.transport.listInteractionInterventions(workspaceId, options);
+  }
+  intervention(workspaceId, interventionId) {
+    return new InteractionInterventionResource(this.transport, workspaceId, interventionId);
+  }
+  async create(workspaceId, request, options = {}) {
+    const response = await this.transport.createInteractionIntervention(
+      workspaceId,
+      request,
+      options
+    );
+    return this.intervention(workspaceId, response.intervention.id);
+  }
+};
+var InteractionInterventionResource = class {
+  constructor(transport, workspaceId, id) {
+    this.transport = transport;
+    this.workspaceId = workspaceId;
+    this.id = id;
+  }
+  async get(options = {}) {
+    return await this.transport.getInteractionIntervention(this.workspaceId, this.id, options);
+  }
+  async resolve(request, options = {}) {
+    return await this.transport.resolveInteractionIntervention(
+      this.workspaceId,
+      this.id,
+      request,
+      options
+    );
   }
 };
 var AttachedBrowserDeviceCollection = class {
@@ -67,6 +323,9 @@ var BrowserIdentityResource = class {
   async revisions(options = {}) {
     return await this.transport.listBrowserRevisions(this.workspaceId, this.id, options);
   }
+  async update(request, options = {}) {
+    return await this.transport.updateBrowserIdentity(this.workspaceId, this.id, request, options);
+  }
 };
 var BrowserSessionCollection = class {
   constructor(transport) {
@@ -85,7 +344,12 @@ var BrowserSessionCollection = class {
   async currentOrOpen(options) {
     const requestOptions = options.signal ? { signal: options.signal } : {};
     const listed = await this.list(options.workspaceId, requestOptions);
-    const current = newestRelevantBrowser(listed.sessions, options.associationSessionId);
+    const current = newestRelevantBrowser(
+      listed.sessions.filter(
+        (session) => browserSessionStorageMode(session) === (options.storageMode ?? "private_profile")
+      ),
+      options.associationSessionId
+    );
     if (current) {
       const resource = this.session(options.workspaceId, current.id);
       if (current.lifecycle === "suspended") {
@@ -104,9 +368,11 @@ var BrowserSessionCollection = class {
         ...options.name !== void 0 ? { name: options.name } : {},
         ...options.initialUrl !== void 0 ? { initialUrl: options.initialUrl } : {},
         ...options.headless !== void 0 ? { headless: options.headless } : {},
+        ...options.storageMode !== void 0 ? { storageMode: options.storageMode } : {},
         ...options.placement !== void 0 ? { placement: options.placement } : {},
         ...options.identityId !== void 0 ? { identityId: options.identityId } : {},
         ...options.baseRevisionId !== void 0 ? { baseRevisionId: options.baseRevisionId } : {},
+        ...options.networkRouteId !== void 0 ? { networkRouteId: options.networkRouteId } : {},
         ...options.linkedComputerSessionId !== void 0 ? { linkedComputerSessionId: options.linkedComputerSessionId } : {}
       },
       requestOptions
@@ -118,9 +384,15 @@ var BrowserSessionResource = class {
     this.transport = transport;
     this.workspaceId = workspaceId;
     this.id = id;
+    this.auth = new BrowserAuthRunCollection(transport, workspaceId, id);
+    this.clipboard = new BrowserClipboardResource(transport, workspaceId, id);
+    this.downloads = new BrowserDownloadCollection(transport, workspaceId, id);
     this.tabs = new BrowserTargetCollection(transport, workspaceId, id);
     this.targets = this.tabs;
   }
+  auth;
+  clipboard;
+  downloads;
   tabs;
   /** Alias for hosts that prefer the protocol term. */
   targets;
@@ -130,6 +402,30 @@ var BrowserSessionResource = class {
   async observe(targetId, options = {}) {
     return await this.transport.observeBrowserTarget(this.workspaceId, this.id, targetId, options);
   }
+  async targetState(targetId, options = {}) {
+    return await this.transport.getBrowserTargetState(this.workspaceId, this.id, targetId, options);
+  }
+  async readDom(targetId, request, options = {}) {
+    return await this.transport.readBrowserDom(
+      this.workspaceId,
+      this.id,
+      targetId,
+      request,
+      options
+    );
+  }
+  async capture(targetId, options = {}, captureOptions = {}) {
+    return await this.transport.captureBrowserTarget(
+      this.workspaceId,
+      this.id,
+      targetId,
+      options,
+      captureOptions
+    );
+  }
+  async screenshot(targetId, captureOptions = {}, options = {}) {
+    return await this.capture(targetId, options, captureOptions);
+  }
   async act(request, options = {}) {
     return await this.transport.actInBrowser(this.workspaceId, this.id, request, options);
   }
@@ -174,6 +470,83 @@ var BrowserSessionResource = class {
     return await this.transport.endBrowserSession(this.workspaceId, this.id, request, options);
   }
 };
+var BrowserClipboardResource = class {
+  constructor(transport, workspaceId, browserSessionId) {
+    this.transport = transport;
+    this.workspaceId = workspaceId;
+    this.browserSessionId = browserSessionId;
+  }
+  async read(options = {}) {
+    const clipboard = await this.transport.readBrowserClipboard(
+      this.workspaceId,
+      this.browserSessionId,
+      options
+    );
+    if (clipboard.browserSessionId !== this.browserSessionId) {
+      throw new Error("Browser clipboard belongs to another BrowserSession");
+    }
+    return clipboard;
+  }
+};
+var BrowserDownloadCollection = class {
+  constructor(transport, workspaceId, browserSessionId) {
+    this.transport = transport;
+    this.workspaceId = workspaceId;
+    this.browserSessionId = browserSessionId;
+  }
+  async list(options = {}) {
+    return await this.transport.listBrowserDownloads(
+      this.workspaceId,
+      this.browserSessionId,
+      options
+    );
+  }
+  download(downloadId) {
+    return new BrowserDownloadResource(
+      this.transport,
+      this.workspaceId,
+      this.browserSessionId,
+      downloadId
+    );
+  }
+};
+var BrowserDownloadResource = class {
+  constructor(transport, workspaceId, browserSessionId, id) {
+    this.transport = transport;
+    this.workspaceId = workspaceId;
+    this.browserSessionId = browserSessionId;
+    this.id = id;
+  }
+  async get(options = {}) {
+    const download = await this.transport.getBrowserDownload(
+      this.workspaceId,
+      this.browserSessionId,
+      this.id,
+      options
+    );
+    if (download.browserSessionId !== this.browserSessionId) {
+      throw new Error("BrowserDownload belongs to another BrowserSession");
+    }
+    return download;
+  }
+  /** Publish this exact private browser download into the source session's
+   * workspace. Pass an operationId when the caller needs retry identity across
+   * process boundaries; otherwise one is generated for this call. */
+  async saveToWorkspace(destinationPath, options = {}) {
+    const { operationId = crypto.randomUUID(), overwrite = false, ...requestOptions } = options;
+    const response = await this.transport.saveBrowserDownload(
+      this.workspaceId,
+      this.browserSessionId,
+      this.id,
+      { operationId, destinationPath, overwrite },
+      requestOptions
+    );
+    if (response.download.id !== this.id || response.download.browserSessionId !== this.browserSessionId) {
+      throw new Error("BrowserDownload save returned another resource");
+    }
+    return response;
+  }
+};
 var BrowserTargetCollection = class {
   constructor(transport, workspaceId, browserSessionId) {
     this.transport = transport;
@@ -252,16 +625,21 @@ var ComputerSessionResource = class {
     this.id = id;
     this.targets = new ComputerTargetCollection(transport, workspaceId, id);
     this.apps = this.targets;
+    this.clipboard = new ComputerClipboardResource(transport, workspaceId, id);
   }
   targets;
   /** Native application/window targets are also the public app collection. */
   apps;
+  clipboard;
   async get(options = {}) {
     return await this.transport.getComputerSession(this.workspaceId, this.id, options);
   }
   async observe(targetId, options = {}) {
     return await this.transport.observeComputerTarget(this.workspaceId, this.id, targetId, options);
   }
+  async capture(targetId, options = {}) {
+    return await this.transport.captureComputerTarget(this.workspaceId, this.id, targetId, options);
+  }
   async act(request, options = {}) {
     return await this.transport.actInComputer(this.workspaceId, this.id, request, options);
   }
@@ -276,6 +654,12 @@ var ComputerSessionResource = class {
   async attach(request, options = {}) {
     return await this.transport.attachComputerSession(this.workspaceId, this.id, request, options);
   }
+  async inputPosture(options = {}) {
+    if (!this.transport.getComputerInputPosture) {
+      throw new Error("Computer input posture requires a current interaction transport.");
+    }
+    return await this.transport.getComputerInputPosture(this.workspaceId, this.id, options);
+  }
   async heartbeat(options = {}) {
     return await this.transport.heartbeatComputerSession(this.workspaceId, this.id, options);
   }
@@ -283,6 +667,24 @@ var ComputerSessionResource = class {
     return await this.transport.endComputerSession(this.workspaceId, this.id, request, options);
   }
 };
+var ComputerClipboardResource = class {
+  constructor(transport, workspaceId, computerSessionId) {
+    this.transport = transport;
+    this.workspaceId = workspaceId;
+    this.computerSessionId = computerSessionId;
+  }
+  async read(options = {}) {
+    const clipboard = await this.transport.readComputerClipboard(
+      this.workspaceId,
+      this.computerSessionId,
+      options
+    );
+    if (clipboard.computerSessionId !== this.computerSessionId) {
+      throw new Error("Computer clipboard belongs to another ComputerSession");
+    }
+    return clipboard;
+  }
+};
 var ComputerTargetCollection = class {
   constructor(transport, workspaceId, computerSessionId) {
     this.transport = transport;
@@ -307,6 +709,7 @@ function browserFrameSocketUrl(attachment, options = {}) {
   else if (url.protocol !== "ws:" && url.protocol !== "wss:") {
     throw new Error("browser frame attachment did not contain an HTTP or WebSocket URL");
   }
+  upgradeMixedContentWebSocket(url);
   if (options.format !== void 0) url.searchParams.set("format", options.format);
   setBoundedIntegerQuery(url, "quality", options.quality, 1, 100);
   setBoundedIntegerQuery(url, "maxWidth", options.maxWidth, 1, 4096);
@@ -324,6 +727,7 @@ function computerFrameSocketUrl(attachment, options = {}) {
   else if (url.protocol !== "ws:" && url.protocol !== "wss:") {
     throw new Error("computer frame attachment did not contain an HTTP or WebSocket URL");
   }
+  upgradeMixedContentWebSocket(url);
   if (options.format !== void 0) url.searchParams.set("format", options.format);
   setBoundedIntegerQuery(url, "quality", options.quality, 1, 100);
   setBoundedIntegerQuery(url, "maxWidth", options.maxWidth, 1, 4096);
@@ -524,6 +928,27 @@ function parseComputerFrameMetadata(value) {
   }
   return metadata;
 }
+function decodeComputerFrameMetadataHeader(value) {
+  if (!value || value.length > 32 * 1024 || !/^[A-Za-z0-9_-]+$/u.test(value)) {
+    throw new Error("computer frame metadata header is invalid");
+  }
+  const normalized = value.replace(/-/gu, "+").replace(/_/gu, "/");
+  const padded = normalized.padEnd(Math.ceil(normalized.length / 4) * 4, "=");
+  let decoded;
+  try {
+    decoded = atob(padded);
+  } catch {
+    throw new Error("computer frame metadata header is invalid");
+  }
+  const bytes = Uint8Array.from(decoded, (character) => character.charCodeAt(0));
+  let metadata;
+  try {
+    metadata = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+  } catch {
+    throw new Error("computer frame metadata header is invalid");
+  }
+  return parseComputerFrameMetadata(metadata);
+}
 function newestRelevantBrowser(sessions, associationSessionId) {
   const live = sessions.filter(
     (session) => !["ending", "ended", "failed", "lost"].includes(session.lifecycle) && session.associations.some((association) => association.sessionId === associationSessionId)
@@ -552,6 +977,10 @@ function computerRelevance(session, associationSessionId) {
   const used = Date.parse(session.lastUsedAt);
   return Math.max(association, Number.isFinite(used) ? used : 0);
 }
+function upgradeMixedContentWebSocket(url) {
+  const protocol = globalThis.location?.protocol;
+  if (protocol === "https:" && url.protocol === "ws:") url.protocol = "wss:";
+}
 function setBoundedIntegerQuery(url, name, value, min, max) {
   if (value === void 0) return;
   if (!Number.isSafeInteger(value) || value < min || value > max) {
@@ -640,22 +1069,37 @@ export {
   BROWSER_FRAME_MAX_BYTES,
   BROWSER_FRAME_MAX_DIMENSION,
   BROWSER_FRAME_MAX_PIXELS,
+  interactionControlFailureFromError,
   OpenGeniInteractionClient,
+  NetworkRouteCollection,
+  NetworkRouteResource,
+  SiteAuthConnectionCollection,
+  SiteAuthConnectionResource,
+  AuthRunCollection,
+  BrowserAuthRunCollection,
+  AuthRunResource,
+  InteractionInterventionCollection,
+  InteractionInterventionResource,
   AttachedBrowserDeviceCollection,
   AttachedBrowserDeviceResource,
   BrowserIdentityCollection,
   BrowserIdentityResource,
   BrowserSessionCollection,
   BrowserSessionResource,
+  BrowserClipboardResource,
+  BrowserDownloadCollection,
+  BrowserDownloadResource,
   BrowserTargetCollection,
   ComputerSessionCollection,
   ComputerSessionResource,
+  ComputerClipboardResource,
   ComputerTargetCollection,
   browserFrameSocketUrl,
   computerFrameSocketUrl,
   decodeBrowserFrameMessage,
   decodeComputerFrameMessage,
   parseBrowserFrameMetadata,
-  parseComputerFrameMetadata
+  parseComputerFrameMetadata,
+  decodeComputerFrameMetadataHeader
 };
-//# sourceMappingURL=chunk-MZWTWOX6.js.map
+//# sourceMappingURL=chunk-NC57YMUO.js.map