Agentic Autofill

import { Browserbase } from "@browserbasehq/sdk";
import { chromium } from "playwright-core";

const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

function unwrap(response) {
  if (!response.success) {
    throw Object.assign(new Error(response.error.code), {
      code: response.error.code,
    });
  }
  return response.result;
}

async function findOnePasswordWorker(context) {
  const deadline = Date.now() + 30_000;
  while (Date.now() < deadline) {
    for (const worker of context.serviceWorkers()) {
      if (!worker.url().startsWith("chrome-extension://")) continue;
      try {
        const isOnePassword = await worker.evaluate(
          () => chrome.runtime.getManifest().short_name === "1Password",
        );
        if (isOnePassword) return worker;
      } catch {
        // A starting service worker may be replaced. Check again.
      }
    }
    await sleep(500);
  }
  throw new Error("1Password extension service worker not found");
}

async function waitForDecision(checkStatus) {
  const openedAt = Date.now();
  while (true) {
    const elapsed = Date.now() - openedAt;
    if (elapsed >= 120_000) return null;
    const delay =
      elapsed < 5_000
        ? 5_000 - elapsed
        : elapsed < 30_000
          ? 2_000
          : elapsed < 60_000
            ? 5_000
            : 10_000;
    await sleep(delay);
    if (Date.now() - openedAt >= 120_000) return null;
    try {
      const status = await checkStatus();
      if (status.state !== "pending") return status;
    } catch (error) {
      if (error.code === "rateLimitExceeded") {
        await sleep(60_000);
      } else if (error.code !== "timeout" && error.code !== "networkError") {
        throw error;
      }
    }
  }
}

export async function signIn({
  getAccessToken,
  integrationKey,
  loginUrl,
  successUrl,
  showApproval,
}) {
  const expected = new URL(successUrl);
  if (
    new URL(loginUrl).protocol !== "https:" ||
    expected.protocol !== "https:"
  ) {
    throw new Error("Use HTTPS login and success URLs");
  }
  const bb = new Browserbase({ apiKey: process.env.BROWSERBASE_API_KEY });
  const projectId = process.env.BROWSERBASE_PROJECT_ID;
  const session = await bb.sessions.create({
    projectId,
    extensionId: process.env.BROWSERBASE_EXTENSION_ID,
    timeout: 600,
    browserSettings: { recordSession: false, logSession: false },
  });
  let browser;

  try {
    browser = await chromium.connectOverCDP(session.connectUrl);
    const context = browser.contexts()[0];
    if (!context) throw new Error("Browserbase browser context not found");
    const worker = await findOnePasswordWorker(context);

    await worker.evaluate(async () => {
      const initialization = globalThis.api?.initialization?.v1;
      if (!initialization?.whenSettled) {
        throw new Error("1Password initialization API is unavailable");
      }
      let timer;
      try {
        const state = await Promise.race([
          initialization.whenSettled(),
          new Promise((_, reject) => {
            timer = setTimeout(
              () => reject(new Error("1Password initialization timed out")),
              20_000,
            );
          }),
        ]);
        if (state !== "ready") {
          throw new Error("1Password extension initialization failed");
        }
      } finally {
        clearTimeout(timer);
      }
      const api = globalThis.api;
      const methods = [
        "createAccessRequest",
        "getAccessRequestStatus",
        "fillCredential",
      ];
      if (
        typeof api.agenticMode?.v1?.enable !== "function" ||
        !methods.every(
          (method) => typeof api.agenticAutofill?.v1?.[method] === "function",
        )
      ) {
        throw new Error("1Password Agentic Autofill API is unavailable");
      }
      const enabled = await api.agenticMode.v1.enable();
      if (!enabled.success) throw new Error(enabled.error.code);
    });

    // Runs only in your backend; secrets are passed as evaluation arguments.
    const callAutofill = async (method, parameters) =>
      unwrap(
        await worker.evaluate(
          ({ method, ...args }) =>
            globalThis.api.agenticAutofill.v1[method](args),
          {
            ...parameters,
            method,
            accessToken: await getAccessToken(),
            integrationKey,
          },
        ),
      );

    const page = await context.newPage();
    await page.goto(loginUrl, {
      waitUntil: "domcontentloaded",
      timeout: 30_000,
    });
    const created = await callAutofill("createAccessRequest", {
      requests: {
        version: 2,
        goal: "Test a website sign-in",
        entries: [
          {
            type: "login",
            parameters: { website: loginUrl },
            reason: "Sign in to verify the Browserbase integration",
          },
        ],
      },
    });

    // Your UI hook resolves when the user opens the approval link.
    await showApproval(created.appLink);

    // Keep the CDP connection open and use one checker per request.
    const status = await waitForDecision(() =>
      callAutofill("getAccessRequestStatus", {
        accessRequestUUID: created.accessRequest.id,
      }),
    );

    if (!status) throw new Error("Approval still pending; wait for the user");
    if (status.state !== "resolved") {
      throw new Error(`Access request ended: ${status.state}`);
    }
    const entry = created.accessRequest.entries[0];
    const grant = status.resolved.find(({ entryId }) => entryId === entry.id);
    if (!grant) throw new Error("No login granted for the requested entry");

    const tabUrl = page.url();
    const tabId = await worker.evaluate(async (url) => {
      const tabs = (await chrome.tabs.query({})).filter(
        (tab) => tab.url === url,
      );
      if (tabs.length !== 1 || typeof tabs[0].id !== "number") {
        throw new Error("Cannot identify login tab");
      }
      return tabs[0].id;
    }, tabUrl);

    // Pause all agent page reads and screenshots until this call returns.
    const filled = await callAutofill("fillCredential", {
      resourcePath: grant.reference,
      tabId,
    });

    if (filled.status !== "fill_submitted") {
      throw new Error("Unexpected fill status");
    }
    // Verify navigation only after the extension has finished the fill.
    await page.waitForURL(
      (url) =>
        url.origin === expected.origin && url.pathname === expected.pathname,
      { waitUntil: "domcontentloaded", timeout: 15_000 },
    );
    console.log(filled.status);
    console.log("Website login verified");
    return { status: filled.status, websiteLoginVerified: true };
  } finally {
    try {
      await browser?.close();
    } finally {
      await bb.sessions.update(session.id, {
        projectId,
        status: "REQUEST_RELEASE",
      });
    }
  }
}