@effect-agent/platform-cloudflare 0.1.0-beta.106 → 0.1.0-beta.108

package/src/internal/browser-failure.ts

@@ -0,0 +1,92 @@
+import type { Effect } from "effect";
+import { Cause, Data, ErrorReporter, Predicate, Schema } from "effect";
+
+/** Source-authored stages and classifications only; never retain SDK text or session capabilities. */
+export class BrowserRunFailure extends Data.TaggedError("BrowserRunFailure")<{
+  readonly operation: string;
+  readonly reason:
+    | "provider"
+    | "timeout"
+    | "malformed"
+    | "configuration"
+    | "authorization"
+    | "rate-limited"
+    | "pending";
+  readonly status?: number;
+  readonly cause?: BrowserRunFailure | { readonly name: string };
+}> {
+  readonly [ErrorReporter.severity] = "Error" as const;
+}
+
+/** A public projection of an already reported private failure must not produce another issue. */
+export const reportedBrowserError = <A extends object>(error: A): A =>
+  Object.assign(error, { [ErrorReporter.ignore]: true });
+
+export const inheritBrowserReport = <A extends object>(original: unknown, error: A): A =>
+  ErrorReporter.isIgnored(original) ? reportedBrowserError(error) : error;
+
+const reasonSchema = Schema.Literals([
+  "provider",
+  "timeout",
+  "malformed",
+  "configuration",
+  "authorization",
+  "rate-limited",
+  "pending",
+]);
+
+const statusSchema = Schema.Int.check(Schema.isBetween({ minimum: 100, maximum: 599 }));
+
+const failureNames = new Set([
+  "TypeError",
+  "RangeError",
+  "SyntaxError",
+  "TimeoutError",
+  "SchemaError",
+]);
+
+export const browserFailure = (operation: string, cause?: unknown): BrowserRunFailure =>
+  cause instanceof BrowserRunFailure
+    ? cause
+    : new BrowserRunFailure({
+        operation,
+        reason:
+          Predicate.isObject(cause) && "reason" in cause && Schema.is(reasonSchema)(cause.reason)
+            ? cause.reason
+            : "provider",
+        ...(Predicate.isObject(cause) && "status" in cause && Schema.is(statusSchema)(cause.status)
+          ? { status: cause.status }
+          : {}),
+        ...(Predicate.isObject(cause) &&
+        "cause" in cause &&
+        cause.cause instanceof BrowserRunFailure
+          ? { cause: cause.cause }
+          : Predicate.isObject(cause) &&
+              "name" in cause &&
+              typeof cause.name === "string" &&
+              failureNames.has(cause.name)
+            ? { cause: { name: cause.name } }
+            : {}),
+      });
+
+/** Keep mixed defects and interruptions distinct while discarding all foreign diagnostic content. */
+export const reportBrowserCause = <E>(
+  operation: string,
+  cause: Cause.Cause<E>,
+): Effect.Effect<void> =>
+  ErrorReporter.report(
+    Cause.fromReasons(
+      cause.reasons
+        .filter((reason) => !Cause.isFailReason(reason) || !ErrorReporter.isIgnored(reason.error))
+        .map((reason) => {
+          switch (reason._tag) {
+            case "Fail":
+              return Cause.makeFailReason(browserFailure(operation, reason.error));
+            case "Die":
+              return Cause.makeDieReason(browserFailure(operation, reason.defect));
+            case "Interrupt":
+              return reason;
+          }
+        }),
+    ),
+  );

package/src/internal/browser-file-selection.ts

