@nuanu-ai/agentbrowse 0.2.46 → 0.2.48

package/dist/commands/get-secrets-catalog.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-secrets-catalog.d.ts","sourceRoot":"","sources":["../../src/commands/get-secrets-catalog.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAKnD,wBAAsB,iBAAiB,CAAC,OAAO,EAAE,aAAa,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAkBjG"}
+{"version":3,"file":"get-secrets-catalog.d.ts","sourceRoot":"","sources":["../../src/commands/get-secrets-catalog.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAYnD,wBAAsB,iBAAiB,CAAC,OAAO,EAAE,aAAa,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CA8EjG"}

package/dist/commands/get-secrets-catalog.js

@@ -2,9 +2,39 @@
  * browse get-secrets-catalog [url] — Refresh stored-secret catalog metadata for a host.
  */
 import { saveSession } from '../session.js';
+import { withApiTraceContext } from '../command-api-tracing.js';
 import { outputContractFailure, outputJSON } from '../output.js';
+import { exportRunStepToOtlpHttpJsonBestEffort } from '../otel-exporter.js';
+import { appendCommandLifecycleEventBestEffort, captureStepSnapshotBestEffort, } from '../run-observability.js';
+import { finishRunStep, startRunStep } from '../run-store.js';
 import { getCurrentSessionPageUrl, syncSecretCatalogForUrl } from '../secrets/catalog-sync.js';
 export async function getSecretsCatalog(session, urlOrHost) {
+    const syncStep = session.activeRunId
+        ? startRunStep({
+            runId: session.activeRunId,
+            command: 'get-secrets-catalog',
+            input: {
+                ...(urlOrHost ? { urlOrHost } : {}),
+            },
+            refs: {
+                pageRef: session.runtime?.currentPageRef,
+            },
+        })
+        : null;
+    captureStepSnapshotBestEffort({
+        session,
+        step: syncStep,
+        phase: 'before',
+        pageRef: session.runtime?.currentPageRef,
+    });
+    appendCommandLifecycleEventBestEffort({
+        step: syncStep,
+        phase: 'started',
+        attributes: {
+            pageRef: session.runtime?.currentPageRef,
+            hasExplicitUrlOrHost: Boolean(urlOrHost),
+        },
+    });
     const syncInput = urlOrHost ?? getCurrentSessionPageUrl(session);
     if (!syncInput) {
         return outputContractFailure({
@@ -14,10 +44,41 @@ export async function getSecretsCatalog(session, urlOrHost) {
             reason: 'Provide a URL explicitly or create page context first by navigating or observing.',
         });
     }
-    const snapshot = await syncSecretCatalogForUrl(session, syncInput);
-    saveSession(session);
-    outputJSON({
-        success: true,
-        ...snapshot,
+    return withApiTraceContext({
+        runId: session.activeRunId,
+        stepId: syncStep?.stepId,
+        command: 'get-secrets-catalog',
+    }, async () => {
+        const snapshot = await syncSecretCatalogForUrl(session, syncInput);
+        saveSession(session);
+        captureStepSnapshotBestEffort({
+            session,
+            step: syncStep,
+            phase: 'after',
+            pageRef: session.runtime?.currentPageRef,
+        });
+        appendCommandLifecycleEventBestEffort({
+            step: syncStep,
+            phase: 'completed',
+            attributes: {
+                outcomeType: 'secret_catalog_synced',
+                host: snapshot.host,
+                storedSecretCount: snapshot.storedSecrets.length,
+            },
+        });
+        if (session.activeRunId && syncStep?.stepId) {
+            finishRunStep({
+                runId: session.activeRunId,
+                stepId: syncStep.stepId,
+                success: true,
+                outcomeType: 'secret_catalog_synced',
+                message: 'Stored-secret catalog synced.',
+            });
+            await exportRunStepToOtlpHttpJsonBestEffort(session.activeRunId, syncStep.stepId);
+        }
+        outputJSON({
+            success: true,
+            ...snapshot,
+        });
     });
 }

package/dist/commands/interaction-kernel.d.ts

@@ -0,0 +1,46 @@
+import type { Locator, Page } from 'playwright-core';
+import type { LocatorCandidate, SurfaceDescriptor, TargetDescriptor } from '../runtime-state.js';
+import { type LocatorRoot } from './action-fallbacks.js';
+export type InteractionResolutionAction = 'click' | 'fill' | 'type' | 'select' | 'press';
+export type SharedBindingStaleReason = 'page_signature_mismatch' | 'dom_signature_mismatch' | 'locator_resolution_failed';
+export type PreparedLocatorCandidateResolution = {
+    resolved: boolean;
+    sawDisabledTarget: boolean;
+    sawReadonlyTarget: boolean;
+};
+export declare function targetUsesSurfaceAsPrimaryLocator(target: Pick<TargetDescriptor, 'locatorCandidates'>, surface: Pick<SurfaceDescriptor, 'locatorCandidates'>): boolean;
+export declare function resolveInteractionRoots(page: Page, target: Pick<TargetDescriptor, 'framePath' | 'locatorCandidates'>, surface: SurfaceDescriptor | null, attempts: string[], options?: {
+    recordSelfTargetReuse?: boolean;
+}): Promise<{
+    baseRoot: LocatorRoot;
+    locatorRoot: LocatorRoot;
+    surfaceRoot: Locator | null;
+}>;
+export declare function resolveScopedLocatorRootForCandidate(baseRoot: LocatorRoot, defaultRoot: LocatorRoot, surfaceRoot: Locator | null, scope: LocatorCandidate['scope']): LocatorRoot | null;
+export declare function prepareEditableInteractionLocator(locator: Locator, action: InteractionResolutionAction, strategy: string, attempts: string[], options?: {
+    allowReadonlyFallback?: boolean;
+    allowDescendantPressFallback?: boolean;
+    isUserActionable?: (locator: Locator) => Promise<boolean>;
+}): Promise<{
+    locator: Locator | null;
+    blockedReason?: 'disabled' | 'readonly';
+}>;
+export declare function assertStoredBindingStillValid(page: Page, locator: Locator, target: Pick<TargetDescriptor, 'pageSignature' | 'domSignature'>, stage: string, options?: {
+    onReason?: (reason: SharedBindingStaleReason, stage: string) => Promise<boolean | void> | boolean | void;
+    errorForReason?: (reason: SharedBindingStaleReason, stage: string) => string;
+}): Promise<void>;
+export declare function resolvePreparedLocatorCandidates(params: {
+    target: Pick<TargetDescriptor, 'locatorCandidates' | 'controlFamily'>;
+    action: InteractionResolutionAction;
+    baseRoot: LocatorRoot;
+    locatorRoot: LocatorRoot;
+    surfaceRoot: Locator | null;
+    attempts: string[];
+    prepareOptions?: {
+        allowReadonlyFallback?: boolean;
+        allowDescendantPressFallback?: boolean;
+        isUserActionable?: (locator: Locator) => Promise<boolean>;
+    };
+    onPreparedLocator: (locator: Locator, strategy: LocatorCandidate['strategy']) => Promise<boolean>;
+}): Promise<PreparedLocatorCandidateResolution>;
+//# sourceMappingURL=interaction-kernel.d.ts.map

package/dist/commands/interaction-kernel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interaction-kernel.d.ts","sourceRoot":"","sources":["../../src/commands/interaction-kernel.ts"],"names":[],"mappings":"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"}

package/dist/commands/interaction-kernel.js

@@ -0,0 +1,215 @@
+import { locatorCandidateKey } from '../runtime-state.js';
+import { rankLocatorCandidates } from './action-acceptance.js';
+import { buildLocator, resolveLocatorRoot } from './action-fallbacks.js';
+import { normalizePageSignature, readLocatorDomSignature } from './descriptor-validation.js';
+import { resolveSurfaceScopeRoot } from './target-resolution.js';
+function defaultLocatorVisibility(locator) {
+    return locator.isVisible().catch(() => false);
+}
+export function targetUsesSurfaceAsPrimaryLocator(target, surface) {
+    const surfaceCandidates = new Set(surface.locatorCandidates.map(locatorCandidateKey));
+    return target.locatorCandidates.some((candidate) => surfaceCandidates.has(locatorCandidateKey(candidate)));
+}
+export async function resolveInteractionRoots(page, target, surface, attempts, options) {
+    const baseRoot = resolveLocatorRoot(page, target.framePath ?? surface?.framePath);
+    if (!surface) {
+        return {
+            baseRoot,
+            locatorRoot: baseRoot,
+            surfaceRoot: null,
+        };
+    }
+    const surfaceRoot = await resolveSurfaceScopeRoot(page, surface, attempts);
+    if (surfaceRoot) {
+        if (targetUsesSurfaceAsPrimaryLocator(target, surface)) {
+            if (options?.recordSelfTargetReuse) {
+                attempts.push('surface.resolve.self-target');
+            }
+            return {
+                baseRoot,
+                locatorRoot: baseRoot,
+                surfaceRoot,
+            };
+        }
+        return {
+            baseRoot,
+            locatorRoot: surfaceRoot,
+            surfaceRoot,
+        };
+    }
+    attempts.push('surface.resolve.fallback:page');
+    return {
+        baseRoot,
+        locatorRoot: baseRoot,
+        surfaceRoot: null,
+    };
+}
+export function resolveScopedLocatorRootForCandidate(baseRoot, defaultRoot, surfaceRoot, scope) {
+    if (scope === 'root') {
+        return baseRoot;
+    }
+    if (scope === 'surface') {
+        return surfaceRoot;
+    }
+    return defaultRoot;
+}
+export async function prepareEditableInteractionLocator(locator, action, strategy, attempts, options) {
+    const isUserActionable = options?.isUserActionable ?? defaultLocatorVisibility;
+    const count = await locator.count().catch(() => 0);
+    if (count === 0) {
+        attempts.push(`resolve.skip:${strategy}:empty`);
+        return { locator: null };
+    }
+    if (action !== 'click' && count > 1) {
+        attempts.push(`resolve.skip:${strategy}:ambiguous:${count}`);
+        return { locator: null };
+    }
+    let resolvedLocator = locator.first();
+    if (action === 'click' && count > 1) {
+        const visibleCandidates = [];
+        for (let index = 0; index < count; index += 1) {
+            const candidate = locator.nth(index);
+            const visible = await isUserActionable(candidate).catch(() => false);
+            if (!visible) {
+                continue;
+            }
+            visibleCandidates.push(candidate);
+        }
+        if (visibleCandidates.length === 1) {
+            attempts.push(`resolve.visible-unique:${strategy}`);
+            resolvedLocator = visibleCandidates[0] ?? locator.first();
+        }
+        else if (visibleCandidates.length > 1) {
+            attempts.push(`resolve.skip:${strategy}:ambiguous-visible:${visibleCandidates.length}`);
+            return { locator: null };
+        }
+        else {
+            attempts.push(`resolve.skip:${strategy}:hidden`);
+            return { locator: null };
+        }
+    }
+    const visible = await isUserActionable(resolvedLocator).catch(() => false);
+    if (!visible) {
+        attempts.push(`resolve.skip:${strategy}:hidden`);
+        return { locator: null };
+    }
+    const disabled = await resolvedLocator.isDisabled?.().catch(() => false);
+    if (disabled) {
+        attempts.push(`resolve.skip:${strategy}:disabled`);
+        return { locator: null, blockedReason: 'disabled' };
+    }
+    const shouldRecoverDescendantEditable = action === 'fill' ||
+        action === 'type' ||
+        (action === 'press' && options?.allowDescendantPressFallback);
+    if (!shouldRecoverDescendantEditable) {
+        return { locator: resolvedLocator };
+    }
+    const editable = await resolvedLocator.isEditable().catch(() => false);
+    if (editable) {
+        return { locator: resolvedLocator };
+    }
+    const descendantSelector = action === 'press' && options?.allowDescendantPressFallback
+        ? 'input:not([type="hidden"]), textarea, select, [contenteditable="true"], [role="textbox"], [role="combobox"]'
+        : 'input:not([type="hidden"]), textarea, select, [contenteditable="true"]';
+    const descendantCandidates = resolvedLocator.locator(descendantSelector);
+    const descendantCount = await descendantCandidates.count().catch(() => 0);
+    const candidateDescendants = [];
+    for (let index = 0; index < descendantCount; index += 1) {
+        const descendant = descendantCandidates.nth(index);
+        const descendantVisible = await isUserActionable(descendant).catch(() => false);
+        if (!descendantVisible) {
+            continue;
+        }
+        if (action !== 'press' || !options?.allowDescendantPressFallback) {
+            const descendantEditable = await descendant.isEditable().catch(() => false);
+            if (!descendantEditable) {
+                continue;
+            }
+        }
+        candidateDescendants.push(descendant);
+    }
+    if (candidateDescendants.length === 1) {
+        attempts.push(action === 'press' && options?.allowDescendantPressFallback
+            ? `resolve.descendant-press:${strategy}`
+            : `resolve.descendant-editable:${strategy}`);
+        return { locator: candidateDescendants[0] ?? null };
+    }
+    if (candidateDescendants.length > 1) {
+        attempts.push(`resolve.skip:${strategy}:descendant-ambiguous:${candidateDescendants.length}`);
+        return { locator: null };
+    }
+    if (options?.allowReadonlyFallback) {
+        attempts.push(`resolve.readonly-fallback:${strategy}`);
+        return { locator: resolvedLocator };
+    }
+    attempts.push(`resolve.skip:${strategy}:readonly`);
+    return { locator: null, blockedReason: 'readonly' };
+}
+export async function assertStoredBindingStillValid(page, locator, target, stage, options) {
+    const errorForReason = options?.errorForReason ??
+        ((reason, errorStage) => `binding_stale:${reason}:${errorStage}`);
+    if (target.pageSignature && normalizePageSignature(page.url()) !== target.pageSignature) {
+        const handled = await options?.onReason?.('page_signature_mismatch', stage);
+        if (handled === true) {
+            return;
+        }
+        throw new Error(errorForReason('page_signature_mismatch', stage));
+    }
+    const liveCount = await locator.count().catch(() => 0);
+    if (liveCount === 0) {
+        const handled = await options?.onReason?.('locator_resolution_failed', stage);
+        if (handled === true) {
+            return;
+        }
+        throw new Error(errorForReason('locator_resolution_failed', stage));
+    }
+    if (!target.domSignature) {
+        return;
+    }
+    const liveSignature = await readLocatorDomSignature(locator).catch(() => null);
+    if (liveSignature && liveSignature !== target.domSignature) {
+        const handled = await options?.onReason?.('dom_signature_mismatch', stage);
+        if (handled === true) {
+            return;
+        }
+        throw new Error(errorForReason('dom_signature_mismatch', stage));
+    }
+}
+export async function resolvePreparedLocatorCandidates(params) {
+    let sawDisabledTarget = false;
+    let sawReadonlyTarget = false;
+    for (const candidate of rankLocatorCandidates(params.target.locatorCandidates, params.action)) {
+        const candidateRoot = resolveScopedLocatorRootForCandidate(params.baseRoot, params.locatorRoot, params.surfaceRoot, candidate.scope);
+        if (!candidateRoot) {
+            params.attempts.push(`resolve.skip:${candidate.strategy}:surface-unavailable`);
+            continue;
+        }
+        const locator = buildLocator(candidateRoot, candidate);
+        if (!locator) {
+            continue;
+        }
+        const preparedLocator = await prepareEditableInteractionLocator(locator, params.action, candidate.strategy, params.attempts, params.prepareOptions);
+        if (preparedLocator.blockedReason === 'disabled') {
+            sawDisabledTarget = true;
+        }
+        if (preparedLocator.blockedReason === 'readonly') {
+            sawReadonlyTarget = true;
+        }
+        if (!preparedLocator.locator) {
+            continue;
+        }
+        const resolved = await params.onPreparedLocator(preparedLocator.locator, candidate.strategy);
+        if (resolved) {
+            return {
+                resolved: true,
+                sawDisabledTarget,
+                sawReadonlyTarget,
+            };
+        }
+    }
+    return {
+        resolved: false,
+        sawDisabledTarget,
+        sawReadonlyTarget,
+    };
+}

package/dist/commands/launch.d.ts

@@ -1,7 +1,6 @@
 /**
  * browse launch [url] — Start browser session, optionally navigate.
  */
-import type { SecretCatalogSummary } from '../secrets/catalog-sync.js';
 export type LaunchCliOptions = {
     compact?: boolean;
     profile?: string;
@@ -17,7 +16,6 @@ export type LaunchSuccessResult = {
     cdpUrl: string;
     url: string;
     title: string;
-    secretCatalog?: SecretCatalogSummary;
 };
 export type LaunchFailureResult = {
     success: false;

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

@@ -1 +1 @@
-{"version":3,"file":"launch.d.ts","sourceRoot":"","sources":["../../src/commands/launch.ts"],"names":[],"mappings":"AAAA;;GAEG;AAUH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAYvE,MAAM,MAAM,gBAAgB,GAAG;IAC7B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,OAAO,EAAE,IAAI,CAAC;IACd,OAAO,EAAE,SAAS,CAAC;IACnB,mBAAmB,EAAE,IAAI,CAAC;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,aAAa,CAAC,EAAE,oBAAoB,CAAC;CACtC,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,OAAO,EAAE,KAAK,CAAC;IACf,KAAK,EAAE,uBAAuB,CAAC;IAC/B,WAAW,EAAE,SAAS,CAAC;IACvB,OAAO,EAAE,wBAAwB,CAAC;IAClC,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,mBAAmB,GAAG,mBAAmB,CAAC;AAErE,wBAAsB,MAAM,CAAC,GAAG,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,YAAY,CAAC,CAazF"}
+{"version":3,"file":"launch.d.ts","sourceRoot":"","sources":["../../src/commands/launch.ts"],"names":[],"mappings":"AAAA;;GAEG;AAgCH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,OAAO,EAAE,IAAI,CAAC;IACd,OAAO,EAAE,SAAS,CAAC;IACnB,mBAAmB,EAAE,IAAI,CAAC;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,OAAO,EAAE,KAAK,CAAC;IACf,KAAK,EAAE,uBAAuB,CAAC;IAC/B,WAAW,EAAE,SAAS,CAAC;IACvB,OAAO,EAAE,wBAAwB,CAAC;IAClC,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,mBAAmB,GAAG,mBAAmB,CAAC;AAErE,wBAAsB,MAAM,CAAC,GAAG,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,YAAY,CAAC,CAgBzF"}

package/dist/commands/launch.js

@@ -4,20 +4,23 @@
 import { readConfig } from '../solver/config.js';
 import { ensureProfile } from '../solver/profile-manager.js';
 import { launchSolver } from '../solver/browser-launcher.js';
-import { buildOwnedSession, isOwnedSession, loadSession, saveSession } from '../session.js';
+import { buildOwnedSession, isOwnedSession, isSessionAlive, loadSession, saveSession, } from '../session.js';
 import { applyAgentpayGatewayEnv, tryResolveAgentpayGatewayConfig } from '../agentpay-gateway.js';
 import { connectPlaywright, disconnectPlaywright, syncLaunchPage } from '../playwright-runtime.js';
-import { summarizeSecretCatalog, syncSecretCatalogForUrl } from '../secrets/catalog-sync.js';
 import { closeOwnedBrowser } from '../owned-browser.js';
 import { cleanupManagedBrowserPids } from '../owned-process.js';
+import { deleteLocalRun, finishRunRecord, pruneLocalRuns } from '../run-store.js';
 import { info } from '../output.js';
+import { clearWorkflowState, completeWorkflowSessionRemote, } from '../workflow-session-completion.js';
 const DEFAULT_PROFILE = 'default';
 const COMPACT_WINDOW = {
     width: 1280,
     height: 900,
 };
 export async function launch(url, opts) {
-    const cleanupFailure = await cleanupOwnedSession();
+    const existingSession = loadSession();
+    pruneLocalRunsBestEffort('launch', existingSession?.activeRunId);
+    const cleanupFailure = await cleanupOwnedSession(existingSession);
     if (cleanupFailure) {
         return cleanupFailure;
     }
@@ -28,14 +31,22 @@ export async function launch(url, opts) {
     const noProxy = opts?.noProxy ?? false;
     return launchManaged(url, profileName, headless, compact, proxyOverride, noProxy);
 }
-async function cleanupOwnedSession() {
-    const existingSession = loadSession();
+async function cleanupOwnedSession(existingSession) {
     const excludePids = new Set();
+    const workflowCleanupFailure = await cleanupPreviousWorkflowState(existingSession);
+    if (workflowCleanupFailure) {
+        return workflowCleanupFailure;
+    }
     if (isOwnedSession(existingSession)) {
         excludePids.add(existingSession.pid);
-        const closeResult = await closeOwnedBrowser(existingSession);
-        if (!closeResult.success) {
-            return buildLaunchFailure(new Error(closeResult.reason));
+        if (await isSessionAlive(existingSession)) {
+            const closeResult = await closeOwnedBrowser(existingSession);
+            if (!closeResult.success) {
+                return buildLaunchFailure(new Error(closeResult.reason));
+            }
+        }
+        else {
+            info(`[launch] previous managed browser pid ${existingSession.pid} was already gone; closing active workflow context before relaunch`);
         }
     }
     // Phase-1 ownership removed port-global prekill, so launch needs a second guardrail
@@ -49,6 +60,95 @@ async function cleanupOwnedSession() {
     }
     return null;
 }
+async function cleanupPreviousWorkflowState(existingSession) {
+    if (!existingSession) {
+        return null;
+    }
+    if (existingSession.intentSessionId) {
+        const remoteCompletion = await completeWorkflowSessionRemote({
+            session: existingSession,
+            stepId: undefined,
+            command: 'launch',
+            terminalStatus: 'canceled',
+            runStatus: 'aborted',
+            summary: 'Workflow session canceled because a new launch replaced the current browser session.',
+            outcomeType: 'workflow_session_canceled',
+            message: 'Workflow session canceled because a new launch replaced the current browser session.',
+            reason: 'A new launch command replaced the previous browser session.',
+            allowMissingStep: true,
+        });
+        if (!remoteCompletion.success) {
+            if (isStaleWorkflowBindingFailure(remoteCompletion.error)) {
+                info(`[launch] clearing stale workflow binding before relaunch: ${remoteCompletion.reason}`);
+                deleteStaleRunBestEffort('launch', existingSession.activeRunId);
+            }
+            else {
+                return buildLaunchFailure(new Error(`Active workflow session cleanup blocked relaunch: ${remoteCompletion.reason}`));
+            }
+        }
+    }
+    await finalizeRunBestEffort('launch', existingSession.activeRunId, {
+        status: 'aborted',
+        finalOutcome: {
+            success: false,
+            outcomeType: 'replaced_by_launch',
+            message: 'Previous run was replaced by a new launch.',
+            reason: 'A new launch started while the previous browser session was still active.',
+        },
+    });
+    persistClearedWorkflowStateBestEffort('launch', existingSession);
+    return null;
+}
+function isStaleWorkflowBindingFailure(error) {
+    return error === 'workflow_run_unavailable' || error === 'workflow_step_unavailable';
+}
+function pruneLocalRunsBestEffort(command, activeRunId) {
+    try {
+        const result = pruneLocalRuns({ activeRunId });
+        if (result.deletedRunIds.length > 0) {
+            info(`[${command}] pruned stale local run${result.deletedRunIds.length === 1 ? '' : 's'} ${result.deletedRunIds.join(', ')}`);
+        }
+        if (result.failedRunIds.length > 0) {
+            info(`[${command}] failed to prune local run${result.failedRunIds.length === 1 ? '' : 's'} ${result.failedRunIds.map((entry) => `${entry.runId}: ${entry.reason}`).join('; ')}`);
+        }
+    }
+    catch (error) {
+        info(`[${command}] local run prune failed: ${formatUnknownError(error)}`);
+    }
+}
+async function finalizeRunBestEffort(command, runId, options) {
+    if (!runId) {
+        return;
+    }
+    try {
+        finishRunRecord(runId, options);
+    }
+    catch (error) {
+        info(`[${command}] failed to finalize local run ${runId}: ${formatUnknownError(error)}`);
+    }
+}
+function deleteStaleRunBestEffort(command, runId) {
+    if (!runId) {
+        return;
+    }
+    try {
+        const deleted = deleteLocalRun(runId);
+        if (deleted) {
+            info(`[${command}] deleted stale local run ${runId}`);
+        }
+    }
+    catch (error) {
+        info(`[${command}] failed to delete stale local run ${runId}: ${formatUnknownError(error)}`);
+    }
+}
+function persistClearedWorkflowStateBestEffort(command, session) {
+    try {
+        saveSession(clearWorkflowState(session));
+    }
+    catch (error) {
+        info(`[${command}] failed to persist cleared workflow state: ${formatUnknownError(error)}`);
+    }
+}
 function buildLaunchFailure(err) {
     return {
         success: false,
@@ -62,7 +162,6 @@ async function launchManaged(url, profileName, headless, compact, proxyOverride,
     let session;
     let browser = null;
     let runtimeProxy;
-    let secretCatalogSummary;
     try {
         const baseProfile = ensureProfile(profileName);
         const config = readConfig();
@@ -125,16 +224,10 @@ async function launchManaged(url, profileName, headless, compact, proxyOverride,
     }
     finally {
         if (browser) {
-            disconnectPlaywright(browser);
+            await disconnectPlaywright(browser);
         }
         await session.disconnect();
     }
-    if (url) {
-        const snapshot = await syncSecretCatalogForUrl(persistedSession, currentUrl || url);
-        if (snapshot) {
-            secretCatalogSummary = summarizeSecretCatalog(snapshot);
-        }
-    }
     saveSession(persistedSession);
     return {
         success: true,
@@ -144,7 +237,6 @@ async function launchManaged(url, profileName, headless, compact, proxyOverride,
         cdpUrl: session.cdpUrl,
         url: currentUrl,
         title,
-        secretCatalog: secretCatalogSummary,
     };
 }
 function formatUnknownError(err) {

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

@@ -1 +1 @@
-{"version":3,"file":"navigate.d.ts","sourceRoot":"","sources":["../../src/commands/navigate.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAgBnD,wBAAsB,QAAQ,CAAC,OAAO,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAwDvF"}
+{"version":3,"file":"navigate.d.ts","sourceRoot":"","sources":["../../src/commands/navigate.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAwFnD,wBAAsB,QAAQ,CAAC,OAAO,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CA8JvF"}