@nuanu-ai/agentbrowse 0.2.7 → 0.2.8

package/dist/commands/observe-surfaces.js

@@ -0,0 +1,195 @@
+import { locatorCandidateKey } from '../runtime-state.js';
+const HIGH_SIGNAL_SCOPE_KINDS = new Set([
+    'dialog',
+    'listbox',
+    'menu',
+    'grid',
+    'tabpanel',
+    'popover',
+    'dropdown',
+    'datepicker',
+]);
+export function selectScopesForOutput(scopes, targets, preferredScopeRefs) {
+    if (scopes.length === 0) {
+        return [];
+    }
+    const linkedScopeRefs = new Set(targets
+        .slice(0, 20)
+        .map((target) => target.surfaceRef)
+        .filter((value) => typeof value === 'string' && value.length > 0));
+    const scored = scopes
+        .map((scope) => {
+        const scopeTargets = targets.filter((target) => target.surfaceRef === scope.ref);
+        const kind = (scope.kind ?? '').toLowerCase();
+        const overlayLike = HIGH_SIGNAL_SCOPE_KINDS.has(kind);
+        const linkedCount = scopeTargets.length;
+        const interactionRich = scopeTargets.some((target) => target.allowedActions.includes('fill') ||
+            target.allowedActions.includes('select') ||
+            target.acceptancePolicy === 'selection' ||
+            target.acceptancePolicy === 'date-selection');
+        const directlyLinked = linkedScopeRefs.has(scope.ref);
+        const explicitlyPreferred = preferredScopeRefs?.has(scope.ref) === true;
+        let score = 0;
+        if (explicitlyPreferred)
+            score += 160;
+        if (directlyLinked)
+            score += 100;
+        if (overlayLike)
+            score += 60;
+        if (interactionRich)
+            score += 30;
+        score += Math.min(linkedCount, 6) * 5;
+        return { scope, score };
+    })
+        .filter(({ score }) => score > 0)
+        .sort((left, right) => right.score - left.score || left.scope.ref.localeCompare(right.scope.ref));
+    if (scored.length > 0) {
+        return scored.slice(0, 12).map(({ scope }) => scope);
+    }
+    return scopes
+        .filter((scope) => HIGH_SIGNAL_SCOPE_KINDS.has((scope.kind ?? '').toLowerCase()))
+        .slice(0, 8);
+}
+export function buildSurfaceRef(target) {
+    if (!target.surfaceKind && !target.surfaceSelector && !target.surfaceLabel) {
+        return undefined;
+    }
+    const frameKey = target.framePath?.join('>') ?? 'top';
+    return [
+        target.pageSignature ?? 'unknown-page',
+        frameKey,
+        target.surfaceKind ?? 'surface',
+        target.surfaceSelector ?? '',
+        target.surfaceLabel ?? '',
+    ].join('|');
+}
+export function surfaceReplacementKey(surface) {
+    const pageKey = surface.pageSignature ?? surface.pageRef;
+    const frameKey = surface.framePath?.join('>') ?? 'top';
+    const kindKey = (surface.kind ?? 'surface').toLowerCase();
+    const labelKey = (surface.label ?? '').trim().toLowerCase();
+    return `${pageKey}|${frameKey}|${kindKey}|${labelKey}`;
+}
+export function summarizeContext(context) {
+    if (!context)
+        return undefined;
+    const parts = [];
+    if (context.item?.label) {
+        parts.push(context.item.label);
+    }
+    else if (context.item?.kind) {
+        parts.push(context.item.kind);
+    }
+    if (context.group?.label) {
+        parts.push(context.group.label);
+    }
+    else if (context.group?.kind) {
+        parts.push(context.group.kind);
+    }
+    if (parts.length === 0 && context.container?.label) {
+        parts.push(context.container.label);
+    }
+    else if (parts.length === 0 && context.container?.kind) {
+        parts.push(context.container.kind);
+    }
+    if (context.landmark?.label &&
+        context.landmark.label !== context.container?.label &&
+        context.landmark.label !== context.group?.label) {
+        parts.push(context.landmark.label);
+    }
+    else if (context.landmark?.kind &&
+        context.landmark.kind !== context.container?.kind &&
+        context.landmark.kind !== context.group?.kind &&
+        !context.landmark?.label) {
+        parts.push(context.landmark.kind);
+    }
+    if (parts.length === 0 && context.hintText) {
+        parts.push(context.hintText);
+    }
+    if (parts.length === 0)
+        return undefined;
+    return parts.join(' / ');
+}
+export function pushUniqueLocatorCandidate(acc, candidate) {
+    if (!candidate)
+        return;
+    const key = locatorCandidateKey(candidate);
+    if (acc.some((existing) => locatorCandidateKey(existing) === key)) {
+        return;
+    }
+    acc.push(candidate);
+}
+function surfaceRoleFromKind(kind) {
+    const normalized = (kind ?? '').trim().toLowerCase();
+    switch (normalized) {
+        case 'card':
+            return 'article';
+        case 'article':
+        case 'dialog':
+        case 'listbox':
+        case 'menu':
+        case 'grid':
+        case 'tabpanel':
+        case 'group':
+        case 'region':
+        case 'listitem':
+        case 'row':
+        case 'form':
+            return normalized;
+        case 'fieldset':
+            return 'group';
+        case 'section':
+            return 'region';
+        default:
+            return undefined;
+    }
+}
+function collectSurfaceLocatorCandidates(target) {
+    const candidates = [];
+    const selectors = [target.surfaceSelector, ...(target.surfaceSelectors ?? [])].filter((value) => typeof value === 'string' && value.length > 0);
+    for (const selector of selectors) {
+        pushUniqueLocatorCandidate(candidates, {
+            strategy: selector.startsWith('xpath=') ? 'xpath' : 'css',
+            value: selector,
+            scope: 'root',
+        });
+    }
+    const surfaceRole = surfaceRoleFromKind(target.surfaceKind);
+    if (surfaceRole) {
+        pushUniqueLocatorCandidate(candidates, target.surfaceLabel
+            ? { strategy: 'role', value: surfaceRole, name: target.surfaceLabel }
+            : undefined);
+        pushUniqueLocatorCandidate(candidates, { strategy: 'role', value: surfaceRole });
+    }
+    return candidates;
+}
+export function collectSurfaceDescriptors(pageRef, targets) {
+    const descriptors = new Map();
+    for (const target of targets) {
+        const surfaceId = target.surfaceRef;
+        if (!surfaceId) {
+            continue;
+        }
+        const existing = descriptors.get(surfaceId);
+        const locatorCandidates = existing ? [...existing.locatorCandidates] : [];
+        for (const candidate of collectSurfaceLocatorCandidates(target)) {
+            pushUniqueLocatorCandidate(locatorCandidates, candidate);
+        }
+        descriptors.set(surfaceId, {
+            surfaceId,
+            pageRef,
+            framePath: existing?.framePath ?? target.framePath,
+            frameUrl: existing?.frameUrl ?? target.frameUrl,
+            kind: existing?.kind ?? target.surfaceKind ?? 'surface',
+            label: existing?.label && existing.label !== 'Active surface'
+                ? existing.label
+                : target.surfaceLabel ?? target.surfaceKind ?? existing?.label ?? 'Active surface',
+            lifecycle: 'live',
+            availability: { state: 'available' },
+            locatorCandidates,
+            createdAt: existing?.createdAt ?? Date.now(),
+            pageSignature: existing?.pageSignature ?? target.pageSignature,
+        });
+    }
+    return [...descriptors.values()];
+}

