@nuanu-ai/agentbrowse 0.2.47 → 0.2.49

package/dist/commands/start-session.js

@@ -0,0 +1,347 @@
+/**
+ * browse start-session — Start the workflow/run context on top of an existing browser session.
+ */
+import { info } from '../output.js';
+import { buildRunRootOtlpTraceRequest, buildRunStepOtlpTraceRequest, } from '../otel-exporter.js';
+import { appendCommandLifecycleEventBestEffort, captureStepSnapshotBestEffort, } from '../run-observability.js';
+import { finishRunRecord, finishRunStep, startCliRun, startRunStep } from '../run-store.js';
+import { createRemoteSession } from '../sessions-backend.js';
+import { isSessionAlive, loadSession, resolveBrowserSessionId, saveSession, } from '../session.js';
+import { clearWorkflowState, 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) {
+    const requestedName = normalizeStartSessionName(options.requestedName);
+    if (requestedName) {
+        return requestedName;
+    }
+    return 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;
+    }
+}
+function finalizeStartSessionStepBestEffort(runId, stepId, options) {
+    if (!stepId) {
+        return;
+    }
+    try {
+        finishRunStep({
+            runId,
+            stepId,
+            ...options,
+        });
+    }
+    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)}`);
+    }
+}
+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;
+    }
+    return {
+        success: false,
+        error: remoteCompletion.error === 'backend_session_complete_failed'
+            ? 'workflow_session_complete_failed'
+            : remoteCompletion.error,
+        outcomeType: remoteCompletion.error === 'backend_session_complete_failed' ? 'failed' : 'blocked',
+        message: 'Session start failed.',
+        reason: `Active workflow session cleanup blocked start-session: ${remoteCompletion.reason}`,
+    };
+}
+export async function startSession(requestedName, options = {}) {
+    const session = loadSession();
+    if (!session) {
+        return buildStartSessionFailure('Launch 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) {
+        saveSession(nextSession);
+    }
+    if (!(await isSessionAlive(session))) {
+        return buildStartSessionFailure('The persisted browser session is no longer running. Launch 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: nextSession.identity?.browserInstanceRef ?? `pid-${nextSession.pid}`,
+        entryCommand: 'start-session',
+        ...(sessionDisplayName ? { displayName: sessionDisplayName } : {}),
+        profile: nextSession.profile,
+        url: currentPage?.url,
+    });
+    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 } : {}),
+        },
+    });
+    captureStepSnapshotBestEffort({
+        session: nextSession,
+        step,
+        phase: 'before',
+        pageRef: currentPageRef,
+        url: currentPage?.url,
+        title: currentPage?.title,
+    });
+    appendCommandLifecycleEventBestEffort({
+        step,
+        phase: 'started',
+        attributes: {
+            hadPreviousRun: replacedPreviousRun,
+            hasRuntime: Boolean(nextSession.runtime),
+        },
+    });
+    const traceId = run.traceContext.traceId;
+    const spanId = step?.otel.spanId;
+    if (!step || !spanId) {
+        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 remoteSession = await createRemoteSession({
+            browserSessionId: resolveBrowserSessionId(nextSession),
+            description: sessionDescription,
+            ...(merchantName ? { merchantName } : {}),
+            ...(currentPageRef || currentPage?.url || currentPage?.title
+                ? {
+                    page: {
+                        ...(currentPageRef ? { ref: currentPageRef } : {}),
+                        ...(currentPage?.url ? { url: currentPage.url } : {}),
+                        ...(currentPage?.title ? { title: currentPage.title } : {}),
+                    },
+                }
+                : {}),
+            run: {
+                id: run.runId,
+                trace_id: traceId,
+                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,
+                span_id: spanId,
+                ...(currentPageRef ? { page_ref: currentPageRef } : {}),
+            },
+            context: {
+                client: 'browse-cli',
+            },
+            metadata: {
+                had_previous_run: replacedPreviousRun,
+            },
+            telemetry: {
+                root_trace: buildRunRootOtlpTraceRequest(run.runId) ?? undefined,
+                step_trace: buildRunStepOtlpTraceRequest(run.runId, step.stepId) ?? undefined,
+            },
+        });
+        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;
+        saveSession(nextSession);
+        captureStepSnapshotBestEffort({
+            session: nextSession,
+            step,
+            phase: 'after',
+            pageRef: currentPageRef,
+            url: currentPage?.url,
+            title: currentPage?.title,
+        });
+        appendCommandLifecycleEventBestEffort({
+            step,
+            phase: 'completed',
+            attributes: {
+                outcomeType: 'workflow_session_started',
+                intentSessionId: remoteSession.session.id,
+                remoteLastEventSeq: remoteSession.session.last_event_seq,
+                ...(currentPageRef ? { pageRef: currentPageRef } : {}),
+            },
+        });
+        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);
+        appendCommandLifecycleEventBestEffort({
+            step,
+            phase: 'failed',
+            attributes: {
+                outcomeType: 'backend_session_start_failed',
+                reason,
+            },
+        });
+        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,
+        });
+        saveSession(nextSession);
+        return {
+            success: false,
+            error: 'backend_session_start_failed',
+            outcomeType: 'failed',
+            message: 'Session start failed.',
+            reason,
+        };
+    }
+}

package/dist/commands/status.d.ts

@@ -1,5 +1,6 @@
 /**
  * browse status — Check browser state (alive, current URL, title).
  */
-export declare function status(): Promise<void>;
+import type { BrowseResult } from '../output.js';
+export declare function status(): Promise<BrowseResult>;
 //# sourceMappingURL=status.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../../src/commands/status.ts"],"names":[],"mappings":"AAAA;;GAEG;AAmKH,wBAAsB,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CAiG5C"}
+{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../../src/commands/status.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AA+LjD,wBAAsB,MAAM,IAAI,OAAO,CAAC,YAAY,CAAC,CAwFpD"}