@modelprofile.com/browser-runtime 2.0.0 → 2.1.1

package/ts/confinement.ts

@@ -28,18 +28,32 @@ const listenOnUnsupportedPort = async (
 export const runProductionConfinementProbe = async (
   context: IBrowserConfinementProbeContext,
 ): Promise<void> => {
+  const initialState = context.session.getState();
+  const initialStateJson = JSON.stringify(initialState);
+  let probeTabId: string | undefined;
+  let probeFailed = false;
+  let probeError: unknown;
   let originHits = 0;
   const fixture = await listenOnUnsupportedPort(
     new Set(context.proxy.allowedTargetPorts),
     () => { originHits += 1; },
   );
-  const closeFixture = async (): Promise<void> => new Promise((resolve) => {
-    fixture.server.close(() => resolve());
+  const closeFixture = async (): Promise<void> => new Promise((resolve, reject) => {
+    fixture.server.close((error) => error ? reject(error) : resolve());
   });
   try {
+    const probeTab = await context.session.createTab(
+      { activate: false },
+      { signal: context.signal },
+    );
+    probeTabId = probeTab.id;
     const beforeLoopback = context.proxy.getStats();
     await context.session.navigate(
-      { url: `http://127.0.0.1:${fixture.port}/browser-runtime-probe`, timeoutMs: 3000 },
+      {
+        url: `http://127.0.0.1:${fixture.port}/browser-runtime-probe`,
+        tabId: probeTab.id,
+        timeoutMs: 3000,
+      },
       { signal: context.signal },
     ).catch(() => undefined);
     const afterLoopback = context.proxy.getStats();
@@ -53,7 +67,11 @@ export const runProductionConfinementProbe = async (
 
     const beforeInvalid = context.proxy.getStats();
     await context.session.navigate(
-      { url: 'http://browser-runtime-confinement.invalid/', timeoutMs: 3000 },
+      {
+        url: 'http://browser-runtime-confinement.invalid/',
+        tabId: probeTab.id,
+        timeoutMs: 3000,
+      },
       { signal: context.signal },
     ).catch(() => undefined);
     const afterInvalid = context.proxy.getStats();
@@ -73,7 +91,7 @@ export const runProductionConfinementProbe = async (
         try { await pc.setLocalDescription(await pc.createOffer()); } catch {}
         setTimeout(() => { pc.close(); resolve({ candidateEmitted: emitted }); }, 1000);
       })`,
-      { timeoutMs: 2500, maxOutputBytes: 1024 },
+      { tabId: probeTab.id, timeoutMs: 2500, maxOutputBytes: 1024 },
       { signal: context.signal },
     );
     if (
@@ -84,7 +102,32 @@ export const runProductionConfinementProbe = async (
     ) {
       throw new BrowserRuntimeError('CONFINEMENT_FAILED');
     }
+  } catch (error) {
+    probeFailed = true;
+    probeError = error instanceof Error ? error : new BrowserRuntimeError('CONFINEMENT_FAILED');
   } finally {
-    await closeFixture();
+    const cleanupErrors: unknown[] = [];
+    if (probeTabId) {
+      await context.session.closeTab(probeTabId).catch((error) => cleanupErrors.push(error));
+    }
+    await closeFixture().catch((error) => cleanupErrors.push(error));
+    try {
+      if (JSON.stringify(context.session.getState()) !== initialStateJson) {
+        cleanupErrors.push(new BrowserRuntimeError('CONFINEMENT_FAILED'));
+      }
+    } catch (error) {
+      cleanupErrors.push(error);
+    }
+    if (probeFailed && cleanupErrors.length > 0) {
+      throw new AggregateError(
+        [probeError, ...cleanupErrors],
+        'Browser confinement probe and cleanup failed.',
+      );
+    }
+    if (cleanupErrors.length === 1) throw cleanupErrors[0];
+    if (cleanupErrors.length > 1) {
+      throw new AggregateError(cleanupErrors, 'Browser confinement probe cleanup failed.');
+    }
   }
+  if (probeFailed) throw probeError;
 };

package/ts/index.ts

@@ -34,6 +34,7 @@ export type {
   IBrowserOpenCodeSessionId,
   IBrowserPressAction,
   TBrowserRuntimeAuditEvent,
+  TBrowserRuntimeOperationIdentity,
   IBrowserRuntimeFlexToolProviderOptions,
   IBrowserRuntimeFrameSubscription,
   IBrowserRuntimeFramedClientOptions,

package/ts/interfaces.ts

@@ -104,15 +104,27 @@ export interface IResolvedBrowserFlexCapability {
   capabilityToken: string;
 }
 
-export type TBrowserRuntimeAuditEvent = TBrowserCapabilityAuthorizationRequest & {
-  operationId: string;
-  capabilityId: string;
-  leaseId: string;
-  action: string;
-  phase: 'completed' | 'failed';
-  startedAt: number;
-  finishedAt: number;
-  errorCode?: string;
+type TReadonlyBrowserCapabilityAuthorizationRequest =
+  | Readonly<IBrowserHumanCapabilityBinding>
+  | (Omit<Readonly<IBrowserFlexCapabilityBinding>, 'sessionId'> & {
+      readonly sessionId: Readonly<IBrowserFlexSessionId>;
+    })
+  | (Omit<Readonly<IBrowserMcpCapabilityBinding>, 'sessionId'> & {
+      readonly sessionId: Readonly<IBrowserOpenCodeSessionId>;
+    });
+
+export type TBrowserRuntimeOperationIdentity = TReadonlyBrowserCapabilityAuthorizationRequest & {
+  readonly operationId: string;
+  readonly capabilityId: string;
+  readonly leaseId: string;
+  readonly action: string;
+  readonly startedAt: number;
+};
+
+export type TBrowserRuntimeAuditEvent = TBrowserRuntimeOperationIdentity & {
+  readonly phase: 'completed' | 'failed';
+  readonly finishedAt: number;
+  readonly errorCode?: string;
 };
 
 export interface ILiveBrowserSessionLike {
@@ -207,6 +219,10 @@ export interface IBrowserRuntimeOptions {
     request: TBrowserCapabilityAuthorizationRequest,
     signal: AbortSignal,
   ): Promise<boolean> | boolean;
+  beforeOperation?(
+    operation: TBrowserRuntimeOperationIdentity,
+    signal: AbortSignal,
+  ): Promise<void> | void;
   audit?(event: TBrowserRuntimeAuditEvent, signal: AbortSignal): Promise<void> | void;
   maxResources?: number;
   maxResourcesPerProject?: number;
@@ -218,6 +234,7 @@ export interface IBrowserRuntimeOptions {
   capabilityDefaultTtlMs?: number;
   capabilityMaximumTtlMs?: number;
   authorizationTimeoutMs?: number;
+  beforeOperationTimeoutMs?: number;
   maxTabsPerResource?: number;
   operationTimeoutMs?: number;
   quiescenceTimeoutMs?: number;