@@ -0,0 +1,126 @@
+import type { Page } from "@cloudflare/puppeteer";
+import { Encoding } from "effect";
+import type { BrowserSelectFileRequest } from "effect-agent/interactive-browser";
+
+type Element = NonNullable<Awaited<ReturnType<Page["$"]>>>;
+
+// Both calls run this fixed function in Chromium. No caller-provided code or
+// filesystem path is evaluated, and none of the file bytes enter diagnostics.
+function setFileSelection(element: object, encoded: string, name: string, type: string): void {
+  if (
+    Reflect.get(element, "type") !== "file" ||
+    Reflect.get(element, "disabled") ||
+    Reflect.get(element, "webkitdirectory")
+  ) {
+    throw new Error("The target is not an enabled file input");
+  }
+  const bytes = Uint8Array.from(atob(encoded), (character) => character.charCodeAt(0));
+  const Transfer = Reflect.get(globalThis, "DataTransfer");
+  const transfer = new Transfer();
+
+  transfer.items.add(new File([bytes], name, { type }));
+  Reflect.set(element, "files", transfer.files);
+  const selected = Reflect.get(element, "files");
+
+  if (
+    selected?.length !== 1 ||
+    selected[0]?.size !== bytes.length ||
+    selected[0]?.name !== name ||
+    selected[0]?.type !== type
+  ) {
+    throw new Error("The input did not retain the selected file");
+  }
+  const dispatch = Reflect.get(element, "dispatchEvent");
+
+  Reflect.apply(dispatch, element, [new Event("input", { bubbles: true })]);
+  Reflect.apply(dispatch, element, [new Event("change", { bubbles: true })]);
+}
+
+export const makeFileSelection =
+  (page: Page) => async (request: BrowserSelectFileRequest, signal: AbortSignal) => {
+    const encoded = Encoding.encodeBase64(request.bytes);
+    const session = request.target === "chooser" ? await page.createCDPSession() : undefined;
+
+    if (session !== undefined) {
+      try {
+        await session.send("Page.enable");
+        await session.send("Page.setInterceptFileChooserDialog", { enabled: true });
+      } catch (cause) {
+        await session.detach();
+        throw cause;
+      }
+    }
+
+    const select = async (element: Element): Promise<void> => {
+      if (session === undefined)
+        return element.evaluate(setFileSelection, encoded, request.fileName, request.mediaType);
+      let onOpened: (event: { backendNodeId?: number }) => void = () => {};
+      let onAbort: () => void = () => {};
+      let timer: ReturnType<typeof setTimeout> | undefined;
+
+      const opened = new Promise<number>((resolve, reject) => {
+        onOpened = (event) =>
+          event.backendNodeId === undefined
+            ? reject(new Error("The chooser has no file input"))
+            : resolve(event.backendNodeId);
+        onAbort = () => reject(new Error("File selection interrupted"));
+        session.on("Page.fileChooserOpened", onOpened);
+        signal.addEventListener("abort", onAbort, { once: true });
+        timer = setTimeout(() => reject(new Error("No file chooser opened")), 5_000);
+        if (signal.aborted) onAbort();
+      });
+
+      try {
+        const [backendNodeId] = await Promise.all([opened, element.click()]);
+
+        if (signal.aborted) throw new Error("File selection interrupted");
+        const resolved = await session.send("DOM.resolveNode", { backendNodeId });
+
+        const objectId = resolved.object.objectId;
+
+        if (objectId === undefined) throw new Error("The chooser has no file input");
+        if (signal.aborted) throw new Error("File selection interrupted");
+
+        const result = await session.send("Runtime.callFunctionOn", {
+          objectId,
+          functionDeclaration: `function(encoded, name, type) { (${setFileSelection.toString()})(this, encoded, name, type); }`,
+          arguments: [
+            { value: encoded },
+            { value: request.fileName },
+            { value: request.mediaType },
+          ],
+          returnByValue: true,
+        });
+
+        if (result.exceptionDetails !== undefined)
+          throw new Error("The chooser did not select the file");
+      } finally {
+        clearTimeout(timer);
+        session.off("Page.fileChooserOpened", onOpened);
+        signal.removeEventListener("abort", onAbort);
+        // Detaching the owned session releases all remote object handles, including
+        // after timeout, interruption, or a navigation during change handlers.
+      }
+    };
+
+    return {
+      validate: async (element: Element): Promise<boolean> =>
+        request.target === "chooser" ||
+        (await element.evaluate(
+          (input) =>
+            Reflect.get(input, "type") === "file" &&
+            !Reflect.get(input, "disabled") &&
+            !Reflect.get(input, "webkitdirectory"),
+        )),
+      select,
+      close: async (): Promise<void> => {
+        if (session !== undefined) {
+          try {
+            await session.send("Page.setInterceptFileChooserDialog", { enabled: false });
+          } finally {
+            await session.detach();
+          }
+        }
+      },
+    };
+  };

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

@@ -1,6 +1,8 @@
 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",
   {
@@ -14,6 +16,7 @@ export class BrowserRunCleanupError extends Schema.TaggedError<BrowserRunCleanup
       "pending",
     ]),
     status: Schema.optionalKey(Schema.Int),
+    cause: Schema.optionalKey(Schema.Defect()),
   },
 ) {}
 
@@ -65,7 +68,13 @@ export class BrowserRunSessionLifecycle extends Context.Service<
             .pipe(
               // workerd supports manual/follow, not error. Reject every redirect below.
               Effect.provideService(FetchHttpClient.RequestInit, { redirect: "manual" }),
-              Effect.mapError(() => new BrowserRunCleanupError({ reason: "provider" })),
+              Effect.mapError(
+                (cause) =>
+                  new BrowserRunCleanupError({
+                    reason: "provider",
+                    cause: browserFailure("browser.close.request", cause),
+                  }),
+              ),
             );
 
           if (response.status === 401 || response.status === 403)
@@ -99,11 +108,23 @@ export class BrowserRunSessionLifecycle extends Context.Service<
 
               return Effect.succeed(combined);
             },
-          ).pipe(Effect.mapError(() => new BrowserRunCleanupError({ reason: "malformed" })));
+          ).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: () => new BrowserRunCleanupError({ reason: "malformed" }),
+            catch: (cause) =>
+              new BrowserRunCleanupError({
+                reason: "malformed",
+                cause: browserFailure("browser.close.decode", cause),
+              }),
           });
 
           if (response.status === 404) {
@@ -117,14 +138,26 @@ export class BrowserRunSessionLifecycle extends Context.Service<
           }
           if (method === "DELETE") {
             const result = yield* Schema.decodeEffect(Schema.fromJsonString(Closed))(body).pipe(
-              Effect.mapError(() => new BrowserRunCleanupError({ reason: "malformed" })),
+              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(() => new BrowserRunCleanupError({ reason: "malformed" })),
+            Effect.mapError(
+              (cause) =>
+                new BrowserRunCleanupError({
+                  reason: "malformed",
+                  cause: browserFailure("browser.close.response", cause),
+                }),
+            ),
           );
 
           if (result.sessionId !== sessionId)