@effect-agent/platform-cloudflare 0.1.0-beta.13 → 0.1.0-beta.131

package/src/internal/browser-readonly-live-view.ts

@@ -0,0 +1,111 @@
+import { Context, Effect, Layer, Redacted, Schema, Stream } from "effect";
+import { FetchHttpClient, HttpClient, HttpClientRequest } from "effect/unstable/http";
+
+import { BrowserRunLiveViewRequest, BrowserRunLiveViewResult } from "../InteractiveBrowser.ts";
+import { browserFailure, BrowserRunFailure } from "./browser-failure.ts";
+import type { BrowserRunLifecycleOptions } from "./browser-session-lifecycle.ts";
+
+const Identity = Schema.Struct({
+  sessionId: Schema.String.check(Schema.isUUID()),
+  targetId: Schema.NonEmptyString.check(Schema.isMaxLength(256)),
+});
+
+const Reply = Schema.fromJsonString(
+  Schema.Struct({
+    id: Identity.fields.targetId,
+    options: Schema.Struct({
+      mode: Schema.Literal("tab"),
+      guardrails: Schema.Struct({ mode: Schema.Literal("readonly") }),
+    }),
+    devtoolsFrontendUrl: Schema.String,
+  }),
+);
+
+const operation = "session.readonlyLiveView";
+
+/** Only the REST endpoint can mint provider-enforced read-only connections. */
+export class BrowserRunReadonlyLiveView extends Context.Service<
+  BrowserRunReadonlyLiveView,
+  {
+    readonly mint: (
+      sessionId: Redacted.Redacted<string>,
+      targetId: Redacted.Redacted<string>,
+      request: BrowserRunLiveViewRequest,
+    ) => Effect.Effect<BrowserRunLiveViewResult, BrowserRunFailure>;
+  }
+>()("@effect-agent/platform-cloudflare/internal/BrowserRunReadonlyLiveView") {
+  static layer(options: BrowserRunLifecycleOptions) {
+    return Layer.effect(
+      this,
+      Effect.gen(function* () {
+        const client = yield* HttpClient.HttpClient;
+
+        const mint = Effect.fnUntraced(
+          function* (
+            sessionId: Redacted.Redacted<string>,
+            targetId: Redacted.Redacted<string>,
+            request: BrowserRunLiveViewRequest,
+          ) {
+            const identity = yield* Schema.decodeEffect(Identity)({
+              sessionId: Redacted.value(sessionId),
+              targetId: Redacted.value(targetId),
+            });
+
+            const input = yield* Schema.decodeEffect(BrowserRunLiveViewRequest)(request);
+
+            const response = yield* client
+              .execute(
+                HttpClientRequest.post(
+                  `https://api.cloudflare.com/client/v4/accounts/${options.accountId}/browser-rendering/devtools/browser/${identity.sessionId}/live_view`,
+                ).pipe(
+                  HttpClientRequest.bearerToken(options.apiToken),
+                  HttpClientRequest.bodyJsonUnsafe({
+                    mode: input.mode,
+                    expiresInMs: input.expiresInMs,
+                    targetId: identity.targetId,
+                    guardrails: { mode: "readonly" },
+                  }),
+                ),
+              )
+              .pipe(Effect.provideService(FetchHttpClient.RequestInit, { redirect: "manual" }));
+
+            if (response.status !== 200)
+              return yield* new BrowserRunFailure({
+                operation,
+                reason: "provider",
+                status: response.status,
+              });
+
+            const bytes = yield* Stream.runFoldEffect(
+              response.stream,
+              () => new Uint8Array(),
+              (body, chunk) => {
+                if (body.byteLength + chunk.byteLength > 16_384)
+                  return Effect.fail(new BrowserRunFailure({ operation, reason: "malformed" }));
+                const combined = new Uint8Array(body.byteLength + chunk.byteLength);
+
+                combined.set(body);
+                combined.set(chunk, body.byteLength);
+
+                return Effect.succeed(combined);
+              },
+            );
+
+            const reply = yield* Schema.decodeEffect(Reply)(new TextDecoder().decode(bytes));
+
+            if (reply.id !== identity.targetId)
+              return yield* new BrowserRunFailure({ operation, reason: "malformed" });
+
+            return yield* Schema.decodeEffect(BrowserRunLiveViewResult)({
+              devtoolsFrontendUrl: Redacted.make(reply.devtoolsFrontendUrl),
+            });
+          },
+          Effect.mapError((cause) => browserFailure(operation, cause)),
+          Effect.withTracerEnabled(false),
+        );
+
+        return { mint };
+      }),
+    );
+  }
+}

