@effect-agent/platform-cloudflare 0.1.0-beta.37 → 0.1.0-beta.39

package/dist/interactive-browser.d.mts

@@ -1,5 +1,23 @@
 import { Context, Effect, Layer, Redacted, Schema, Scope } from "effect";
 import { BrowserHandle, InteractiveBrowser, InteractiveBrowserError, InteractiveBrowserPolicy, InteractiveBrowserPolicyDeniedError, SandboxImplementation } from "@effect-agent/sandbox";
+import { HttpClient } from "effect/unstable/http";
+//#region src/browser-session-lifecycle.d.ts
+declare const BrowserRunCleanupError_base: Schema.Class<BrowserRunCleanupError, Schema.TaggedStruct<"BrowserRunCleanupError", {
+  readonly reason: Schema.Literals<readonly ["configuration", "authorization", "rate-limited", "provider", "malformed", "timeout", "pending"]>;
+  readonly status: Schema.optionalKey<Schema.Int>;
+}>, import("effect/Cause").YieldableError>;
+declare class BrowserRunCleanupError extends BrowserRunCleanupError_base {}
+interface BrowserRunLifecycleOptions {
+  readonly accountId: string;
+  readonly apiToken: Redacted.Redacted<string>;
+}
+declare const BrowserRunSessionLifecycle_base: Context.ServiceClass<BrowserRunSessionLifecycle, "@effect-agent/platform-cloudflare/BrowserRunSessionLifecycle", {
+  readonly close: (sessionId: Redacted.Redacted<string>) => Effect.Effect<void, BrowserRunCleanupError>;
+}>;
+declare class BrowserRunSessionLifecycle extends BrowserRunSessionLifecycle_base {
+  static layer(options: BrowserRunLifecycleOptions): Layer.Layer<BrowserRunSessionLifecycle, BrowserRunCleanupError, HttpClient.HttpClient>;
+}
+//#endregion
 //#region src/interactive-browser.d.ts
 declare const browserRunInteractiveImplementation: SandboxImplementation;
 declare const BrowserRunViewport_base: Schema.Class<BrowserRunViewport, Schema.Struct<{
@@ -83,14 +101,15 @@ interface BrowserRunInteractiveBrowser {
 }
 declare const BrowserRunInteractiveBinding_base: Context.ServiceClass<BrowserRunInteractiveBinding, "@effect-agent/platform-cloudflare/BrowserRunInteractiveBinding", {
   readonly launch: (keepAliveMillis: number) => Promise<BrowserRunInteractiveBrowser>;
-  readonly connect: (sessionId: string) => Promise<BrowserRunInteractiveBrowser>;
+  /** Success proves whole-browser termination or exact-session absence. */
+  readonly closeSession: (sessionId: Redacted.Redacted<string>) => Effect.Effect<void, InteractiveBrowserError>;
 }>;
 /** Host-supplied Browser Run binding projected into one fakeable launch operation. */
 declare class BrowserRunInteractiveBinding extends BrowserRunInteractiveBinding_base {
   static layer(options: {
     readonly browser: BrowserRun;
     readonly viewport?: BrowserRunViewport;
-  }): Layer.Layer<BrowserRunInteractiveBinding, InteractiveBrowserPolicyDeniedError>;
+  }): Layer.Layer<BrowserRunInteractiveBinding, InteractiveBrowserPolicyDeniedError, BrowserRunSessionLifecycle>;
 }
 interface BrowserRunInteractiveSession {
   readonly handle: BrowserHandle;
@@ -108,6 +127,7 @@ interface BrowserRunInteractiveSession {
   readonly close: Effect.Effect<void, InteractiveBrowserError>;
 }
 declare const BrowserRunInteractiveHost_base: Context.ServiceClass<BrowserRunInteractiveHost, "@effect-agent/platform-cloudflare/BrowserRunInteractiveHost", {
+  readonly cleanupSemantics?: "confirmed-terminal";
   readonly open: (policy: InteractiveBrowserPolicy) => Effect.Effect<BrowserRunInteractiveSession, InteractiveBrowserError, Scope.Scope>;
   readonly closeSession: (sessionId: Redacted.Redacted<string>) => Effect.Effect<void, InteractiveBrowserError>;
 }>;
@@ -120,5 +140,5 @@ declare const browserRunInteractiveHostLayer: () => Layer.Layer<BrowserRunIntera
 /** Worker-only generic adapter; Cloudflare identity and controls remain host-only. */
 declare const browserRunInteractiveLayer: () => Layer.Layer<InteractiveBrowser, never, BrowserRunInteractiveBinding>;
 //#endregion
-export { BrowserRunCloudflareCommand, BrowserRunHandoffRequest, BrowserRunHandoffResult, BrowserRunHandoffState, BrowserRunInteractiveBinding, BrowserRunInteractiveBrowser, BrowserRunInteractiveCdpSession, BrowserRunInteractiveContext, BrowserRunInteractiveHost, BrowserRunInteractivePage, BrowserRunInteractiveRequest, BrowserRunInteractiveRequestListener, BrowserRunInteractiveSession, BrowserRunLiveViewRequest, BrowserRunLiveViewResult, BrowserRunViewport, browserRunInteractiveHostLayer, browserRunInteractiveImplementation, browserRunInteractiveLayer, isBrowserRunUndispatchedActionError };
+export { BrowserRunCleanupError, BrowserRunCloudflareCommand, BrowserRunHandoffRequest, BrowserRunHandoffResult, BrowserRunHandoffState, BrowserRunInteractiveBinding, BrowserRunInteractiveBrowser, BrowserRunInteractiveCdpSession, BrowserRunInteractiveContext, BrowserRunInteractiveHost, BrowserRunInteractivePage, BrowserRunInteractiveRequest, BrowserRunInteractiveRequestListener, BrowserRunInteractiveSession, BrowserRunLiveViewRequest, BrowserRunLiveViewResult, BrowserRunSessionLifecycle, BrowserRunViewport, browserRunInteractiveHostLayer, browserRunInteractiveImplementation, browserRunInteractiveLayer, isBrowserRunUndispatchedActionError };
 //# sourceMappingURL=interactive-browser.d.mts.map

package/dist/interactive-browser.mjs

@@ -1,6 +1,86 @@
-import { Context, Duration, Effect, Layer, Option, Redacted, Ref, Schema, Semaphore } from "effect";
+import { Clock, Context, Duration, Effect, Layer, Option, Redacted, Ref, Schema, Semaphore, Stream } from "effect";
 import { BrowserActionResult, BrowserNavigationResult, BrowserScreenshotRequest, BrowserScrollRequest, BrowserTextResult, InteractiveBrowser, InteractiveBrowserActionError, InteractiveBrowserBusyError, InteractiveBrowserCapacityError, InteractiveBrowserExpiredError, InteractiveBrowserLimitError, InteractiveBrowserPolicy, InteractiveBrowserPolicyDeniedError, InteractiveBrowserProtocolError, InteractiveBrowserTargetUrl, InteractiveBrowserUnsupportedError, PageScreenshotResult, SandboxImplementation } from "@effect-agent/sandbox";
 import puppeteer from "@cloudflare/puppeteer";
+import { FetchHttpClient, HttpClient, HttpClientRequest } from "effect/unstable/http";
+//#region src/browser-session-lifecycle.ts
+var BrowserRunCleanupError = class extends Schema.TaggedError()("BrowserRunCleanupError", {
+	reason: Schema.Literals([
+		"configuration",
+		"authorization",
+		"rate-limited",
+		"provider",
+		"malformed",
+		"timeout",
+		"pending"
+	]),
+	status: Schema.optionalKey(Schema.Int)
+}) {};
+const Identity = Schema.String.check(Schema.isUUID());
+const Account = Schema.String.check(Schema.isPattern(/^[a-f0-9]{32}$/));
+const Closed = Schema.Struct({ status: Schema.Literals(["closing", "closed"]) });
+const Metadata = Schema.Struct({
+	sessionId: Identity,
+	endTime: Schema.optionalKey(Schema.Finite)
+});
+const Absent = Schema.Struct({ error: Schema.Literal("Session not found") });
+var BrowserRunSessionLifecycle = class extends Context.Service()("@effect-agent/platform-cloudflare/BrowserRunSessionLifecycle") {
+	static layer(options) {
+		return Layer.effect(this, Effect.gen(function* () {
+			if (!Schema.is(Account)(options.accountId) || Redacted.value(options.apiToken).length === 0) return yield* new BrowserRunCleanupError({ reason: "configuration" });
+			const client = yield* HttpClient.HttpClient;
+			const request = Effect.fn("BrowserRunSessionLifecycle.request")(function* (method, sessionId) {
+				const path = method === "DELETE" ? "browser" : "session";
+				const response = yield* client.execute(HttpClientRequest.make(method)(`https://api.cloudflare.com/client/v4/accounts/${options.accountId}/browser-rendering/devtools/${path}/${sessionId}`).pipe(HttpClientRequest.bearerToken(options.apiToken))).pipe(Effect.provideService(FetchHttpClient.RequestInit, { redirect: "manual" }), Effect.mapError(() => new BrowserRunCleanupError({ reason: "provider" })));
+				if (response.status === 401 || response.status === 403) return yield* new BrowserRunCleanupError({
+					reason: "authorization",
+					status: response.status
+				});
+				if (response.status === 429) return yield* new BrowserRunCleanupError({
+					reason: "rate-limited",
+					status: response.status
+				});
+				if (response.status !== 200 && response.status !== 404) return yield* new BrowserRunCleanupError({
+					reason: "provider",
+					status: response.status
+				});
+				if (response.headers["content-type"]?.split(";", 1)[0]?.trim() !== "application/json") return yield* new BrowserRunCleanupError({ reason: "malformed" });
+				const bytes = yield* Stream.runFoldEffect(response.stream, () => /* @__PURE__ */ new Uint8Array(), (body, chunk) => {
+					if (body.byteLength + chunk.byteLength > 16384) return Effect.fail(new BrowserRunCleanupError({ reason: "malformed" }));
+					const combined = new Uint8Array(body.byteLength + chunk.byteLength);
+					combined.set(body);
+					combined.set(chunk, body.byteLength);
+					return Effect.succeed(combined);
+				}).pipe(Effect.mapError(() => new BrowserRunCleanupError({ reason: "malformed" })));
+				const body = yield* Effect.try({
+					try: () => new TextDecoder("utf-8", {
+						fatal: true,
+						ignoreBOM: false
+					}).decode(bytes),
+					catch: () => new BrowserRunCleanupError({ reason: "malformed" })
+				});
+				if (response.status === 404) {
+					const absent = Schema.decodeUnknownOption(Schema.fromJsonString(Absent))(body, { onExcessProperty: "error" });
+					if (Option.isSome(absent)) return true;
+					return yield* new BrowserRunCleanupError({ reason: "malformed" });
+				}
+				if (method === "DELETE") return (yield* Schema.decodeUnknownEffect(Schema.fromJsonString(Closed))(body).pipe(Effect.mapError(() => new BrowserRunCleanupError({ reason: "malformed" })))).status === "closed";
+				const result = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(Metadata))(body).pipe(Effect.mapError(() => new BrowserRunCleanupError({ reason: "malformed" })));
+				if (result.sessionId !== sessionId) return yield* new BrowserRunCleanupError({ reason: "malformed" });
+				return result.endTime !== void 0 && result.endTime > 0;
+			});
+			return { close: Effect.fn("BrowserRunSessionLifecycle.close")(function* (sessionId) {
+				const id = yield* Schema.decodeUnknownEffect(Identity)(Redacted.value(sessionId)).pipe(Effect.mapError(() => new BrowserRunCleanupError({ reason: "configuration" })));
+				if (yield* request("DELETE", id)) return;
+				for (let read = 0; read < 2; read++) if (yield* request("GET", id)) return;
+				return yield* new BrowserRunCleanupError({ reason: "pending" });
+			}, Effect.timeoutOrElse({
+				duration: "10 seconds",
+				orElse: () => Effect.fail(new BrowserRunCleanupError({ reason: "timeout" }))
+			}), Effect.withTracerEnabled(false)) };
+		}));
+	}
+};
+//#endregion
 //#region src/interactive-browser.ts
 const browserRunInteractiveImplementation = SandboxImplementation.make({
 	isolation: "isolated",
@@ -15,7 +95,6 @@ const MAX_LIVE_VIEW_EXPIRY_MILLIS = 60 * 6e4;
 const MAX_HANDOFF_TIMEOUT_MILLIS = 30 * 6e4;
 const MAX_HOST_TEXT_LENGTH = 8 * 1024;
 const CLEANUP_STEP_TIMEOUT_MILLIS = 1e4;
-const CLOSE_SESSION_TIMEOUT_MILLIS = 1e4;
 const ACTION_NETWORK_QUIET_MILLIS = 200;
 const ACTION_NETWORK_SETTLE_MILLIS = 2e3;
 const ACTION_POST_STATE_MILLIS = 250;
@@ -149,13 +228,14 @@ var BrowserRunHandoffState = class extends Schema.Class("BrowserRunHandoffState"
 var BrowserRunInteractiveBinding = class BrowserRunInteractiveBinding extends Context.Service()("@effect-agent/platform-cloudflare/BrowserRunInteractiveBinding") {
 	static layer(options) {
 		return Layer.effect(BrowserRunInteractiveBinding)(Effect.gen(function* () {
+			const lifecycle = yield* BrowserRunSessionLifecycle;
 			const viewport = options.viewport === void 0 ? void 0 : yield* decodeViewport(options.viewport);
 			return {
 				launch: async (keepAliveMillis) => makeProductionBrowser(await puppeteer.launch(options.browser, {
 					keep_alive: keepAliveMillis,
 					...viewport === void 0 ? {} : { defaultViewport: { ...viewport } }
 				})),
-				connect: async (sessionId) => makeProductionBrowser(await puppeteer.connect(options.browser, sessionId))
+				closeSession: (sessionId) => lifecycle.close(sessionId).pipe(Effect.mapError((cause) => actionError("close", cause)))
 			};
 		}));
 	}
@@ -919,6 +999,24 @@ const cdpCommand = (page, state, command, parameters, output, malformedMessage)
 	return yield* Schema.decodeUnknownEffect(output)(raw).pipe(Effect.mapError(() => protocolError(malformedMessage)));
 }));
 const makeHostService = (binding) => {
+	const closeSession = binding.closeSession;
+	const terminate = Effect.fn("BrowserRunInteractiveHost.terminate")(function* (sessionId, entries) {
+		const deadline = (yield* Clock.currentTimeMillis) + 1e4;
+		yield* closeSession(sessionId).pipe(Effect.interruptible, Effect.timeoutOrElse({
+			duration: "10 seconds",
+			orElse: () => Effect.fail(actionError("close"))
+		}));
+		const remaining = deadline - (yield* Clock.currentTimeMillis);
+		if (remaining <= 0) return yield* Effect.logWarning("Local browser teardown skipped after confirmed termination deadline");
+		yield* runTeardown(entries).pipe(Effect.flatMap((failures) => Effect.forEach(failures, (failure) => Effect.logWarning(failure.warning), { discard: true })), Effect.interruptible, Effect.timeout(`${remaining} millis`), Effect.catchCause(() => Effect.logWarning("Local browser teardown incomplete after confirmed termination")));
+	});
+	const closeAcquired = Effect.fn("BrowserRunInteractiveHost.closeAcquired")(function* (browser) {
+		const sessionId = yield* Effect.try({
+			try: browser.sessionId,
+			catch: () => actionError("close")
+		}).pipe(Effect.flatMap(Schema.decodeUnknownEffect(BrowserRunSessionId)), Effect.mapError(() => actionError("close")), Effect.onError(() => closeWithWarning(browser.close, "Closing an unidentified browser failed")));
+		yield* terminate(Redacted.make(sessionId), [closeEntry(browser.close, "Closing the local browser connection failed")]);
+	});
 	const open = Effect.fn("BrowserRunInteractiveHost.open")(function* (policy) {
 		const fixedPolicy = yield* snapshotPolicy(policy);
 		const startedAt = yield* Effect.clockWith((clock) => clock.currentTimeMillis);
@@ -929,21 +1027,18 @@ const makeHostService = (binding) => {
 			violation: { value: void 0 },
 			pendingRequests: /* @__PURE__ */ new Set()
 		};
-		const lifecycle = {
-			managedTeardownInstalled: false,
-			explicitCloseInvoked: false
-		};
+		const lifecycle = { managedTeardownInstalled: false };
 		const closers = [];
 		const releaseBeforeManaged = (entry) => Effect.suspend(() => lifecycle.managedTeardownInstalled ? Effect.void : entry.close.pipe(Effect.catchCause(() => Effect.logWarning(entry.warning))));
 		const browser = yield* Effect.acquireRelease(withinDeadline(Effect.tryPromise({
-			try: (signal) => closeLateAcquisition(signal, () => binding.launch(keepAliveMillis(fixedPolicy)), (acquired) => acquired.close()),
+			try: (signal) => closeLateAcquisition(signal, () => binding.launch(keepAliveMillis(fixedPolicy)), (acquired) => Effect.runPromise(closeAcquired(acquired))),
 			catch: (cause) => isCapacityRefusal(cause) ? InteractiveBrowserCapacityError.make({
 				implementation: browserRunInteractiveImplementation,
 				message: "Browser Run has no capacity for a new browser session"
 			}) : protocolError("Launching the Browser Run session failed", cause)
 		}), fixedPolicy, startedAt), (acquired) => {
 			state.disconnected.value = true;
-			return releaseBeforeManaged(closeEntry(acquired.close, "Closing the interactive browser failed"));
+			return lifecycle.managedTeardownInstalled ? Effect.void : closeAcquired(acquired).pipe(Effect.catch(() => Effect.logWarning("Whole-browser cleanup remains unconfirmed")));
 		}, { interruptible: true });
 		closers.push(closeEntry(browser.close, "Closing the interactive browser failed"));
 		const disconnected = () => {
@@ -993,19 +1088,18 @@ const makeHostService = (binding) => {
 		const setupFailure = stateFailure(state);
 		if (setupFailure !== void 0) return yield* setupFailure;
 		const teardown = yield* Effect.uninterruptible(Effect.gen(function* () {
-			const cached = yield* Effect.cached(runTeardown(closers));
+			const cached = yield* Effect.cached(terminate(Redacted.make(sessionIdValue), closers));
 			lifecycle.managedTeardownInstalled = true;
 			yield* Effect.addFinalizer(() => Effect.uninterruptible(Effect.sync(() => {
 				state.closed.value = true;
 				state.disconnected.value = true;
-			}).pipe(Effect.andThen(cached), Effect.flatMap((failures) => lifecycle.explicitCloseInvoked ? Effect.void : Effect.forEach(failures, (failure) => Effect.logWarning(failure.warning)).pipe(Effect.asVoid)))));
+			}).pipe(Effect.andThen(cached), Effect.catch(() => Effect.logWarning("Whole-browser cleanup remains unconfirmed")))));
 			return cached;
 		}));
 		const close = Effect.uninterruptible(Effect.sync(() => {
-			lifecycle.explicitCloseInvoked = true;
 			state.closed.value = true;
 			state.disconnected.value = true;
-		}).pipe(Effect.andThen(teardown), Effect.flatMap((failures) => failures[0] === void 0 ? Effect.void : Effect.fail(failures[0].error))));
+		}).pipe(Effect.andThen(teardown)));
 		const runtime = yield* makeHandle(page, fixedPolicy, startedAt, state, close);
 		const currentPagePreflight = decodeActionResult(page, fixedPolicy).pipe(Effect.asVoid);
 		const requestFitsSession = (requestedMillis) => remainingMillis(fixedPolicy, startedAt).pipe(Effect.flatMap((remaining) => remaining > 0 && requestedMillis <= remaining ? Effect.void : Effect.fail(policyError("The host browser request exceeds the remaining session time"))));
