@effect-agent/platform-cloudflare 0.1.0-beta.120 → 0.1.0-beta.122

package/src/protected-browser/binding.ts

@@ -1,10 +1,15 @@
 /// <reference types="@cloudflare/workers-types" />
-import { type Browser, type Page, type CDPSession } from "@cloudflare/puppeteer";
+
 import { Cause, Context, Crypto, Effect, Layer, Redacted, Schema, type Scope } from "effect";
 import { type InteractiveBrowserPolicy } from "effect-agent/interactive-browser";
 import { ProtectedBrowserError } from "effect-agent/protected-browser";
+import {
+  type Browser,
+  type Page,
+  type CDPSession,
+} from "puppeteer-core/lib/esm/puppeteer/puppeteer-core-browser.js";
 
-import { BrowserRunBinding } from "../internal/browser-binding.ts";
+import { BrowserRunBinding, type BrowserRunAttachment } from "../internal/browser-binding.ts";
 import {
   browserFailure,
   BrowserRunFailure,
@@ -45,6 +50,9 @@ export class BrowserRunProtectedBinding extends Context.Service<
       policy: InteractiveBrowserPolicy,
       identity?: ProtectedProviderIdentity,
     ) => Effect.Effect<ProtectedProviderSession, ProtectedBrowserError, Scope.Scope>;
+    readonly keepAlive: (
+      sessionId: Redacted.Redacted<string>,
+    ) => Effect.Effect<void, ProtectedBrowserError>;
   }
 >()("@effect-agent/platform-cloudflare/BrowserRunProtectedBinding") {}
 