package/src/internal/browser-session-lifecycle.ts

@@ -0,0 +1,193 @@
+import { Context, Effect, Layer, Option, Redacted, Schema, Stream } from "effect";
+import { FetchHttpClient, HttpClient, HttpClientRequest } from "effect/unstable/http";
+
+import { browserFailure } from "./browser-failure.ts";
+
+export class BrowserRunCleanupError extends Schema.TaggedError<BrowserRunCleanupError>()(
+  "BrowserRunCleanupError",
+  {
+    reason: Schema.Literals([
+      "configuration",
+      "authorization",
+      "rate-limited",
+      "provider",
+      "malformed",
+      "timeout",
+      "pending",
+    ]),
+    status: Schema.optionalKey(Schema.Int),
+    cause: Schema.optionalKey(Schema.Defect()),
+  },
+) {}
+
+export interface BrowserRunLifecycleOptions {
+  readonly accountId: string;
+  readonly apiToken: Redacted.Redacted<string>;
+}
+
+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) });
+// This exact provider response is accepted only on a fixed-origin, authenticated,
+// exact-session request. An arbitrary 404 or a listing omission is never absence.
+const Absent = Schema.Struct({ error: Schema.Literal("Session not found") });
+
+export class BrowserRunSessionLifecycle extends Context.Service<
+  BrowserRunSessionLifecycle,
+  {
+    readonly close: (
+      sessionId: Redacted.Redacted<string>,
+    ) => Effect.Effect<void, BrowserRunCleanupError>;
+  }
+>()("@effect-agent/platform-cloudflare/BrowserRunSessionLifecycle") {
+  static layer(options: BrowserRunLifecycleOptions) {
+    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: "GET" | "DELETE",
+          sessionId: string,
+        ) {
+          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(
+              // workerd supports manual/follow, not error. Reject every redirect below.
+              Effect.provideService(FetchHttpClient.RequestInit, { redirect: "manual" }),
+              Effect.mapError(
+                (cause) =>
+                  new BrowserRunCleanupError({
+                    reason: "provider",
+                    cause: browserFailure("browser.close.request", cause),
+                  }),
+              ),
+            );
+
+          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,
+            () => new Uint8Array(),
+            (body, chunk) => {
+              if (body.byteLength + chunk.byteLength > 16_384)
+                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(
+              (cause) =>
+                new BrowserRunCleanupError({
+                  reason: "malformed",
+                  cause: browserFailure("browser.close.response", cause),
+                }),
+            ),
+          );
+
+          const body = yield* Effect.try({
+            try: () => new TextDecoder("utf-8", { fatal: true, ignoreBOM: false }).decode(bytes),
+            catch: (cause) =>
+              new BrowserRunCleanupError({
+                reason: "malformed",
+                cause: browserFailure("browser.close.decode", cause),
+              }),
+          });
+
+          if (response.status === 404) {
+            const absent = Schema.decodeOption(Schema.fromJsonString(Absent))(body, {
+              onExcessProperty: "error",
+            });
+
+            if (Option.isSome(absent)) return true;
+
+            return yield* new BrowserRunCleanupError({ reason: "malformed" });
+          }
+          if (method === "DELETE") {
+            const result = yield* Schema.decodeEffect(Schema.fromJsonString(Closed))(body).pipe(
+              Effect.mapError(
+                (cause) =>
+                  new BrowserRunCleanupError({
+                    reason: "malformed",
+                    cause: browserFailure("browser.close.response", cause),
+                  }),
+              ),
+            );
+
+            return result.status === "closed";
+          }
+
+          const result = yield* Schema.decodeEffect(Schema.fromJsonString(Metadata))(body).pipe(
+            Effect.mapError(
+              (cause) =>
+                new BrowserRunCleanupError({
+                  reason: "malformed",
+                  cause: browserFailure("browser.close.response", cause),
+                }),
+            ),
+          );
+
+          if (result.sessionId !== sessionId)
+            return yield* new BrowserRunCleanupError({ reason: "malformed" });
+
+          return result.endTime !== undefined && result.endTime > 0;
+        });
+
+        const close = Effect.fn("BrowserRunSessionLifecycle.close")(
+          function* (sessionId: Redacted.Redacted<string>) {
+            const id = yield* Schema.decodeEffect(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),
+        );
+
+        return { close };
+      }),
+    );
+  }
+}