@mercuryo-ai/agentbrowse 0.2.50

package/dist/owned-process.js

@@ -0,0 +1,145 @@
+import { execFileSync } from 'node:child_process';
+import path from 'node:path';
+import { getProfilesDir } from './solver/config.js';
+const TERM_WAIT_ATTEMPTS = 10;
+const TERM_WAIT_MS = 100;
+const KILL_WAIT_ATTEMPTS = 5;
+const KILL_WAIT_MS = 20;
+export function isPidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        const code = getErrorCode(error);
+        if (code === 'EPERM') {
+            return true;
+        }
+        return false;
+    }
+}
+export async function terminateOwnedPid(pid) {
+    const processGroupTermination = await terminateSignalTarget(-pid, pid);
+    if (processGroupTermination !== 'not_found') {
+        return processGroupTermination;
+    }
+    return terminateSignalTarget(pid, pid);
+}
+async function terminateSignalTarget(target, pid) {
+    try {
+        process.kill(target, 'SIGTERM');
+    }
+    catch (error) {
+        const code = getErrorCode(error);
+        if (target < 0 && code === 'ESRCH' && isPidAlive(pid)) {
+            return 'not_found';
+        }
+        return isPidAlive(pid) ? 'still_alive' : 'not_found';
+    }
+    if (await waitForPidExit(pid, TERM_WAIT_ATTEMPTS, TERM_WAIT_MS)) {
+        return 'terminated';
+    }
+    try {
+        process.kill(target, 'SIGKILL');
+    }
+    catch {
+        return isPidAlive(pid) ? 'still_alive' : 'sigkilled';
+    }
+    if (await waitForPidExit(pid, KILL_WAIT_ATTEMPTS, KILL_WAIT_MS)) {
+        return 'sigkilled';
+    }
+    return 'still_alive';
+}
+export async function cleanupManagedBrowserPids(options = {}) {
+    const excludePids = new Set(options.excludePids ?? []);
+    const terminated = [];
+    const blocked = [];
+    for (const pid of listManagedBrowserPids({ userDataDir: options.userDataDir })) {
+        if (excludePids.has(pid)) {
+            continue;
+        }
+        const result = await terminateOwnedPid(pid);
+        if (result === 'still_alive') {
+            blocked.push(pid);
+            continue;
+        }
+        if (result !== 'not_found') {
+            terminated.push(pid);
+        }
+    }
+    return { terminated, blocked };
+}
+export function listManagedBrowserPids(options = {}) {
+    const processTable = options.processTable ?? readProcessTable();
+    const pids = new Set();
+    const scopedUserDataDir = options.userDataDir ? path.resolve(options.userDataDir) : null;
+    for (const line of processTable.split(/\r?\n/)) {
+        const match = line.trimStart().match(/^(\d+)\s+(.*)$/);
+        if (!match) {
+            continue;
+        }
+        const pid = Number(match[1]);
+        const command = match[2] ?? '';
+        if (!Number.isFinite(pid) || pid <= 0 || pid === process.pid) {
+            continue;
+        }
+        if (!isManagedBrowserCommand(command, scopedUserDataDir)) {
+            continue;
+        }
+        pids.add(pid);
+    }
+    return Array.from(pids);
+}
+export function isManagedBrowserPid(pid, options = {}) {
+    return listManagedBrowserPids(options).includes(pid);
+}
+async function waitForPidExit(pid, attempts, intervalMs) {
+    for (let attempt = 0; attempt < attempts; attempt++) {
+        if (!isPidAlive(pid)) {
+            return true;
+        }
+        await sleep(intervalMs);
+    }
+    return !isPidAlive(pid);
+}
+function getErrorCode(error) {
+    if (!error || typeof error !== 'object') {
+        return undefined;
+    }
+    const code = Reflect.get(error, 'code');
+    return typeof code === 'string' ? code : undefined;
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function readProcessTable() {
+    try {
+        return execFileSync('ps', ['-Ao', 'pid=,command='], { encoding: 'utf-8' });
+    }
+    catch {
+        return '';
+    }
+}
+function isManagedBrowserCommand(command, scopedUserDataDir) {
+    if (!command.includes('--remote-debugging-address=127.0.0.1')) {
+        return false;
+    }
+    const userDataDir = readCommandFlag(command, '--user-data-dir');
+    if (!userDataDir) {
+        return false;
+    }
+    const normalizedUserDataDir = path.resolve(userDataDir);
+    if (scopedUserDataDir && normalizedUserDataDir !== scopedUserDataDir) {
+        return false;
+    }
+    return isWithinRoot(normalizedUserDataDir, getProfilesDir());
+}
+function readCommandFlag(command, flag) {
+    const escapedFlag = flag.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const match = command.match(new RegExp(`${escapedFlag}=(?:"([^"]+)"|'([^']+)'|(\\S+))`));
+    return match?.[1] ?? match?.[2] ?? match?.[3] ?? null;
+}
+function isWithinRoot(candidatePath, rootPath) {
+    const relative = path.relative(rootPath, candidatePath);
+    return relative.length > 0 && !relative.startsWith(`..${path.sep}`) && relative !== '..';
+}

package/dist/playwright-runtime.d.ts

@@ -0,0 +1,43 @@
+import { type Browser, type Page } from 'playwright-core';
+import type { BrowserSessionState } from './browser-session-state.js';
+export declare function connectPlaywright(cdpUrl: string): Promise<Browser>;
+export declare function disconnectPlaywright(browser: Browser): Promise<void>;
+export declare function listPages(browser: Browser): Page[];
+type LaunchPageMetadata = {
+    page: Page | null;
+    url: string;
+    title: string;
+    targetId?: string;
+};
+export type ResolvedCurrentPageContext = {
+    pageRef: string;
+    page: Page;
+    recoveredVia?: 'opener' | 'sole-live-page';
+};
+export declare function readLaunchPageMetadata(browser: Browser, options?: {
+    requestedUrl?: string;
+    fallbackUrl?: string;
+    fallbackTitle?: string;
+    timeoutMs?: number;
+}): Promise<LaunchPageMetadata>;
+export declare function syncLaunchPage(session: BrowserSessionState, browser: Browser, options?: {
+    requestedUrl?: string;
+    fallbackUrl?: string;
+    fallbackTitle?: string;
+    timeoutMs?: number;
+}): Promise<{
+    url: string;
+    title: string;
+    targetId?: string;
+}>;
+export declare function resolvePageByRef(browser: Browser, session: BrowserSessionState, pageRef: string): Promise<Page>;
+export declare function resolveCurrentPageContext(browser: Browser, session: BrowserSessionState): Promise<ResolvedCurrentPageContext>;
+export declare function syncSessionPage(session: BrowserSessionState, pageRef: string, page: Page, options?: {
+    settleTimeoutMs?: number;
+}): Promise<{
+    url: string;
+    title: string;
+    targetId?: string;
+}>;
+export {};
+//# sourceMappingURL=playwright-runtime.d.ts.map

package/dist/playwright-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"playwright-runtime.d.ts","sourceRoot":"","sources":["../src/playwright-runtime.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,iBAAiB,CAAC;AACpE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAItE,wBAAsB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAExE;AAED,wBAAsB,oBAAoB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAO1E;AAED,wBAAgB,SAAS,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,EAAE,CAElD;AA8CD,KAAK,kBAAkB,GAAG;IACxB,IAAI,EAAE,IAAI,GAAG,IAAI,CAAC;IAClB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAQF,MAAM,MAAM,0BAA0B,GAAG;IACvC,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,IAAI,CAAC;IACX,YAAY,CAAC,EAAE,QAAQ,GAAG,gBAAgB,CAAC;CAC5C,CAAC;AA4IF,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,OAAO,EAChB,OAAO,GAAE;IACP,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,SAAS,CAAC,EAAE,MAAM,CAAC;CACf,GACL,OAAO,CAAC,kBAAkB,CAAC,CA+C7B;AAED,wBAAsB,cAAc,CAClC,OAAO,EAAE,mBAAmB,EAC5B,OAAO,EAAE,OAAO,EAChB,OAAO,GAAE;IACP,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,SAAS,CAAC,EAAE,MAAM,CAAC;CACf,GACL,OAAO,CAAC;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAgC5D;AAED,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,mBAAmB,EAC5B,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,IAAI,CAAC,CA8Cf;AA+CD,wBAAsB,yBAAyB,CAC7C,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,mBAAmB,GAC3B,OAAO,CAAC,0BAA0B,CAAC,CAqCrC;AAED,wBAAsB,eAAe,CACnC,OAAO,EAAE,mBAAmB,EAC5B,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,IAAI,EACV,OAAO,GAAE;IACP,eAAe,CAAC,EAAE,MAAM,CAAC;CACrB,GACL,OAAO,CAAC;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAgB5D"}

package/dist/playwright-runtime.js

@@ -0,0 +1,339 @@
+import { chromium } from 'playwright-core';
+import { ensureRuntimeState } from './runtime-state.js';
+import { registerPage, updatePage } from './runtime-page-state.js';
+export async function connectPlaywright(cdpUrl) {
+    return chromium.connectOverCDP(cdpUrl);
+}
+export async function disconnectPlaywright(browser) {
+    const maybeClose = browser.close;
+    if (typeof maybeClose !== 'function') {
+        return;
+    }
+    await Promise.resolve(maybeClose.call(browser)).catch(() => undefined);
+}
+export function listPages(browser) {
+    return browser.contexts().flatMap((context) => context.pages());
+}
+function buildPageResolutionError(kind, pageRef) {
+    return new Error(`${kind === 'unknown' ? 'unknown_page_ref' : 'stale_page_ref'}:${pageRef}`);
+}
+function isPageResolutionError(error, kind, pageRef) {
+    return (error instanceof Error &&
+        error.message === `${kind === 'unknown' ? 'unknown_page_ref' : 'stale_page_ref'}:${pageRef}`);
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function normalizeComparableUrl(value) {
+    const raw = value?.trim();
+    if (!raw) {
+        return null;
+    }
+    try {
+        const url = new URL(raw);
+        url.hash = '';
+        url.search = '';
+        return `${url.origin}${url.pathname}`;
+    }
+    catch {
+        return raw;
+    }
+}
+function isMeaningfulUrl(value) {
+    const raw = value?.trim();
+    return Boolean(raw && raw !== ':' && raw !== 'about:blank');
+}
+function isMeaningfulTitle(value) {
+    return Boolean(value?.trim());
+}
+function preferMeaningfulValue(value, fallback, predicate) {
+    if (predicate(value)) {
+        return value ?? '';
+    }
+    if (predicate(fallback)) {
+        return fallback ?? '';
+    }
+    return value ?? fallback ?? '';
+}
+function scoreLaunchPageMetadata(metadata, options) {
+    const normalizedUrl = normalizeComparableUrl(metadata.url);
+    const requestedUrl = normalizeComparableUrl(options.requestedUrl);
+    const fallbackUrl = normalizeComparableUrl(options.fallbackUrl);
+    let score = 0;
+    if (requestedUrl && normalizedUrl === requestedUrl) {
+        score += 200;
+    }
+    else if (fallbackUrl && normalizedUrl === fallbackUrl) {
+        score += 180;
+    }
+    else if (isMeaningfulUrl(metadata.url)) {
+        score += 100;
+    }
+    if (isMeaningfulTitle(metadata.title)) {
+        score += 20;
+    }
+    if (metadata.targetId) {
+        score += 5;
+    }
+    return score;
+}
+async function readPageTargetId(page) {
+    try {
+        const cdp = await page.context().newCDPSession(page);
+        try {
+            const result = (await cdp.send('Target.getTargetInfo'));
+            return result.targetInfo?.targetId;
+        }
+        finally {
+            await cdp.detach().catch(() => undefined);
+        }
+    }
+    catch {
+        return undefined;
+    }
+}
+async function readPageMetadata(page) {
+    const [url, title, targetId] = await Promise.all([
+        Promise.resolve(page.url()),
+        page.title().catch(() => ''),
+        readPageTargetId(page),
+    ]);
+    return { page, url, title, targetId };
+}
+async function readSessionPageMetadata(session, pageRef, page) {
+    const existing = session.runtime?.pages[pageRef];
+    const [url, targetId, title] = await Promise.all([
+        Promise.resolve(page.url()),
+        readPageTargetId(page),
+        page.title().catch(() => existing?.title ?? ''),
+    ]);
+    return {
+        url,
+        title,
+        targetId,
+    };
+}
+async function readSettledSessionPageMetadata(session, pageRef, page, options = {}) {
+    const existing = session.runtime?.pages[pageRef];
+    const deadline = Date.now() + (options.settleTimeoutMs ?? 0);
+    let best = null;
+    while (Date.now() <= deadline) {
+        const metadata = await readSessionPageMetadata(session, pageRef, page);
+        const score = (isMeaningfulUrl(metadata.url) ? 100 : 0) +
+            (isMeaningfulTitle(metadata.title) ? 20 : 0) +
+            (metadata.targetId ? 5 : 0);
+        if (!best ||
+            score > best.score ||
+            (score === best.score && metadata.title.trim().length > best.title.trim().length)) {
+            best = { ...metadata, score };
+        }
+        if (best &&
+            isMeaningfulUrl(best.url) &&
+            (isMeaningfulTitle(best.title) || best.targetId || Date.now() >= deadline)) {
+            break;
+        }
+        if (Date.now() >= deadline) {
+            break;
+        }
+        await sleep(100);
+    }
+    const metadata = best ?? (await readSessionPageMetadata(session, pageRef, page));
+    return {
+        url: preferMeaningfulValue(metadata.url, existing?.url, isMeaningfulUrl),
+        title: preferMeaningfulValue(metadata.title, existing?.title, isMeaningfulTitle),
+        targetId: metadata.targetId ?? existing?.targetId,
+    };
+}
+export async function readLaunchPageMetadata(browser, options = {}) {
+    const deadline = Date.now() + (options.timeoutMs ?? 2_500);
+    let best = null;
+    while (Date.now() <= deadline) {
+        const pages = listPages(browser);
+        for (const page of pages) {
+            const metadata = await readPageMetadata(page);
+            const score = scoreLaunchPageMetadata(metadata, options);
+            if (!best ||
+                score > best.score ||
+                (score === best.score && metadata.title.trim().length > best.title.trim().length)) {
+                best = { ...metadata, score };
+            }
+        }
+        if (best &&
+            isMeaningfulUrl(best.url) &&
+            (isMeaningfulTitle(best.title) || Date.now() >= deadline)) {
+            break;
+        }
+        if (Date.now() >= deadline) {
+            break;
+        }
+        await sleep(100);
+    }
+    if (best) {
+        return {
+            page: best.page,
+            url: isMeaningfulUrl(best.url) ? best.url : (options.fallbackUrl ?? best.url),
+            title: isMeaningfulTitle(best.title) ? best.title : (options.fallbackTitle ?? best.title),
+            targetId: best.targetId,
+        };
+    }
+    return {
+        page: null,
+        url: options.fallbackUrl ?? '',
+        title: options.fallbackTitle ?? '',
+    };
+}
+export async function syncLaunchPage(session, browser, options = {}) {
+    const metadata = await readLaunchPageMetadata(browser, options);
+    if (!metadata.page) {
+        return {
+            url: metadata.url,
+            title: metadata.title,
+            targetId: metadata.targetId,
+        };
+    }
+    ensureRuntimeState(session);
+    if (session.runtime?.pages.p0) {
+        updatePage(session, 'p0', {
+            url: metadata.url,
+            title: metadata.title,
+            targetId: metadata.targetId,
+        });
+    }
+    else {
+        registerPage(session, {
+            pageRef: 'p0',
+            url: metadata.url,
+            title: metadata.title,
+            targetId: metadata.targetId,
+            makeCurrent: true,
+        });
+    }
+    return {
+        url: metadata.url,
+        title: metadata.title,
+        targetId: metadata.targetId,
+    };
+}
+export async function resolvePageByRef(browser, session, pageRef) {
+    const pages = listPages(browser);
+    if (pages.length === 0) {
+        throw new Error('no_open_pages');
+    }
+    const pageState = session.runtime?.pages[pageRef];
+    if (!pageState) {
+        throw buildPageResolutionError('unknown', pageRef);
+    }
+    if (!pageState.targetId && !pageState.url && !pageState.title) {
+        if (pages.length === 1) {
+            return pages[0];
+        }
+        throw buildPageResolutionError('stale', pageRef);
+    }
+    if (pageState.targetId) {
+        for (const page of pages) {
+            if ((await readPageTargetId(page)) === pageState.targetId) {
+                return page;
+            }
+        }
+    }
+    if (pageState.url && pageState.title) {
+        for (const page of pages) {
+            const liveTitle = await page.title().catch(() => '');
+            if (page.url() === pageState.url && liveTitle === pageState.title) {
+                return page;
+            }
+        }
+    }
+    if (!pageState.url) {
+        throw buildPageResolutionError('stale', pageRef);
+    }
+    for (const page of pages) {
+        if (page.url() === pageState.url) {
+            return page;
+        }
+    }
+    throw buildPageResolutionError('stale', pageRef);
+}
+async function findRecoverableCurrentPageRef(browser, session, stalePageRef) {
+    const runtimePages = session.runtime?.pages ?? {};
+    const stalePageState = runtimePages[stalePageRef];
+    const openerPageRef = stalePageState?.openerPageRef;
+    if (openerPageRef && openerPageRef !== stalePageRef) {
+        try {
+            await resolvePageByRef(browser, session, openerPageRef);
+            return {
+                pageRef: openerPageRef,
+                recoveredVia: 'opener',
+            };
+        }
+        catch {
+            // Keep recovery fail-closed unless opener or a single live alternative is provably valid.
+        }
+    }
+    const liveCandidateRefs = [];
+    for (const candidatePageRef of Object.keys(runtimePages)) {
+        if (candidatePageRef === stalePageRef || candidatePageRef === openerPageRef) {
+            continue;
+        }
+        try {
+            await resolvePageByRef(browser, session, candidatePageRef);
+            liveCandidateRefs.push(candidatePageRef);
+        }
+        catch {
+            // Ignore stale or unknown candidates while looking for a single surviving live page.
+        }
+    }
+    if (liveCandidateRefs.length === 1) {
+        return {
+            pageRef: liveCandidateRefs[0],
+            recoveredVia: 'sole-live-page',
+        };
+    }
+    return null;
+}
+export async function resolveCurrentPageContext(browser, session) {
+    const currentPageRef = session.runtime?.currentPageRef ?? 'p0';
+    try {
+        const page = await resolvePageByRef(browser, session, currentPageRef);
+        return {
+            pageRef: currentPageRef,
+            page,
+        };
+    }
+    catch (error) {
+        if (isPageResolutionError(error, 'unknown', currentPageRef)) {
+            const pages = listPages(browser);
+            if (pages.length === 1) {
+                return {
+                    pageRef: currentPageRef,
+                    page: pages[0],
+                    recoveredVia: 'sole-live-page',
+                };
+            }
+            throw error;
+        }
+        if (!isPageResolutionError(error, 'stale', currentPageRef)) {
+            throw error;
+        }
+        const recovered = await findRecoverableCurrentPageRef(browser, session, currentPageRef);
+        if (!recovered) {
+            throw error;
+        }
+        return {
+            pageRef: recovered.pageRef,
+            page: await resolvePageByRef(browser, session, recovered.pageRef),
+            recoveredVia: recovered.recoveredVia,
+        };
+    }
+}
+export async function syncSessionPage(session, pageRef, page, options = {}) {
+    ensureRuntimeState(session);
+    const { url, title, targetId } = await readSettledSessionPageMetadata(session, pageRef, page, options);
+    if (session.runtime?.pages[pageRef]) {
+        updatePage(session, pageRef, { url, title, targetId });
+    }
+    else {
+        registerPage(session, { pageRef, url, title, targetId, makeCurrent: false });
+    }
+    return { url, title, targetId };
+}

package/dist/protected-fill-browser.d.ts

@@ -0,0 +1,22 @@
+import type { BrowserSessionState } from './browser-session-state.js';
+import { type ProtectedFillExecutionResult } from './secrets/protected-fill.js';
+import type { PersistedFillableForm, StoredSecretFieldPolicies, StoredSecretFieldKey } from './secrets/types.js';
+export type FillProtectedFormBrowserResult = {
+    success: true;
+    pageRef: string;
+    url: string;
+    title: string;
+    execution: ProtectedFillExecutionResult;
+} | {
+    success: false;
+    error: 'browser_connection_failed' | 'page_resolution_failed';
+    message: string;
+    reason: string;
+};
+export declare function fillProtectedFormBrowser(params: {
+    session: BrowserSessionState;
+    fillableForm: PersistedFillableForm;
+    protectedValues: Partial<Record<StoredSecretFieldKey, string>>;
+    fieldPolicies?: StoredSecretFieldPolicies;
+}): Promise<FillProtectedFormBrowserResult>;
+//# sourceMappingURL=protected-fill-browser.d.ts.map

package/dist/protected-fill-browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"protected-fill-browser.d.ts","sourceRoot":"","sources":["../src/protected-fill-browser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAOtE,OAAO,EAEL,KAAK,4BAA4B,EAClC,MAAM,6BAA6B,CAAC;AACrC,OAAO,KAAK,EACV,qBAAqB,EACrB,yBAAyB,EACzB,oBAAoB,EACrB,MAAM,oBAAoB,CAAC;AAE5B,MAAM,MAAM,8BAA8B,GACtC;IACE,OAAO,EAAE,IAAI,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,4BAA4B,CAAC;CACzC,GACD;IACE,OAAO,EAAE,KAAK,CAAC;IACf,KAAK,EAAE,2BAA2B,GAAG,wBAAwB,CAAC;IAC9D,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEN,wBAAsB,wBAAwB,CAAC,MAAM,EAAE;IACrD,OAAO,EAAE,mBAAmB,CAAC;IAC7B,YAAY,EAAE,qBAAqB,CAAC;IACpC,eAAe,EAAE,OAAO,CAAC,MAAM,CAAC,oBAAoB,EAAE,MAAM,CAAC,CAAC,CAAC;IAC/D,aAAa,CAAC,EAAE,yBAAyB,CAAC;CAC3C,GAAG,OAAO,CAAC,8BAA8B,CAAC,CAqD1C"}

package/dist/protected-fill-browser.js

@@ -0,0 +1,52 @@
+import { connectPlaywright, disconnectPlaywright, resolvePageByRef, syncSessionPage, } from './playwright-runtime.js';
+import { executeProtectedFill, } from './secrets/protected-fill.js';
+export async function fillProtectedFormBrowser(params) {
+    let browser = null;
+    try {
+        browser = await connectPlaywright(params.session.cdpUrl);
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: 'browser_connection_failed',
+            message: 'Protected fill could not connect to the browser.',
+            reason: error instanceof Error ? error.message : String(error),
+        };
+    }
+    try {
+        const page = await resolvePageByRef(browser, params.session, params.fillableForm.pageRef).catch((error) => {
+            throw new Error(error instanceof Error ? error.message : String(error));
+        });
+        const { url, title } = await syncSessionPage(params.session, params.fillableForm.pageRef, page);
+        const execution = await executeProtectedFill({
+            session: params.session,
+            page,
+            fillableForm: params.fillableForm,
+            protectedValues: Object.fromEntries(Object.entries(params.protectedValues).filter((entry) => {
+                const value = entry[1];
+                return typeof value === 'string' && value.length > 0;
+            })),
+            fieldPolicies: params.fieldPolicies,
+        });
+        return {
+            success: true,
+            pageRef: params.fillableForm.pageRef,
+            url,
+            title,
+            execution,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: 'page_resolution_failed',
+            message: 'Protected fill could not resolve the target page in the browser.',
+            reason: error instanceof Error ? error.message : String(error),
+        };
+    }
+    finally {
+        if (browser) {
+            await disconnectPlaywright(browser);
+        }
+    }
+}

package/dist/protected-fill.d.ts

@@ -0,0 +1,82 @@
+import type { BrowserSessionState } from "./browser-session-state.js";
+import type { FillableFormFieldBinding, FillableFormPresence, ProtectedBindingValueHint, ProtectedFieldPolicy, StoredSecretFieldKey, StoredSecretFieldPolicies } from "./secrets/types.js";
+import type { ProtectedExactValueProfile } from "./runtime-state.js";
+/** Canonical stored protected field keys supported by AgentBrowse protected fill. */
+export type ProtectedFieldKey = StoredSecretFieldKey;
+export type ProtectedFieldPolicyMode = ProtectedFieldPolicy;
+export type ProtectedFieldPolicies = StoredSecretFieldPolicies;
+export type ProtectedFieldValueHint = ProtectedBindingValueHint;
+export type ProtectedFillPresence = FillableFormPresence;
+export type { ProtectedExactValueProfile } from "./runtime-state.js";
+/** Single field binding inside a protected fill form. */
+export interface ProtectedFillFieldBinding extends FillableFormFieldBinding {
+}
+/** Protected fill form returned from `observe(...)` and accepted by `fillProtectedForm(...)`. */
+export interface ProtectedFillForm {
+    fillRef: string;
+    pageRef: string;
+    scopeRef?: string;
+    purpose: string;
+    presence?: ProtectedFillPresence;
+    scopeEpoch?: number;
+    fields: ProtectedFillFieldBinding[];
+    observedAt: string;
+}
+/** Single field that AgentBrowse filled during a protected fill run. */
+export interface ProtectedFilledField {
+    fieldKey: ProtectedFieldKey;
+    targetRef: string;
+}
+/** Field-level validation or application failure for protected fill. */
+export interface ProtectedFieldError extends ProtectedFilledField {
+    reason: "client_validation_rejected" | "value_not_applied";
+    validationTextRedacted?: true;
+}
+export type ProtectedFillExecution = {
+    kind: "success";
+    filledFields: ProtectedFilledField[];
+} | {
+    kind: "binding_stale";
+    targetRef: string;
+    fieldKeys: ProtectedFieldKey[];
+    reason: "target_missing" | "target_not_live" | "page_signature_mismatch" | "dom_signature_mismatch" | "locator_resolution_failed" | "target_blocked";
+    attempts: string[];
+} | {
+    kind: "validation_failed";
+    filledFields: ProtectedFilledField[];
+    fieldErrors: ProtectedFieldError[];
+} | {
+    kind: "unexpected_error";
+    reason: "missing_protected_value" | "unsupported_protected_field_group" | "deterministic_only_resolution_failed" | "assisted_value_resolution_failed" | "action_failed";
+};
+export type FillProtectedFormResult = {
+    success: true;
+    pageRef: string;
+    url: string;
+    title: string;
+    execution: ProtectedFillExecution;
+} | {
+    success: false;
+    error: "browser_connection_failed" | "page_resolution_failed";
+    message: string;
+    reason: string;
+};
+export interface FillProtectedFormInput {
+    session: BrowserSessionState;
+    fillableForm: ProtectedFillForm;
+    protectedValues: Partial<Record<ProtectedFieldKey, string>>;
+    fieldPolicies?: ProtectedFieldPolicies;
+}
+export interface BuildProtectedExposureArtifactsInput {
+    session: BrowserSessionState;
+    fillableForm: ProtectedFillForm;
+    protectedValues: Partial<Record<ProtectedFieldKey, string>>;
+    fieldPolicies?: ProtectedFieldPolicies;
+}
+export interface ProtectedExposureArtifacts {
+    exactValueProfile: ProtectedExactValueProfile;
+}
+/** Fills a previously observed protected form with caller-provided protected values. */
+export declare function fillProtectedForm(params: FillProtectedFormInput): Promise<FillProtectedFormResult>;
+export declare function buildProtectedExposureArtifacts(params: BuildProtectedExposureArtifactsInput): ProtectedExposureArtifacts;
+//# sourceMappingURL=protected-fill.d.ts.map