@@ -78,6 +86,7 @@ const protectedBindingLayer = (options: { readonly browser: Pick<BrowserRun, "fe
         let control: CDPSession | undefined;
         let providerIdentity: ProtectedProviderIdentity | undefined;
         let browser: Browser | undefined;
+        let attachment: BrowserRunAttachment | undefined;
         let driver: ProtectedBrowserTransport | undefined;
         let invalid = false;
         // SDK acquisition may finish after interruption. Its late-reply callback must await cleanup,
@@ -89,6 +98,32 @@ const protectedBindingLayer = (options: { readonly browser: Pick<BrowserRun, "fe
           driver?.invalidate();
           if (sessionId === undefined) return "unconfirmed" as const;
 
+          // A failed resume has not acquired the host's retained provider. Release only
+          // this connection; successful attachments and new allocations own termination.
+          if (identity !== undefined && driver === undefined) {
+            if (attachment !== undefined)
+              yield* attachment.retire.pipe(
+                Effect.interruptible,
+                Effect.timeoutOrElse({
+                  duration: "1 second",
+                  orElse: () =>
+                    Effect.fail(
+                      new BrowserRunFailure({
+                        operation: "protected.disconnect",
+                        reason: "timeout",
+                      }),
+                    ),
+                }),
+                Effect.catch((error) =>
+                  reportBrowserCause("protected.disconnect", Cause.fail(error)).pipe(
+                    Effect.andThen(() => Effect.die(reportedBrowserError(error))),
+                  ),
+                ),
+              );
+
+            return "unconfirmed" as const;
+          }
+
           const cleanup = yield* lifecycle.close(sessionId).pipe(
             Effect.as("confirmed" as const),
             Effect.catchCause((cause) =>
@@ -155,7 +190,8 @@ const protectedBindingLayer = (options: { readonly browser: Pick<BrowserRun, "fe
               }
               // Resume only a host-persisted exact page. Never open a replacement page or context.
               stage = "protected.connect";
-              browser = await binding.connect(Redacted.value(sessionId), stage);
+              attachment = binding.connect(Redacted.value(sessionId), stage, signal);
+              browser = await attachment.browser;
               if (signal.aborted || invalid) {
                 await runCleanup(terminate);
                 throw new ProtectedTransportError({ reason: "stale-reference" });
@@ -203,32 +239,38 @@ const protectedBindingLayer = (options: { readonly browser: Pick<BrowserRun, "fe
                 targetId: Redacted.make(info.targetInfo.targetId),
               });
 
-              stage = "protected.interception";
-              await page.setBypassServiceWorker(true);
-              await page.setRequestInterception(true);
-              page.on("request", (request) => {
-                let allowed = policy.network._tag === "Unrestricted";
-
-                try {
-                  const url = new URL(request.url());
-
-                  allowed ||=
-                    policy.network._tag === "ExactHosts" &&
-                    url.protocol === "https:" &&
-                    !url.username &&
-                    !url.password &&
-                    policy.network.allowedHosts.includes(url.host);
-                } catch {
-                  /* Refuse malformed destinations. */
-                }
-                void (
-                  allowed && !invalid ? request.continue() : request.abort("blockedbyclient")
-                ).catch(async (cause) => {
-                  invalid = true;
-                  driver?.invalidate();
-                  await runCleanup(reportBrowserCause("protected.interception", Cause.fail(cause)));
+              // Unrestricted passes need no attachment-local network enforcement. Leave their
+              // service workers and requests alone, including across host-owned detach/resume.
+              if (policy.network._tag !== "Unrestricted") {
+                stage = "protected.interception";
+                await page.setBypassServiceWorker(true);
+                await page.setRequestInterception(true);
+                page.on("request", (request) => {
+                  let allowed = false;
+
+                  try {
+                    const url = new URL(request.url());
+
+                    allowed =
+                      policy.network._tag === "ExactHosts" &&
+                      url.protocol === "https:" &&
+                      !url.username &&
+                      !url.password &&
+                      policy.network.allowedHosts.includes(url.host);
+                  } catch {
+                    /* Refuse malformed destinations. */
+                  }
+                  void (
+                    allowed && !invalid ? request.continue() : request.abort("blockedbyclient")
+                  ).catch(async (cause) => {
+                    invalid = true;
+                    driver?.invalidate();
+                    await runCleanup(
+                      reportBrowserCause("protected.interception", Cause.fail(cause)),
+                    );
+                  });
                 });
-              });
+              }
               if (signal.aborted || invalid) {
                 await runCleanup(terminate);
                 throw new ProtectedTransportError({ reason: "stale-reference" });
@@ -253,8 +295,26 @@ const protectedBindingLayer = (options: { readonly browser: Pick<BrowserRun, "fe
             orElse: () =>
               Effect.fail(new BrowserRunFailure({ operation: stage, reason: "timeout" })),
           }),
-          Effect.catch((error) =>
-            reportBrowserCause(stage, Cause.fail(error)).pipe(
+          Effect.catch((error) => {
+            if (identity !== undefined && driver === undefined)
+              return reportBrowserCause(stage, Cause.fail(error)).pipe(
+                Effect.andThen(
+                  Effect.fail(
+                    reportedBrowserError(
+                      new ProtectedBrowserError({
+                        ...failure(),
+                        reason: error.reason === "timeout" ? "timeout" : "provider",
+                        cleanup: "not-requested",
+                      }),
+                    ),
+                  ),
+                ),
+                // A disposal defect stays alongside the original failure. Only a pure typed
+                // failure proves that this pre-handle attachment is safe to relinquish.
+                Effect.ensuring(close),
+              );
+
+            return reportBrowserCause(stage, Cause.fail(error)).pipe(
               Effect.andThen(close),
               Effect.flatMap((cleanup) =>
                 Effect.fail(
@@ -267,8 +327,8 @@ const protectedBindingLayer = (options: { readonly browser: Pick<BrowserRun, "fe
                   ),
                 ),
               ),
-            ),
-          ),
+            );
+          }),
         );
 
         driver = yield* makeProtectedNativeTransport(policy).pipe(
@@ -334,7 +394,38 @@ const protectedBindingLayer = (options: { readonly browser: Pick<BrowserRun, "fe
         };
       }, Effect.withTracerEnabled(false));
 
-      return { open };
+      const keepAlive = Effect.fn("BrowserRunProtectedBinding.keepAlive")(function* (
+        sessionId: Redacted.Redacted<string>,
+      ) {
+        const failure = (reason: ProtectedBrowserError["reason"]) =>
+          new ProtectedBrowserError({
+            reason,
+            dispatch: "not-dispatched",
+            milestone: "none",
+            observation: "protected",
+            cleanup: "not-requested",
+          });
+
+        const id = yield* Schema.decodeEffect(ProtectedProviderIdentity.fields.sessionId)(
+          sessionId,
+        ).pipe(Effect.mapError(() => failure("denied")));
+
+        yield* binding.keepAlive(Redacted.value(id)).pipe(
+          Effect.timeoutOrElse({
+            duration: "10 seconds",
+            orElse: () =>
+              Effect.fail(
+                new BrowserRunFailure({ operation: "protected.keepAlive", reason: "timeout" }),
+              ),
+          }),
+          Effect.tapError((error) => reportBrowserCause("protected.keepAlive", Cause.fail(error))),
+          Effect.mapError((error) =>
+            reportedBrowserError(failure(error.reason === "timeout" ? "timeout" : "provider")),
+          ),
+        );
+      }, Effect.withTracerEnabled(false));
+
+      return { open, keepAlive };
     }),
   ).pipe(Layer.provide(BrowserRunBinding.layer(options.browser)));
 

package/src/protected-browser/host.ts

@@ -83,6 +83,14 @@ export interface BrowserRunProtectedSession {
 export class BrowserRunProtectedHost extends Context.Service<
   BrowserRunProtectedHost,
   {
+    /**
+     * Refresh provider inactivity on an exact retained session with one browser-level command.
+     * Internally scoped and bounded to ten seconds; releases only its own connection on every exit.
+     * Does not acquire a page, transfer control, extend host expiry, or close the provider on failure.
+     */
+    readonly keepAlive: (
+      sessionId: Redacted.Redacted<string>,
+    ) => Effect.Effect<void, ProtectedBrowserError>;
     readonly open: (
       policy: InteractiveBrowserPolicy,
     ) => Effect.Effect<
@@ -90,6 +98,13 @@ export class BrowserRunProtectedHost extends Context.Service<
       ProtectedBrowserError,
       Scope.Scope | BrowserCredentialAccess
     >;
+    /**
+     * A pure pre-handle provider failure with not-dispatched/none/not-requested evidence
+     * retires this attempt's SDK callbacks and confirms local socket closure before returning
+     * (or never starts SDK initialization). Raw retirement failure remains a mixed defect.
+     * This does not confirm provider health or undo already-sent CDP; the host still owns
+     * atomic claim restoration and must exclude defects, interruption, and post-handle errors.
+     */
     readonly resume: (
       checkpoint: BrowserRunProtectedCheckpoint,
     ) => Effect.Effect<
@@ -362,6 +377,7 @@ export const browserRunProtectedHostLayer = () =>
       }, Effect.withTracerEnabled(false));
 
       return {
+        keepAlive: binding.keepAlive,
         open: (policy: InteractiveBrowserPolicy) => open(policy),
         resume: (checkpoint: BrowserRunProtectedCheckpoint) =>
           Schema.decodeEffect(BrowserRunProtectedCheckpoint)(checkpoint).pipe(

package/src/protected-browser/native.ts

@@ -1,5 +1,5 @@
 /// <reference types="@cloudflare/workers-types" />
-import type { Browser, Frame, JSHandle, Page } from "@cloudflare/puppeteer";
+
 import { Cause, Clock, Context, Crypto, Effect, Redacted, Schema, type Scope } from "effect";
 import { type InteractiveBrowserPolicy } from "effect-agent/interactive-browser";
 import {
@@ -7,6 +7,12 @@ import {
   CredentialTarget,
   ProtectedBrowserControl,
 } from "effect-agent/protected-browser";
+import type {
+  Browser,
+  Frame,
+  JSHandle,
+  Page,
+} from "puppeteer-core/lib/esm/puppeteer/puppeteer-core-browser.js";
 
 import {
   browserFailure,
@@ -22,14 +28,6 @@ import {
   type ProtectedBrowserTransport,
 } from "./policy.ts";
 
-// The pinned SDK implements this method but strips its internal declaration from lib/types.d.ts.
-// Keep the declaration narrow and refuse runtimes without it. No main-world fallback is safe.
-declare module "@cloudflare/puppeteer" {
-  interface Frame {
-    isolatedRealm(): { evaluateHandle(source: string): Promise<JSHandle<unknown>> };
-  }
-}
-
 const Description = Schema.Struct({
   role: ProtectedBrowserControl.fields.role,
   formIndex: Schema.Natural,