package/dist/commands/observe.d.ts

@@ -1,5 +1,51 @@
 /**
  * browse observe ["<instruction>"] — Discover available actions on the page.
  */
-export declare function observe(cdpUrl: string, instruction?: string): Promise<void>;
+import type { BrowseSession } from '../session.js';
+import { toStagehandDescriptor } from './observe-stagehand.js';
+export declare const __testDomTargetCollection: {
+    collectDomTargetsFromDocument: (context: {
+        evaluate<T>(pageFunction: string): Promise<T>;
+    }, options?: import("./observe-inventory.js").DomTargetCollectionOptions & {
+        framePath?: string[];
+        frameUrl?: string;
+    }) => Promise<import("./observe-inventory.js").DomObservedTarget[]>;
+    collectPageSignalsFromDocument: (context: {
+        evaluate<T>(pageFunction: string): Promise<T>;
+    }, options?: {
+        framePath?: string[];
+        frameUrl?: string;
+    }) => Promise<import("./observe-inventory.js").ObservedPageSignal[]>;
+    locatorDomSignatureScript: string;
+};
+export declare const __testStagehandDescriptor: {
+    toStagehandDescriptor: typeof toStagehandDescriptor;
+    normalizeStagehandSelector: typeof import("./observe-inventory.js").normalizeStagehandSelector;
+    readStagehandDomFacts: (locator: import("playwright-core").Locator) => Promise<{
+        kind?: string;
+        role?: string;
+        placeholder?: string;
+        inputName?: string;
+        inputType?: string;
+        autocomplete?: string;
+        value?: string;
+        text?: string;
+        currentValue?: string;
+        states?: Record<string, string | boolean | number>;
+    } | null>;
+    readStagehandDomFactsInBrowser: (element: Element) => {
+        kind?: string;
+        role?: string;
+        placeholder?: string;
+        inputName?: string;
+        inputType?: string;
+        autocomplete?: string;
+        value?: string;
+        text?: string;
+        currentValue?: string;
+        states?: Record<string, string | boolean | number>;
+    } | null;
+    stagehandDomFactsScript: string;
+};
+export declare function observe(session: BrowseSession, instruction?: string): Promise<void>;
 //# sourceMappingURL=observe.d.ts.map

