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

package/src/internal/browser-credentials.ts

@@ -0,0 +1,362 @@
+import { Cause, Context, Effect, Redacted, Schema } from "effect";
+import type { Frame, Page } from "puppeteer-core/lib/esm/puppeteer/puppeteer-core-browser.js";
+
+import {
+  BrowserCredentialAccess,
+  type BrowserCredentialMaterial,
+  CardCredential,
+  type CredentialDispatch,
+  type CredentialFieldRole,
+  CredentialFillError,
+  CredentialFillResult,
+  CredentialOrigin,
+  CredentialTarget,
+  FillCredentialRequest,
+  LoginCredential,
+  type CredentialAccessRequest,
+} from "../BrowserCredentials.ts";
+
+/** Supplied only under the attachment lock, with the remaining command/session budget. */
+export class BrowserSessionPage extends Context.Service<
+  BrowserSessionPage,
+  {
+    readonly page: Page;
+    readonly commandTimeoutMillis: number;
+  }
+>()("@effect-agent/platform-cloudflare/internal/BrowserSessionPage") {}
+
+const TargetReply = Schema.Union([
+  Schema.Struct({ action: Schema.String.check(Schema.isMaxLength(2048)) }),
+  Schema.Struct({ reason: Schema.Literals(["stale-target", "unsupported"]) }),
+]);
+
+const WriteReply = Schema.Literals([
+  "filled",
+  "stale-target",
+  "unsupported-before-write",
+  "unsupported",
+]);
+
+// One invocation-local isolated-world handle. Actual nodes and fingerprints never leave the page.
+// This program neither discovers controls nor classifies roles nor observes page content.
+const prepareFields = `(() => {
+  const doc = document;
+  let fields = [];
+  let form;
+  let snapshots = [];
+  const describe = el => {
+    if (!el || !el.isConnected || el.ownerDocument !== doc || doc !== document) return null;
+    const native = el instanceof HTMLTextAreaElement ||
+      (el instanceof HTMLSelectElement && !el.multiple) ||
+      (el instanceof HTMLInputElement && ['text','email','password','tel','number','month','search','url','date','time','week','datetime-local'].includes(el.type));
+    if (!native || el.matches(':disabled') || el.readOnly || !el.form) return null;
+    const values = [el.form.action, el.form.method, el.form.enctype, el.name, el.type, el.autocomplete ?? ''];
+    if (values.some(value => value.length > 2048)) return null;
+    return JSON.stringify(values);
+  };
+  const validate = () => fields.length > 0 && fields.every((el, index) =>
+    el.form === form && describe(el) !== null && describe(el) === snapshots[index]);
+  return {
+    prepare(selectors) {
+      try {
+        fields = selectors.map(selector => {
+          const matches = doc.querySelectorAll(selector);
+          return matches.length === 1 ? matches[0] : null;
+        });
+      } catch { return {reason: 'stale-target'}; }
+      if (fields.some(el => !el) || new Set(fields).size !== fields.length) return {reason: 'stale-target'};
+      snapshots = fields.map(describe);
+      form = fields[0].form;
+      if (!form || snapshots.some(value => value === null) || fields.some(el => el.form !== form)) return {reason: 'unsupported'};
+      return {action: form.action};
+    },
+    target() { return validate() ? {action: form.action} : {reason: 'stale-target'}; },
+    fill(index, value) {
+      if (!validate()) return 'stale-target';
+      const el = fields[index];
+      if (el instanceof HTMLSelectElement) {
+        const options = [...el.options].filter(option => option.value === value);
+        if (options.length !== 1 || options[0].matches(':disabled')) return 'unsupported-before-write';
+      }
+      let prototype = Object.getPrototypeOf(el);
+      let setter;
+      while (prototype && !setter) { setter = Object.getOwnPropertyDescriptor(prototype, 'value')?.set; prototype = Object.getPrototypeOf(prototype); }
+      if (!setter) return 'unsupported-before-write';
+      setter.call(el, value);
+      if (el.value !== value) return 'unsupported';
+      el.dispatchEvent(new Event('input', {bubbles: true}));
+      el.dispatchEvent(new Event('change', {bubbles: true}));
+      return 'filled';
+    }
+  };
+})()`;
+
+const secretFor = (material: BrowserCredentialMaterial, role: typeof CredentialFieldRole.Type) => {
+  if (material._tag === "LoginCredential")
+    return role === "username"
+      ? material.username
+      : role === "password"
+        ? material.password
+        : undefined;
+  switch (role) {
+    case "card-name":
+      return material.name;
+    case "card-number":
+      return material.number;
+    case "card-expiry":
+      return material.expiry;
+    case "card-expiry-month":
+      return material.expiryMonth;
+    case "card-expiry-year":
+      return material.expiryYear;
+    case "card-security-code":
+      return material.securityCode;
+    case "username":
+    case "password":
+      return undefined;
+  }
+};
+
+/**
+ * Fill explicit native fields on an existing page without submitting. The owning browser session
+ * serializes operations and closes on timeout, interruption or uncertain dispatch; this function releases
+ * only its local handles. Ordinary native observations remain available, including credential echoes.
+ */
+export const fillCredential = Effect.fnUntraced(function* (
+  input: FillCredentialRequest,
+): Effect.fn.Return<
+  CredentialFillResult,
+  CredentialFillError,
+  BrowserCredentialAccess | BrowserSessionPage
+> {
+  const { page, commandTimeoutMillis } = yield* BrowserSessionPage;
+  let dispatch: typeof CredentialDispatch.Type = "not-dispatched";
+  let filled = 0;
+
+  const fail = (reason: CredentialFillError["reason"]) =>
+    new CredentialFillError({ reason, dispatch, filled, cleanup: "not-requested" });
+
+  const remote = <A>(run: (signal: AbortSignal) => Promise<A>) =>
+    Effect.tryPromise({
+      try: async (signal) => {
+        try {
+          return { ok: true as const, value: await run(signal) };
+        } catch {
+          return { ok: false as const };
+        }
+      },
+      catch: () => fail("provider"),
+    }).pipe(
+      Effect.flatMap((result) =>
+        result.ok ? Effect.succeed(result.value) : Effect.fail(fail("provider")),
+      ),
+    );
+
+  const release = (handles: ReadonlyArray<{ dispose(): Promise<void> }>) =>
+    Effect.promise(async () => {
+      await Promise.all(handles.map((handle) => handle.dispose().catch(() => {})));
+    }).pipe(Effect.interruptible, Effect.timeoutOption("1 second"), Effect.asVoid);
+
+  const acquire = <A extends { dispose(): Promise<void> }>(run: () => Promise<ReadonlyArray<A>>) =>
+    Effect.acquireRelease(
+      remote(async (signal) => {
+        const handles = await run();
+
+        if (signal.aborted) {
+          await Promise.all(handles.map((handle) => handle.dispose().catch(() => {})));
+          throw fail("provider");
+        }
+
+        return handles;
+      }).pipe(Effect.interruptible),
+      release,
+    );
+
+  const origin = (value: string) =>
+    Effect.try({
+      try: () => {
+        const url = new URL(value);
+
+        if (url.username || url.password) throw fail("denied");
+
+        return url.origin;
+      },
+      catch: () => fail("denied"),
+    }).pipe(
+      Effect.flatMap(Schema.decodeUnknownEffect(CredentialOrigin)),
+      Effect.mapError(() => fail("denied")),
+    );
+
+  return yield* Effect.gen(function* () {
+    const request = yield* Schema.decodeEffect(FillCredentialRequest, {
+      onExcessProperty: "error",
+    })(input).pipe(Effect.mapError(() => fail("denied")));
+
+    const roles = request.fields.map((field) => field.role);
+
+    if (
+      new Set(roles).size !== roles.length ||
+      roles.some(
+        (role) => (request.kind === "login") !== (role === "username" || role === "password"),
+      )
+    )
+      return yield* fail("denied");
+    const access = yield* BrowserCredentialAccess;
+    let frame: Frame = page.mainFrame();
+
+    for (const selector of request.frame ?? []) {
+      const matches = yield* acquire(() => frame.$$(selector));
+      const element = matches[0];
+
+      if (matches.length !== 1 || element === undefined) return yield* fail("stale-target");
+      const child = yield* remote(() => element.contentFrame());
+
+      if (child === null) return yield* fail("unsupported");
+      frame = child;
+    }
+
+    const handles = yield* acquire(async () => [
+      await frame.isolatedRealm().evaluateHandle(prepareFields),
+    ]);
+
+    const held = handles[0];
+
+    if (held === undefined) return yield* fail("provider");
+
+    const inspect = (raw: unknown) =>
+      Schema.decodeUnknownEffect(TargetReply)(raw).pipe(
+        Effect.mapError(() => fail("provider")),
+        Effect.flatMap((reply) =>
+          "reason" in reply ? Effect.fail(fail(reply.reason)) : Effect.succeed(reply.action),
+        ),
+      );
+
+    const action = yield* remote(() =>
+      held.evaluate(
+        (state, selectors) => {
+          if (typeof state !== "object" || state === null) return null;
+
+          return Reflect.apply(Reflect.get(state, "prepare"), state, [selectors]);
+        },
+        request.fields.map((field) => field.selector),
+      ),
+    ).pipe(Effect.flatMap(inspect));
+
+    const target = CredentialTarget.make({
+      topOrigin: yield* origin(page.url()),
+      frameOrigin: yield* origin(frame.url()),
+      recipientOrigin: yield* origin(action),
+    });
+
+    const authorization: CredentialAccessRequest = {
+      credential: request.credential,
+      kind: request.kind,
+      target,
+      roles,
+    };
+
+    const authorize = Effect.suspend(() => access.authorize(authorization)).pipe(
+      Effect.mapError((error) => fail(error.reason)),
+    );
+
+    const validate = Effect.gen(function* () {
+      if (
+        frame.detached ||
+        (yield* origin(page.url())) !== target.topOrigin ||
+        (yield* origin(frame.url())) !== target.frameOrigin
+      )
+        return yield* fail("stale-target");
+
+      const current = yield* remote(() =>
+        held.evaluate((state) => {
+          if (typeof state !== "object" || state === null) return null;
+
+          return Reflect.apply(Reflect.get(state, "target"), state, []);
+        }),
+      ).pipe(Effect.flatMap(inspect));
+
+      if ((yield* origin(current)) !== target.recipientOrigin) return yield* fail("stale-target");
+    });
+
+    yield* authorize;
+    yield* validate;
+
+    const raw = yield* access
+      .resolve(authorization)
+      .pipe(Effect.mapError((error) => fail(error.reason)));
+
+    const material = yield* Schema.decodeEffect(
+      request.kind === "login" ? LoginCredential : CardCredential,
+    )(raw).pipe(Effect.mapError(() => fail("resolver")));
+
+    for (const role of roles)
+      if (secretFor(material, role) === undefined) return yield* fail("missing-credential");
+    for (const [index, role] of roles.entries()) {
+      yield* authorize;
+      yield* validate;
+      const value = secretFor(material, role);
+
+      if (value === undefined) return yield* fail("missing-credential");
+      const previous = dispatch;
+
+      const result = yield* remote((signal) => {
+        if (signal.aborted) return Promise.reject(fail("provider"));
+        dispatch = "possibly-dispatched";
+
+        return held.evaluate(
+          (state, field, secret) => {
+            if (typeof state !== "object" || state === null) return "stale-target";
+
+            return Reflect.apply(Reflect.get(state, "fill"), state, [field, secret]);
+          },
+          index,
+          Redacted.value(value),
+        );
+      }).pipe(
+        Effect.flatMap(Schema.decodeUnknownEffect(WriteReply)),
+        Effect.mapError(() => fail("provider")),
+      );
+
+      if (result === "stale-target" || result === "unsupported-before-write") {
+        dispatch = previous;
+
+        return yield* fail(result === "stale-target" ? "stale-target" : "unsupported");
+      }
+      if (result === "unsupported") return yield* fail("unsupported");
+      dispatch = "dispatched";
+      filled++;
+    }
+
+    return CredentialFillResult.make({ dispatch: "dispatched", filled });
+  }).pipe(
+    Effect.scoped,
+    Effect.timeoutOrElse({
+      duration: commandTimeoutMillis,
+      orElse: () => Effect.fail(fail("timeout")),
+    }),
+    Effect.catchCause((cause) => {
+      if (Cause.hasInterrupts(cause)) return Effect.interrupt;
+      if (
+        cause.reasons.some(
+          (reason) =>
+            reason._tag === "Die" ||
+            (reason._tag === "Fail" && !Schema.is(CredentialFillError)(reason.error)),
+        )
+      )
+        return Effect.fail(fail("provider"));
+
+      const expected = cause.reasons.find(
+        (reason) => reason._tag === "Fail" && Schema.is(CredentialFillError)(reason.error),
+      );
+
+      return Effect.fail(
+        fail(
+          expected?._tag === "Fail" && Schema.is(CredentialFillError)(expected.error)
+            ? expected.error.reason
+            : "provider",
+        ),
+      );
+    }),
+    Effect.withTracerEnabled(false),
+  );
+});

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 { Encoding } from "effect";
+import type { BrowserSelectFileRequest } from "effect-agent/interactive-browser";
+import type { Page } from "puppeteer-core/lib/esm/puppeteer/puppeteer-core-browser.js";
+
+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();
+          }
+        }
+      },
+    };
+  };