@@ -1038,29 +1132,10 @@ const makeHostService = (binding) => {
 			close
 		};
 	});
-	const closeSession = Effect.fn("BrowserRunInteractiveHost.closeSession")(function* (sessionId) {
-		const decoded = yield* Schema.decodeUnknownEffect(Schema.Redacted(BrowserRunSessionId))(sessionId).pipe(Effect.mapError(() => policyError("The Browser Run cleanup session identity is malformed")));
-		return yield* Effect.scoped(Effect.gen(function* () {
-			const closeAttempted = { value: false };
-			const browser = yield* Effect.acquireRelease(Effect.tryPromise({
-				try: (signal) => closeLateAcquisition(signal, () => binding.connect(Redacted.value(decoded)), (acquired) => acquired.close()),
-				catch: (cause) => actionError("close", cause)
-			}), (acquired) => closeAttempted.value ? Effect.void : closeWithWarning(acquired.close, "Closing the leaked Browser Run session failed"), { interruptible: true });
-			return yield* Effect.tryPromise({
-				try: () => {
-					closeAttempted.value = true;
-					return browser.close();
-				},
-				catch: (cause) => actionError("close", cause)
-			});
-		})).pipe(Effect.timeoutOrElse({
-			duration: Duration.millis(CLOSE_SESSION_TIMEOUT_MILLIS),
-			orElse: () => Effect.fail(actionError("close"))
-		}));
-	});
 	return BrowserRunInteractiveHost.of({
 		open,
-		closeSession
+		closeSession,
+		cleanupSemantics: "confirmed-terminal"
 	});
 };
 /** Cloudflare host controls and private session identity for one scoped Browser Run pass. */
@@ -1074,6 +1149,6 @@ const browserRunInteractiveLayer = () => Layer.effect(InteractiveBrowser, Effect
 	return InteractiveBrowser.of({ open: (policy) => host.open(policy).pipe(Effect.map((session) => session.handle)) });
 }));
 //#endregion
-export { BrowserRunHandoffRequest, BrowserRunHandoffResult, BrowserRunHandoffState, BrowserRunInteractiveBinding, BrowserRunInteractiveHost, BrowserRunLiveViewRequest, BrowserRunLiveViewResult, BrowserRunViewport, browserRunInteractiveHostLayer, browserRunInteractiveImplementation, browserRunInteractiveLayer, isBrowserRunUndispatchedActionError };
+export { BrowserRunCleanupError, BrowserRunHandoffRequest, BrowserRunHandoffResult, BrowserRunHandoffState, BrowserRunInteractiveBinding, BrowserRunInteractiveHost, BrowserRunLiveViewRequest, BrowserRunLiveViewResult, BrowserRunSessionLifecycle, BrowserRunViewport, browserRunInteractiveHostLayer, browserRunInteractiveImplementation, browserRunInteractiveLayer, isBrowserRunUndispatchedActionError };
 
 //# sourceMappingURL=interactive-browser.mjs.map