package/dist/commands/observe.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"observe.d.ts","sourceRoot":"","sources":["../../src/commands/observe.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH,wBAAsB,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAiCjF"}
+{"version":3,"file":"observe.d.ts","sourceRoot":"","sources":["../../src/commands/observe.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AA+CnD,OAAO,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAU/D,eAAO,MAAM,yBAAyB;;;;iBA0Ou0F,CAAC;gBAAwB,CAAC;;;;;iBAAq7vE,CAAC;gBAAwB,CAAC;;;CA1Ojx1E,CAAC;AACtE,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGrC,CAAC;AAEF,wBAAsB,OAAO,CAAC,OAAO,EAAE,aAAa,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAmOzF"}

package/dist/commands/observe.js

@@ -1,37 +1,190 @@
 /**
  * browse observe ["<instruction>"] — Discover available actions on the page.
  */
-import { connectStagehand, getPageInfo } from '../stagehand.js';
-import { outputJSON, outputError } from '../output.js';
-export async function observe(cdpUrl, instruction) {
-    let stagehand;
+import { saveSession } from '../session.js';
+import { ensureRuntimeState, incrementMetric, replaceTargetsForPage } from '../runtime-state.js';
+import { connectPlaywright, disconnectPlaywright, resolvePageByRef, syncSessionPage, } from '../playwright-runtime.js';
+import { outputContractFailure, outputJSON } from '../output.js';
+import { domRuntimeResolution, stagehandRuntimeResolution } from '../runtime-resolution.js';
+import { withStagehand } from '../stagehand-runtime.js';
+import { normalizePageSignature } from './descriptor-validation.js';
+import { collectDomTargets, collectPageSignals, __testDomTargetCollection as inventoryDomTargetCollection, __testStagehandDescriptor as inventoryStagehandDescriptor, } from './observe-inventory.js';
+import { attachObservedTargetOwners, reconcileObservedTargetsForPage, persistObservedSurfacesForPage, toDomDescriptor, } from './observe-persistence.js';
+import { clearProtectedFillableFormsForPage, persistProtectedFillableFormsForPage, } from './observe-protected.js';
+import { annotateDomTargets, compressSemanticallyDuplicateTargets, expandRerankedFormTargets, orderBySurfaceCompetition, } from './observe-semantics.js';
+import { buildExplicitScopeRefs, buildGoalObserveInventoryCandidates, compactFillableForms, compactScopes, compactSignals, compactTargets, projectPersistedTargetsForGoal, selectTargetsForGoalMatches, } from './observe-projection.js';
+import { collectSurfaceDescriptors, selectScopesForOutput } from './observe-surfaces.js';
+import { toStagehandDescriptor } from './observe-stagehand.js';
+import { rerankDomTargetsForGoal } from './semantic-observe.js';
+export const __testDomTargetCollection = inventoryDomTargetCollection;
+export const __testStagehandDescriptor = {
+    ...inventoryStagehandDescriptor,
+    toStagehandDescriptor,
+};
+export async function observe(session, instruction) {
+    const runtime = ensureRuntimeState(session);
+    const pageRef = runtime.currentPageRef;
+    let domPassError = null;
+    let stagehandFallbackReason = null;
+    let browser = null;
+    let observedScopes = [];
+    if (!instruction) {
+        try {
+            browser = await connectPlaywright(session.cdpUrl);
+            const page = await resolvePageByRef(browser, session, pageRef);
+            const { url, title } = await syncSessionPage(session, pageRef, page);
+            const domTargets = compressSemanticallyDuplicateTargets(orderBySurfaceCompetition(annotateDomTargets(await collectDomTargets(page))));
+            const signals = compactSignals(await collectPageSignals(page).catch(() => []));
+            const persisted = persistObservedSurfacesForPage(session, pageRef, domTargets);
+            observedScopes = persisted.observedScopes;
+            const surfaceRefMap = persisted.surfaceRefMap;
+            if (domTargets.length > 0) {
+                const targets = replaceTargetsForPage(session, pageRef, domTargets.map((target) => toDomDescriptor(pageRef, target, surfaceRefMap)));
+                reconcileObservedTargetsForPage(session, pageRef, targets);
+                attachObservedTargetOwners(domTargets, targets);
+                const fillableForms = await persistProtectedFillableFormsForPage(session, pageRef, url, targets, new Date().toISOString());
+                saveSession(session);
+                disconnectPlaywright(browser);
+                browser = null;
+                outputJSON({
+                    success: true,
+                    pageRef,
+                    resolvedBy: 'dom',
+                    ...domRuntimeResolution(),
+                    scopes: compactScopes(selectScopesForOutput(observedScopes, targets)),
+                    targets: compactTargets(targets),
+                    signals,
+                    fillableForms: compactFillableForms(fillableForms),
+                    metrics: session.runtime?.metrics,
+                    message: targets.length === 0 ? 'No targets found.' : undefined,
+                    url,
+                    title,
+                });
+                return;
+            }
+            stagehandFallbackReason = 'deterministic-observe-empty';
+        }
+        catch (err) {
+            domPassError = err instanceof Error ? err.message : String(err);
+            stagehandFallbackReason = 'deterministic-observe-failed';
+        }
+    }
+    if (instruction) {
+        try {
+            if (!browser) {
+                browser = await connectPlaywright(session.cdpUrl);
+            }
+            const page = await resolvePageByRef(browser, session, pageRef);
+            const { url, title } = await syncSessionPage(session, pageRef, page);
+            const domTargets = compressSemanticallyDuplicateTargets(orderBySurfaceCompetition(annotateDomTargets(await collectDomTargets(page, { includeActivationAffordances: true }))));
+            const signals = compactSignals(await collectPageSignals(page).catch(() => []));
+            const surfaceInputs = collectSurfaceDescriptors(pageRef, domTargets);
+            if (domTargets.length > 0) {
+                const rerankedCandidates = await rerankDomTargetsForGoal(instruction, buildGoalObserveInventoryCandidates(domTargets, surfaceInputs));
+                const { targets: goalMatchedTargets, selectedSurfaceIds } = selectTargetsForGoalMatches(domTargets, rerankedCandidates);
+                const selectedTargets = expandRerankedFormTargets(domTargets, goalMatchedTargets);
+                if (selectedTargets.length > 0 || selectedSurfaceIds.size > 0) {
+                    const persisted = persistObservedSurfacesForPage(session, pageRef, domTargets, {
+                        allSurfaceInputs: surfaceInputs,
+                        explicitSurfaceIds: selectedSurfaceIds,
+                    });
+                    observedScopes = persisted.observedScopes;
+                    const surfaceRefMap = persisted.surfaceRefMap;
+                    const targets = replaceTargetsForPage(session, pageRef, domTargets.map((target) => toDomDescriptor(pageRef, target, surfaceRefMap)));
+                    reconcileObservedTargetsForPage(session, pageRef, targets);
+                    const explicitScopeRefs = buildExplicitScopeRefs(selectedSurfaceIds, surfaceRefMap);
+                    attachObservedTargetOwners(domTargets, targets);
+                    const fillableForms = await persistProtectedFillableFormsForPage(session, pageRef, url, targets, new Date().toISOString());
+                    const projectedTargets = projectPersistedTargetsForGoal(domTargets, targets, selectedTargets);
+                    saveSession(session);
+                    disconnectPlaywright(browser);
+                    browser = null;
+                    outputJSON({
+                        success: true,
+                        pageRef,
+                        resolvedBy: 'dom-rerank',
+                        ...domRuntimeResolution(),
+                        scopes: compactScopes(selectScopesForOutput(observedScopes, projectedTargets, explicitScopeRefs)),
+                        targets: compactTargets(projectedTargets),
+                        signals,
+                        fillableForms: compactFillableForms(fillableForms),
+                        metrics: session.runtime?.metrics,
+                        url,
+                        title,
+                    });
+                    return;
+                }
+                stagehandFallbackReason = 'dom-rerank-empty';
+            }
+            else {
+                stagehandFallbackReason = 'deterministic-observe-empty';
+            }
+        }
+        catch (err) {
+            domPassError = err instanceof Error ? err.message : String(err);
+            stagehandFallbackReason = 'deterministic-observe-failed';
+        }
+    }
     try {
-        stagehand = await connectStagehand(cdpUrl);
+        if (!browser) {
+            browser = await connectPlaywright(session.cdpUrl);
+        }
     }
     catch (err) {
-        outputError(`Failed to connect to browser: ${err instanceof Error ? err.message : String(err)}`);
+        const domFailure = domPassError && domPassError.length > 0 ? `; dom observe failed: ${domPassError}` : '';
+        outputContractFailure({
+            error: 'browser_connection_failed',
+            outcomeType: 'blocked',
+            message: 'Observe could not start because AgentBrowse failed to connect to the browser.',
+            reason: `${err instanceof Error ? err.message : String(err)}${domFailure}`,
+            pageRef,
+        });
     }
     try {
-        const actions = instruction
-            ? await stagehand.observe(instruction)
-            : await stagehand.observe();
-        const { url, title } = await getPageInfo(stagehand);
-        await stagehand.close();
+        const page = await resolvePageByRef(browser, session, pageRef);
+        const { url, title } = await syncSessionPage(session, pageRef, page);
+        const signals = compactSignals(await collectPageSignals(page).catch(() => []));
+        const actions = await withStagehand(session, async (stagehand) => {
+            incrementMetric(session, 'stagehandCalls');
+            return instruction
+                ? (await stagehand.observe(instruction, { page }))
+                : (await stagehand.observe({ page }));
+        });
+        const targets = replaceTargetsForPage(session, pageRef, await Promise.all(actions.map((action) => toStagehandDescriptor(pageRef, action, page, normalizePageSignature(url)))));
+        const fillableForms = clearProtectedFillableFormsForPage(session, pageRef);
+        saveSession(session);
         outputJSON({
             success: true,
-            message: actions.length === 0 ? 'No actions found by Stagehand observe.' : undefined,
-            actions: actions.map((a) => ({
-                description: a.description,
-                selector: a.selector,
-                method: a.method,
-                arguments: a.arguments,
-            })),
+            pageRef,
+            resolvedBy: 'stagehand-observe',
+            ...stagehandRuntimeResolution(stagehandFallbackReason ?? 'deterministic-observe-failed'),
+            deterministicObserveError: domPassError ?? undefined,
+            scopes: compactScopes(selectScopesForOutput(observedScopes, targets)),
+            targets: compactTargets(targets),
+            signals,
+            fillableForms: compactFillableForms(fillableForms),
+            metrics: session.runtime?.metrics,
+            message: targets.length === 0 ? 'No targets found.' : undefined,
             url,
             title,
         });
     }
     catch (err) {
-        await stagehand.close();
-        outputError(`Observe failed: ${err instanceof Error ? err.message : String(err)}`);
+        const stagehandError = err instanceof Error ? err.message : String(err);
+        const details = domPassError
+            ? `${stagehandError} (deterministic observe failed earlier: ${domPassError})`
+            : stagehandError;
+        outputContractFailure({
+            error: 'observe_failed',
+            outcomeType: 'blocked',
+            message: 'Observe failed.',
+            reason: details,
+            pageRef,
+        });
+    }
+    finally {
+        if (browser) {
+            disconnectPlaywright(browser);
+        }
     }
 }

package/dist/commands/observe.test-harness.d.ts

@@ -0,0 +1,67 @@
+import { vi } from 'vitest';
+import type { BrowseSession } from '../session.js';
+type ViMock = ReturnType<typeof vi.fn>;
+export declare const connectOverCDPMock: ViMock;
+export declare const connectStagehandMock: ViMock;
+export declare const outputContractFailureMock: ViMock;
+export declare const outputErrorMock: ViMock;
+export declare const outputFailureMock: ViMock;
+export declare const outputJSONMock: ViMock;
+export declare const rerankDomTargetsForGoalMock: ViMock;
+export declare const saveSessionMock: ViMock;
+export declare const observe: typeof import("./observe.js").observe, __testDomTargetCollection: {
+    collectDomTargetsFromDocument: (context: {
+        evaluate<T>(pageFunction: string): Promise<T>;
+    }, options?: import("./observe-inventory.js").DomTargetCollectionOptions & {
+        framePath?: string[];
+        frameUrl?: string;
+    }) => Promise<import("./observe-inventory.js").DomObservedTarget[]>;
+    collectPageSignalsFromDocument: (context: {
+        evaluate<T>(pageFunction: string): Promise<T>;
+    }, options?: {
+        framePath?: string[];
+        frameUrl?: string;
+    }) => Promise<import("./observe-inventory.js").ObservedPageSignal[]>;
+    locatorDomSignatureScript: string;
+}, __testStagehandDescriptor: {
+    toStagehandDescriptor: typeof import("./observe-stagehand.js").toStagehandDescriptor;
+    normalizeStagehandSelector: typeof import("./observe-inventory.js").normalizeStagehandSelector;
+    readStagehandDomFacts: (locator: import("playwright-core").Locator) => Promise<{
+        kind?: string;
+        role?: string;
+        placeholder?: string;
+        inputName?: string;
+        inputType?: string;
+        autocomplete?: string;
+        value?: string;
+        text?: string;
+        currentValue?: string;
+        states?: Record<string, string | boolean | number>;
+    } | null>;
+    readStagehandDomFactsInBrowser: (element: Element) => {
+        kind?: string;
+        role?: string;
+        placeholder?: string;
+        inputName?: string;
+        inputType?: string;
+        autocomplete?: string;
+        value?: string;
+        text?: string;
+        currentValue?: string;
+        states?: Record<string, string | boolean | number>;
+    } | null;
+    stagehandDomFactsScript: string;
+};
+export declare const __testDescriptorValidation: {
+    readLocatorDomSignatureInBrowser: (element: Element) => string | null;
+    locatorDomSignatureScript: string;
+    locatorBindingSnapshotScript: string;
+    isCompatibleMutableFieldBinding: typeof import("./descriptor-validation.js").isCompatibleMutableFieldBinding;
+};
+export declare function makeSession(): BrowseSession;
+export declare function withStagehandLocator<T extends Record<string, unknown>>(page: T, domSignature?: string): T & {
+    locator: ReturnType<typeof vi.fn>;
+};
+export declare function installObserveTestHooks(): void;
+export {};
+//# sourceMappingURL=observe.test-harness.d.ts.map

package/dist/commands/observe.test-harness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"observe.test-harness.d.ts","sourceRoot":"","sources":["../../src/commands/observe.test-harness.ts"],"names":[],"mappings":"AAAA,OAAO,EAAyB,EAAE,EAAE,MAAM,QAAQ,CAAC;AACnD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAGnD,KAAK,MAAM,GAAG,UAAU,CAAC,OAAO,EAAE,CAAC,EAAE,CAAC,CAAC;AAmBvC,eAAO,MAAM,kBAAkB,EAAE,MAAiC,CAAC;AACnE,eAAO,MAAM,oBAAoB,EAAE,MAAmC,CAAC;AACvE,eAAO,MAAM,yBAAyB,EAAE,MAAwC,CAAC;AACjF,eAAO,MAAM,eAAe,EAAE,MAA8B,CAAC;AAC7D,eAAO,MAAM,iBAAiB,EAAE,MAAgC,CAAC;AACjE,eAAO,MAAM,cAAc,EAAE,MAA6B,CAAC;AAC3D,eAAO,MAAM,2BAA2B,EAAE,MAA0C,CAAC;AACrF,eAAO,MAAM,eAAe,EAAE,MAA8B,CAAC;AA+B7D,eAAO,MAAQ,OAAO,yCAAE,yBAAyB;;;;iBAoEo/R,CAAC;gBAAwB,CAAC;;;;;iBAAq7vE,CAAC;gBAAwB,CAAC;;;GApE39hF,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAE3E,CAAC;AACF,eAAO,MAAQ,0BAA0B;;;;;CAA+C,CAAC;AAMzF,wBAAgB,WAAW,IAAI,aAAa,CAW3C;AAYD,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACpE,IAAI,EAAE,CAAC,EACP,YAAY,SAAkC,GAC7C,CAAC,GAAG;IAAE,OAAO,EAAE,UAAU,CAAC,OAAO,EAAE,CAAC,EAAE,CAAC,CAAA;CAAE,CAM3C;AAED,wBAAgB,uBAAuB,IAAI,IAAI,CAwB9C"}

package/dist/commands/observe.test-harness.js

@@ -0,0 +1,107 @@
+import { afterEach, beforeEach, vi } from 'vitest';
+import { registerPage } from '../runtime-state.js';
+const mocks = vi.hoisted(() => ({
+    connectOverCDPMock: vi.fn(),
+    connectStagehandMock: vi.fn(),
+    outputContractFailureMock: vi.fn((payload) => {
+        throw new Error(`outputContractFailure:${JSON.stringify(payload)}`);
+    }),
+    outputErrorMock: vi.fn((message) => {
+        throw new Error(message);
+    }),
+    outputFailureMock: vi.fn((payload) => {
+        throw new Error(`outputFailure:${JSON.stringify(payload)}`);
+    }),
+    outputJSONMock: vi.fn(),
+    rerankDomTargetsForGoalMock: vi.fn(async (..._args) => []),
+    saveSessionMock: vi.fn(),
+}));
+export const connectOverCDPMock = mocks.connectOverCDPMock;
+export const connectStagehandMock = mocks.connectStagehandMock;
+export const outputContractFailureMock = mocks.outputContractFailureMock;
+export const outputErrorMock = mocks.outputErrorMock;
+export const outputFailureMock = mocks.outputFailureMock;
+export const outputJSONMock = mocks.outputJSONMock;
+export const rerankDomTargetsForGoalMock = mocks.rerankDomTargetsForGoalMock;
+export const saveSessionMock = mocks.saveSessionMock;
+vi.mock('playwright-core', () => ({
+    chromium: {
+        connectOverCDP: connectOverCDPMock,
+    },
+}));
+vi.mock('../stagehand.js', () => ({
+    connectStagehand: connectStagehandMock,
+}));
+vi.mock('../output.js', () => ({
+    outputContractFailure: outputContractFailureMock,
+    outputFailure: outputFailureMock,
+    outputError: outputErrorMock,
+    outputJSON: outputJSONMock,
+}));
+vi.mock('./semantic-observe.js', () => ({
+    rerankDomTargetsForGoal: rerankDomTargetsForGoalMock,
+}));
+vi.mock('../session.js', async () => {
+    const actual = await vi.importActual('../session.js');
+    return {
+        ...actual,
+        saveSession: saveSessionMock,
+    };
+});
+export const { observe, __testDomTargetCollection, __testStagehandDescriptor } = await import('./observe.js');
+export const { __testDescriptorValidation } = await import('./descriptor-validation.js');
+const originalFetch = globalThis.fetch;
+const originalApiKey = process.env.AGENTPAY_API_KEY;
+const originalApiUrl = process.env.AGENTPAY_API_URL;
+export function makeSession() {
+    const session = {
+        cdpUrl: 'ws://localhost:9222/devtools/browser/test',
+        pid: 1,
+        launchedAt: new Date(0).toISOString(),
+    };
+    registerPage(session, {
+        pageRef: 'p0',
+        makeCurrent: true,
+    });
+    return session;
+}
+function makeStagehandLocator(domSignature = 'button|button|Observed target') {
+    const locator = {
+        evaluate: vi.fn(async () => domSignature),
+        first: vi.fn(),
+        waitFor: vi.fn(async () => { }),
+    };
+    locator.first.mockReturnValue(locator);
+    return locator;
+}
+export function withStagehandLocator(page, domSignature = 'button|button|Observed target') {
+    const locator = makeStagehandLocator(domSignature);
+    return {
+        ...page,
+        locator: vi.fn(() => locator),
+    };
+}
+export function installObserveTestHooks() {
+    beforeEach(() => {
+        connectOverCDPMock.mockReset();
+        connectStagehandMock.mockReset();
+        outputContractFailureMock.mockReset();
+        outputContractFailureMock.mockImplementation((payload) => {
+            throw new Error(`outputContractFailure:${JSON.stringify(payload)}`);
+        });
+        outputErrorMock.mockClear();
+        outputFailureMock.mockReset();
+        outputFailureMock.mockImplementation((payload) => {
+            throw new Error(`outputFailure:${JSON.stringify(payload)}`);
+        });
+        outputJSONMock.mockClear();
+        rerankDomTargetsForGoalMock.mockReset();
+        rerankDomTargetsForGoalMock.mockResolvedValue([]);
+        saveSessionMock.mockReset();
+    });
+    afterEach(() => {
+        globalThis.fetch = originalFetch;
+        process.env.AGENTPAY_API_KEY = originalApiKey;
+        process.env.AGENTPAY_API_URL = originalApiUrl;
+    });
+}

package/dist/commands/poll-intent.d.ts

@@ -0,0 +1,6 @@
+/**
+ * browse poll-intent <intentId> — Poll stored-secret intent state and capture one-time delivery.
+ */
+import type { BrowseSession } from '../session.js';
+export declare function pollIntent(session: BrowseSession, intentId: string): Promise<void>;
+//# sourceMappingURL=poll-intent.d.ts.map

package/dist/commands/poll-intent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"poll-intent.d.ts","sourceRoot":"","sources":["../../src/commands/poll-intent.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAKnD,wBAAsB,UAAU,CAAC,OAAO,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAsDxF"}