@mercuryo-ai/magicpay-cli 0.1.0

package/dist/commands/start-session.js

@@ -0,0 +1,298 @@
+import { isSessionAlive, resolveBrowserSessionId } from '@mercuryo-ai/agentbrowse';
+import { buildCreateRemoteSessionInput } from '@mercuryo-ai/magicpay-sdk/core';
+import { exportRunRootToOtlpHttpJsonBestEffort, exportRunStepToOtlpHttpJsonBestEffort } from '../otel-exporter.js';
+import { info } from '../output.js';
+import { getMagicPayClient } from '../session-backend.js';
+import { finishRunRecord, finishRunStep, startCliRun, startRunStep, } from '../run-store.js';
+import { clearWorkflowState, loadMagicPaySession, saveMagicPaySession, } from '../workflow-state.js';
+import { completeWorkflowSessionRemote } from '../workflow-session-completion.js';
+const MAX_START_SESSION_NAME_LENGTH = 256;
+function formatUnknownError(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    if (typeof error === 'string') {
+        return error;
+    }
+    if (error && typeof error === 'object') {
+        try {
+            return JSON.stringify(error);
+        }
+        catch {
+            return Object.prototype.toString.call(error);
+        }
+    }
+    return String(error);
+}
+function buildStartSessionFailure(reason) {
+    return {
+        success: false,
+        error: 'browser_session_unavailable',
+        outcomeType: 'blocked',
+        message: 'Session start failed.',
+        reason,
+    };
+}
+function normalizeStartSessionName(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+        return undefined;
+    }
+    return trimmed.length > MAX_START_SESSION_NAME_LENGTH
+        ? trimmed.slice(0, MAX_START_SESSION_NAME_LENGTH)
+        : trimmed;
+}
+function normalizeMerchantName(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function buildStartSessionDisplayName(options) {
+    return normalizeStartSessionName(options.requestedName) ?? normalizeStartSessionName(options.pageTitle);
+}
+function finalizePreviousRunBestEffort(runId) {
+    if (!runId) {
+        return false;
+    }
+    try {
+        finishRunRecord(runId, {
+            status: 'aborted',
+            finalOutcome: {
+                success: false,
+                outcomeType: 'replaced_by_start_session',
+                message: 'Workflow session was replaced by a new start-session command.',
+                reason: 'A new workflow session was started on the same browser session.',
+            },
+        });
+        return true;
+    }
+    catch (error) {
+        info(`[start-session] failed to finalize previous local run ${runId}: ${formatUnknownError(error)}`);
+        return false;
+    }
+}
+async function finalizeStartSessionStepBestEffort(runId, stepId, options) {
+    if (!stepId) {
+        return;
+    }
+    try {
+        finishRunStep({
+            runId,
+            stepId,
+            ...options,
+        });
+        await exportRunStepToOtlpHttpJsonBestEffort(runId, stepId);
+    }
+    catch (error) {
+        info(`[start-session] failed to finalize local run step ${stepId}: ${formatUnknownError(error)}`);
+    }
+}
+function finalizeRunRecordBestEffort(runId, options) {
+    try {
+        finishRunRecord(runId, {
+            status: options.status,
+            finalOutcome: {
+                success: options.success,
+                ...(options.outcomeType ? { outcomeType: options.outcomeType } : {}),
+                ...(options.message ? { message: options.message } : {}),
+                ...(options.reason ? { reason: options.reason } : {}),
+            },
+        });
+    }
+    catch (error) {
+        info(`[start-session] failed to finalize local run ${runId}: ${formatUnknownError(error)}`);
+    }
+}
+function isStalePreviousWorkflowCompletionFailure(error) {
+    return (error === 'workflow_session_unavailable' ||
+        error === 'workflow_session_already_closed' ||
+        error === 'workflow_run_unavailable' ||
+        error === 'workflow_step_unavailable');
+}
+async function completePreviousWorkflowSessionIfNeeded(session) {
+    if (!session.intentSessionId) {
+        return null;
+    }
+    const remoteCompletion = await completeWorkflowSessionRemote({
+        session,
+        stepId: undefined,
+        command: 'start-session',
+        terminalStatus: 'canceled',
+        runStatus: 'aborted',
+        summary: 'Previous workflow session canceled because a new start-session replaced it.',
+        outcomeType: 'workflow_session_canceled',
+        message: 'Previous workflow session canceled because a new start-session replaced it.',
+        reason: 'A new start-session command replaced the previous workflow session.',
+        allowMissingStep: true,
+    });
+    if (remoteCompletion.success) {
+        return null;
+    }
+    if (isStalePreviousWorkflowCompletionFailure(remoteCompletion.error)) {
+        info(`[start-session] clearing stale previous workflow binding before creating a new session: ${remoteCompletion.reason}`);
+        return null;
+    }
+    return {
+        success: false,
+        error: 'workflow_session_complete_failed',
+        outcomeType: 'failed',
+        message: 'Session start failed.',
+        reason: `Active workflow session cleanup blocked start-session: ${remoteCompletion.reason}`,
+    };
+}
+export async function startSession(requestedName, options = {}) {
+    const session = loadMagicPaySession();
+    if (!session) {
+        return buildStartSessionFailure('Launch or attach a browser first. No persisted browser session was found.');
+    }
+    const previousWorkflowCompletionFailure = await completePreviousWorkflowSessionIfNeeded(session);
+    if (previousWorkflowCompletionFailure) {
+        return previousWorkflowCompletionFailure;
+    }
+    const replacedPreviousRun = finalizePreviousRunBestEffort(session.activeRunId);
+    const nextSession = clearWorkflowState(session);
+    if (replacedPreviousRun ||
+        session.intentSessionId ||
+        session.currentRequestId ||
+        session.lastKnownStatus ||
+        typeof session.lastEventSeq === 'number' ||
+        session.transientSecretCache) {
+        saveMagicPaySession(nextSession);
+    }
+    if (!(await isSessionAlive(session))) {
+        return buildStartSessionFailure('The persisted browser session is no longer running. Launch or attach a fresh browser first.');
+    }
+    const currentPageRef = nextSession.runtime?.currentPageRef;
+    const currentPage = currentPageRef ? nextSession.runtime?.pages[currentPageRef] : undefined;
+    const sessionDisplayName = buildStartSessionDisplayName({
+        requestedName,
+        pageTitle: currentPage?.title,
+    });
+    const sessionDescription = sessionDisplayName ?? normalizeStartSessionName(currentPage?.url);
+    const merchantName = normalizeMerchantName(options.merchantName);
+    const run = startCliRun({
+        sessionId: resolveBrowserSessionId(nextSession),
+        entryCommand: 'start-session',
+        ...(sessionDisplayName ? { displayName: sessionDisplayName } : {}),
+        profile: nextSession.profile,
+        url: currentPage?.url,
+    });
+    await exportRunRootToOtlpHttpJsonBestEffort(run.runId);
+    const step = startRunStep({
+        runId: run.runId,
+        command: 'start-session',
+        input: {
+            hadPreviousRun: replacedPreviousRun,
+            ...(currentPageRef ? { pageRef: currentPageRef } : {}),
+            ...(currentPage?.url ? { url: currentPage.url } : {}),
+            ...(currentPage?.title ? { title: currentPage.title } : {}),
+        },
+    });
+    if (!step?.stepId) {
+        finalizeRunRecordBestEffort(run.runId, {
+            status: 'failed',
+            success: false,
+            outcomeType: 'backend_session_start_failed',
+            message: 'Workflow session start failed.',
+            reason: 'Local step creation failed before backend session start.',
+        });
+        return {
+            success: false,
+            error: 'backend_session_start_failed',
+            outcomeType: 'failed',
+            message: 'Session start failed.',
+            reason: 'Local step creation failed before backend session start.',
+        };
+    }
+    try {
+        const client = getMagicPayClient();
+        const remoteSession = await client.sessions.create(buildCreateRemoteSessionInput({
+            browserSessionId: resolveBrowserSessionId(nextSession),
+            description: sessionDescription,
+            ...(merchantName ? { merchantName } : {}),
+            page: {
+                ...(currentPageRef ? { ref: currentPageRef } : {}),
+                ...(currentPage?.url ? { url: currentPage.url } : {}),
+                ...(currentPage?.title ? { title: currentPage.title } : {}),
+            },
+            run: {
+                id: run.runId,
+                started_at: run.startedAt,
+                source: run.source,
+                status: run.status,
+                ...(run.profile ? { profile: run.profile } : {}),
+                ...(run.hostHints?.[0] ? { site_host: run.hostHints[0] } : {}),
+                protected_run: run.protectedRun,
+            },
+            step: {
+                id: step.stepId,
+                ordinal: step.ordinal,
+                command: step.command,
+                started_at: step.startedAt,
+                ...(currentPageRef ? { page_ref: currentPageRef } : {}),
+            },
+            context: {
+                client: 'magicpay-cli',
+            },
+            metadata: {
+                had_previous_run: replacedPreviousRun,
+            },
+        }));
+        nextSession.activeRunId = run.runId;
+        nextSession.browserSessionId = resolveBrowserSessionId(nextSession);
+        nextSession.intentSessionId = remoteSession.session.id;
+        nextSession.currentRequestId = remoteSession.current_request?.id ?? undefined;
+        nextSession.lastKnownStatus = remoteSession.session.status;
+        nextSession.lastEventSeq = remoteSession.session.last_event_seq;
+        saveMagicPaySession(nextSession);
+        await finalizeStartSessionStepBestEffort(run.runId, step.stepId, {
+            success: true,
+            outcomeType: 'workflow_session_started',
+            message: 'Workflow session started.',
+        });
+        return {
+            success: true,
+            runId: run.runId,
+            startedAt: run.startedAt,
+            browserSessionId: resolveBrowserSessionId(nextSession),
+            intentSessionId: remoteSession.session.id,
+            lastEventSeq: remoteSession.session.last_event_seq,
+            status: remoteSession.session.status,
+            currentRequestId: remoteSession.current_request?.id ?? null,
+            replacedPreviousRun,
+            profile: nextSession.profile,
+            pageRef: currentPageRef,
+            url: currentPage?.url,
+            title: currentPage?.title,
+        };
+    }
+    catch (error) {
+        const reason = formatUnknownError(error);
+        await finalizeStartSessionStepBestEffort(run.runId, step.stepId, {
+            success: false,
+            outcomeType: 'backend_session_start_failed',
+            message: 'Workflow session start failed.',
+            reason,
+        });
+        finalizeRunRecordBestEffort(run.runId, {
+            status: 'failed',
+            success: false,
+            outcomeType: 'backend_session_start_failed',
+            message: 'Workflow session start failed.',
+            reason,
+        });
+        saveMagicPaySession(nextSession);
+        return {
+            success: false,
+            error: 'backend_session_start_failed',
+            outcomeType: 'failed',
+            message: 'Session start failed.',
+            reason,
+        };
+    }
+}

package/dist/commands/status.d.ts

@@ -0,0 +1,27 @@
+import { type AgentBackendProfile } from '../gateway.js';
+import { type CliUpdateNotice } from '../update-check.js';
+export type StatusSuccess = {
+    success: true;
+    healthy: true;
+    message: 'MagicPay gateway setup is healthy.';
+    apiUrl: string;
+    checkedEndpoint: string;
+    agent: AgentBackendProfile;
+    cliUpdate?: CliUpdateNotice;
+};
+export type StatusFailure = {
+    success: false;
+    error: 'agent_status_failed';
+    outcomeType: 'blocked' | 'failed';
+    message: 'MagicPay gateway status check failed.';
+    reason: string;
+    apiUrl: string;
+    checkedEndpoint: string;
+    httpStatus?: number;
+    cliUpdate?: CliUpdateNotice;
+};
+export type StatusResult = StatusSuccess | StatusFailure;
+export declare function status(options?: {
+    fetchImpl?: typeof fetch;
+}): Promise<StatusResult>;
+//# sourceMappingURL=status.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../../src/commands/status.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,mBAAmB,EACzB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAqB,KAAK,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAE7E,MAAM,MAAM,aAAa,GAAG;IAC1B,OAAO,EAAE,IAAI,CAAC;IACd,OAAO,EAAE,IAAI,CAAC;IACd,OAAO,EAAE,oCAAoC,CAAC;IAC9C,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,EAAE,MAAM,CAAC;IACxB,KAAK,EAAE,mBAAmB,CAAC;IAC3B,SAAS,CAAC,EAAE,eAAe,CAAC;CAC7B,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,OAAO,EAAE,KAAK,CAAC;IACf,KAAK,EAAE,qBAAqB,CAAC;IAC7B,WAAW,EAAE,SAAS,GAAG,QAAQ,CAAC;IAClC,OAAO,EAAE,uCAAuC,CAAC;IACjD,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,EAAE,MAAM,CAAC;IACxB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,eAAe,CAAC;CAC7B,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,aAAa,GAAG,aAAa,CAAC;AAyBzD,wBAAsB,MAAM,CAC1B,OAAO,GAAE;IAAE,SAAS,CAAC,EAAE,OAAO,KAAK,CAAA;CAAO,GACzC,OAAO,CAAC,YAAY,CAAC,CAkCvB"}

package/dist/commands/status.js

@@ -0,0 +1,51 @@
+import { buildMagicPayAgentMeUrl, getAuthenticatedAgent, MagicPayRequestError, resolveMagicPayGatewayConfig, } from '../gateway.js';
+import { checkForCliUpdate } from '../update-check.js';
+function buildFailure(params) {
+    return {
+        success: false,
+        error: 'agent_status_failed',
+        outcomeType: params.httpStatus === 401 || params.httpStatus === 403 || params.httpStatus === 404
+            ? 'blocked'
+            : 'failed',
+        message: 'MagicPay gateway status check failed.',
+        reason: params.reason,
+        apiUrl: params.apiUrl,
+        checkedEndpoint: params.checkedEndpoint,
+        ...(params.cliUpdate ? { cliUpdate: params.cliUpdate } : {}),
+        ...(params.httpStatus !== undefined ? { httpStatus: params.httpStatus } : {}),
+    };
+}
+export async function status(options = {}) {
+    const cliUpdate = await checkForCliUpdate({ fetchImpl: options.fetchImpl }).catch(() => null);
+    const gateway = resolveMagicPayGatewayConfig();
+    const checkedEndpoint = buildMagicPayAgentMeUrl(gateway.apiUrl);
+    try {
+        const agent = await getAuthenticatedAgent(options);
+        return {
+            success: true,
+            healthy: true,
+            message: 'MagicPay gateway setup is healthy.',
+            apiUrl: gateway.apiUrl,
+            checkedEndpoint,
+            agent,
+            ...(cliUpdate ? { cliUpdate } : {}),
+        };
+    }
+    catch (error) {
+        if (error instanceof MagicPayRequestError) {
+            return buildFailure({
+                apiUrl: gateway.apiUrl,
+                checkedEndpoint,
+                reason: error.message,
+                httpStatus: error.status,
+                cliUpdate,
+            });
+        }
+        return buildFailure({
+            apiUrl: gateway.apiUrl,
+            checkedEndpoint,
+            reason: error instanceof Error ? error.message : String(error),
+            cliUpdate,
+        });
+    }
+}

package/dist/commands/submit-form.d.ts

@@ -0,0 +1,36 @@
+import type { BrowserSessionState } from '@mercuryo-ai/agentbrowse';
+export type ResolvedSubmitTarget = {
+    targetRef: string;
+    pageRef: string;
+    label?: string;
+    surfaceRef?: string;
+    allowedActions: Array<'click' | 'press'>;
+    resolution: 'unique_form_bound_submit_target';
+};
+export type SubmitFormResult = {
+    success: true;
+    outcomeType: 'submitted';
+    fillRef: string;
+    submitTargetRef: string;
+    pageRef: string;
+    url?: string;
+    title?: string;
+    submissionState: 'progress_observed' | 'same_page_result_observed' | 'navigation_observed';
+    message: string;
+    reason: string;
+} | {
+    success: false;
+    error: 'browser_connection_failed' | 'page_resolution_failed' | 'unknown_fill_ref' | 'fillable_form_absent' | 'submit_target_not_found' | 'submit_binding_stale' | 'validation_blocked' | 'no_observable_progress';
+    outcomeType: 'binding_stale' | 'blocked';
+    fillRef: string;
+    submitTargetRef?: string;
+    pageRef?: string;
+    url?: string;
+    title?: string;
+    message: string;
+    reason: string;
+    nextAction: 'find-form' | 'ask-user';
+};
+export declare function getResolvedSubmitTarget(session: BrowserSessionState, fillRef: string): ResolvedSubmitTarget | null;
+export declare function submitForm(session: BrowserSessionState, fillRef: string): Promise<SubmitFormResult>;
+//# sourceMappingURL=submit-form.d.ts.map

package/dist/commands/submit-form.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"submit-form.d.ts","sourceRoot":"","sources":["../../src/commands/submit-form.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAQpE,MAAM,MAAM,oBAAoB,GAAG;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,KAAK,CAAC,OAAO,GAAG,OAAO,CAAC,CAAC;IACzC,UAAU,EAAE,iCAAiC,CAAC;CAC/C,CAAC;AAEF,MAAM,MAAM,gBAAgB,GACxB;IACE,OAAO,EAAE,IAAI,CAAC;IACd,WAAW,EAAE,WAAW,CAAC;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,eAAe,EAAE,MAAM,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,eAAe,EAAE,mBAAmB,GAAG,2BAA2B,GAAG,qBAAqB,CAAC;IAC3F,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;CAChB,GACD;IACE,OAAO,EAAE,KAAK,CAAC;IACf,KAAK,EACD,2BAA2B,GAC3B,wBAAwB,GACxB,kBAAkB,GAClB,sBAAsB,GACtB,yBAAyB,GACzB,sBAAsB,GACtB,oBAAoB,GACpB,wBAAwB,CAAC;IAC7B,WAAW,EAAE,eAAe,GAAG,SAAS,CAAC;IACzC,OAAO,EAAE,MAAM,CAAC;IAChB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,WAAW,GAAG,UAAU,CAAC;CACtC,CAAC;AAgHN,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,mBAAmB,EAC5B,OAAO,EAAE,MAAM,GACd,oBAAoB,GAAG,IAAI,CAG7B;AAkCD,wBAAsB,UAAU,CAC9B,OAAO,EAAE,mBAAmB,EAC5B,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,gBAAgB,CAAC,CAkK3B"}

package/dist/commands/submit-form.js

@@ -0,0 +1,242 @@
+import { act } from '../browser-bridge/act.js';
+import { getFillableForm } from '../fillable-form-state.js';
+function readString(value) {
+    return typeof value === 'string' ? value : undefined;
+}
+function readStringArray(value) {
+    return Array.isArray(value) ? value.filter((entry) => typeof entry === 'string') : [];
+}
+function submitTargetLabelMatches(label) {
+    return /submit|continue|sign in|log in|pay|buy|book|reserve|checkout|next|done|оплат|войти|далее/i.test(label ?? '');
+}
+function listSubmitCandidates(session, fillRef) {
+    const form = getFillableForm(session, fillRef);
+    if (!form) {
+        return [];
+    }
+    const fieldTargets = form.fields
+        .map((field) => session.runtime?.targets?.[field.targetRef])
+        .filter((target) => Boolean(target));
+    const fieldSurfaceRefs = new Set(fieldTargets
+        .map((target) => target.surfaceRef?.trim())
+        .filter((surfaceRef) => Boolean(surfaceRef)));
+    const fieldTargetRefs = new Set(fieldTargets.map((target) => target.ref));
+    return Object.values(session.runtime?.targets ?? {})
+        .filter((target) => Boolean(target) &&
+        target.pageRef === form.pageRef &&
+        target.lifecycle === 'live' &&
+        target.capability === 'actionable' &&
+        (target.allowedActions.includes('click') || target.allowedActions.includes('press')) &&
+        (target.acceptancePolicy === 'submit' || target.inputType === 'submit'))
+        .map((target) => {
+        let score = 0;
+        if (form.scopeRef && target.surfaceRef === form.scopeRef) {
+            score += 100;
+        }
+        if (target.surfaceRef && fieldSurfaceRefs.has(target.surfaceRef)) {
+            score += 60;
+        }
+        if (target.ownerRef && fieldTargetRefs.has(target.ownerRef)) {
+            score += 30;
+        }
+        if (target.acceptancePolicy === 'submit') {
+            score += 20;
+        }
+        if (target.inputType === 'submit') {
+            score += 10;
+        }
+        if (submitTargetLabelMatches(target.label)) {
+            score += 5;
+        }
+        return { target, score };
+    })
+        .sort((left, right) => right.score - left.score || (left.target.label ?? '').localeCompare(right.target.label ?? ''));
+}
+function resolveSubmitTarget(session, fillRef) {
+    const candidates = listSubmitCandidates(session, fillRef);
+    const best = candidates[0];
+    if (!best || best.score <= 0) {
+        return null;
+    }
+    const tied = candidates.filter((candidate) => candidate.score === best.score);
+    if (tied.length > 1) {
+        return null;
+    }
+    return best.target;
+}
+function toResolvedSubmitTarget(target) {
+    return {
+        targetRef: target.ref,
+        pageRef: target.pageRef,
+        ...(target.label ? { label: target.label } : {}),
+        ...(target.surfaceRef ? { surfaceRef: target.surfaceRef } : {}),
+        allowedActions: target.allowedActions.filter((action) => action === 'click' || action === 'press'),
+        resolution: 'unique_form_bound_submit_target',
+    };
+}
+export function getResolvedSubmitTarget(session, fillRef) {
+    const target = resolveSubmitTarget(session, fillRef);
+    return target ? toResolvedSubmitTarget(target) : null;
+}
+function pageSnapshot(session, pageRef) {
+    if (!pageRef) {
+        return {};
+    }
+    const page = session.runtime?.pages?.[pageRef];
+    return {
+        pageRef,
+        ...(page?.url ? { url: page.url } : {}),
+        ...(page?.title ? { title: page.title } : {}),
+    };
+}
+function submissionStateFor(initialPageRef, result) {
+    const pageRef = readString(result.pageRef);
+    if (pageRef && pageRef !== initialPageRef) {
+        return 'navigation_observed';
+    }
+    if (readStringArray(result.attempts).some((attempt) => attempt.startsWith('submit-resolution:'))) {
+        return 'same_page_result_observed';
+    }
+    return 'progress_observed';
+}
+export async function submitForm(session, fillRef) {
+    const fillableForm = getFillableForm(session, fillRef);
+    if (!fillableForm) {
+        return {
+            success: false,
+            error: 'unknown_fill_ref',
+            outcomeType: 'blocked',
+            fillRef,
+            message: 'Protected form submit was not started because the requested fill reference is unknown.',
+            reason: 'The provided fillRef does not match any currently observed protected form.',
+            nextAction: 'find-form',
+        };
+    }
+    if (fillableForm.presence === 'absent') {
+        return {
+            success: false,
+            error: 'fillable_form_absent',
+            outcomeType: 'blocked',
+            fillRef,
+            ...pageSnapshot(session, fillableForm.pageRef),
+            message: 'Protected form submit was not started because the requested form is no longer present on the page.',
+            reason: 'MagicPay already marked this protected form as absent, so a fresh `find-form` pass is required before submit can continue.',
+            nextAction: 'find-form',
+        };
+    }
+    const submitTarget = resolveSubmitTarget(session, fillRef);
+    if (!submitTarget) {
+        return {
+            success: false,
+            error: 'submit_target_not_found',
+            outcomeType: 'blocked',
+            fillRef,
+            ...pageSnapshot(session, fillableForm.pageRef),
+            message: 'Protected form submit could not find a submit control for the selected form.',
+            reason: 'MagicPay could not resolve one live submit-like target that belongs to the selected protected form.',
+            nextAction: 'find-form',
+        };
+    }
+    const result = await act(session, submitTarget.ref, 'click');
+    const currentPageRef = readString(result.pageRef) ?? fillableForm.pageRef;
+    const currentPage = pageSnapshot(session, currentPageRef);
+    if (result.success) {
+        return {
+            success: true,
+            outcomeType: 'submitted',
+            fillRef,
+            submitTargetRef: submitTarget.ref,
+            pageRef: currentPageRef,
+            ...(currentPage.url ? { url: currentPage.url } : {}),
+            ...(currentPage.title ? { title: currentPage.title } : {}),
+            submissionState: submissionStateFor(fillableForm.pageRef, result),
+            message: 'Protected form submit completed successfully.',
+            reason: 'MagicPay activated the submit control bound to the selected protected form.',
+        };
+    }
+    if (result.error === 'browser_connection_failed') {
+        return {
+            success: false,
+            error: 'browser_connection_failed',
+            outcomeType: 'blocked',
+            fillRef,
+            submitTargetRef: submitTarget.ref,
+            ...currentPage,
+            message: 'Protected form submit could not reconnect to the browser.',
+            reason: readString(result.reason) ?? 'AgentBrowse failed to reconnect to the browser session.',
+            nextAction: 'ask-user',
+        };
+    }
+    if (result.error === 'stale_target' ||
+        result.error === 'stale_target_ref' ||
+        result.error === 'target_surface_not_live' ||
+        result.error === 'target_surface_unavailable' ||
+        result.error === 'target_surface_inactive') {
+        return {
+            success: false,
+            error: 'submit_binding_stale',
+            outcomeType: 'binding_stale',
+            fillRef,
+            submitTargetRef: submitTarget.ref,
+            ...currentPage,
+            message: 'Protected form submit was blocked because the saved submit binding is no longer valid.',
+            reason: readString(result.reason) ?? 'The submit control binding is stale.',
+            nextAction: 'find-form',
+        };
+    }
+    if (result.error === 'unknown_target_ref' ||
+        result.error === 'target_not_actionable' ||
+        result.error === 'target_disabled' ||
+        result.error === 'target_gated' ||
+        result.error === 'action_not_allowed_for_target') {
+        return {
+            success: false,
+            error: 'submit_target_not_found',
+            outcomeType: 'blocked',
+            fillRef,
+            submitTargetRef: submitTarget.ref,
+            ...currentPage,
+            message: 'Protected form submit could not find a usable submit control for the selected form.',
+            reason: readString(result.reason) ?? 'The previously resolved submit control is no longer usable.',
+            nextAction: 'find-form',
+        };
+    }
+    if (result.error === 'validation_blocked') {
+        return {
+            success: false,
+            error: 'validation_blocked',
+            outcomeType: 'blocked',
+            fillRef,
+            submitTargetRef: submitTarget.ref,
+            ...currentPage,
+            message: 'Protected form submit was processed, but the page surfaced validation blockers that require human attention.',
+            reason: readString(result.reason) ??
+                'The page surfaced validation blockers after the submit action was accepted.',
+            nextAction: 'ask-user',
+        };
+    }
+    if (result.error === 'no_observable_progress' || result.error === 'act_failed') {
+        return {
+            success: false,
+            error: 'no_observable_progress',
+            outcomeType: 'blocked',
+            fillRef,
+            submitTargetRef: submitTarget.ref,
+            ...currentPage,
+            message: 'Protected form submit produced no defensible progress signal on the page.',
+            reason: readString(result.reason) ?? 'No observable page progress was detected after submit.',
+            nextAction: 'ask-user',
+        };
+    }
+    return {
+        success: false,
+        error: 'page_resolution_failed',
+        outcomeType: 'blocked',
+        fillRef,
+        submitTargetRef: submitTarget.ref,
+        ...currentPage,
+        message: 'Protected form submit could not resolve the current page state.',
+        reason: readString(result.reason) ?? 'AgentBrowse returned an unsupported submit failure shape.',
+        nextAction: 'ask-user',
+    };
+}

package/dist/config.d.ts

@@ -0,0 +1,2 @@
+export { getMagicPayConfigPath as getConfigPath, getMagicPayHomeDir as getStateDir, readMagicPayConfig as readConfig, writeMagicPayConfig as writeConfig, type MagicPaySharedConfig as MagicPayCliConfig, } from '@mercuryo-ai/magicpay-home';
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,qBAAqB,IAAI,aAAa,EACtC,kBAAkB,IAAI,WAAW,EACjC,kBAAkB,IAAI,UAAU,EAChC,mBAAmB,IAAI,WAAW,EAClC,KAAK,oBAAoB,IAAI,iBAAiB,GAC/C,MAAM,4BAA4B,CAAC"}

package/dist/config.js

@@ -0,0 +1 @@
+export { getMagicPayConfigPath as getConfigPath, getMagicPayHomeDir as getStateDir, readMagicPayConfig as readConfig, writeMagicPayConfig as writeConfig, } from '@mercuryo-ai/magicpay-home';

package/dist/fillable-form-state.d.ts

@@ -0,0 +1,5 @@
+import type { BrowserSessionState } from '@mercuryo-ai/agentbrowse';
+import type { ProtectedFillForm } from '@mercuryo-ai/agentbrowse/protected-fill';
+export declare function getFillableForm(session: BrowserSessionState, fillRef: string): ProtectedFillForm | null;
+export declare function listFillableForms(session: BrowserSessionState): ProtectedFillForm[];
+//# sourceMappingURL=fillable-form-state.d.ts.map