wip

packages/automation/application/ports/AutomationResults.ts

@@ -0,0 +1,30 @@
+export interface AutomationResult {
+  success: boolean;
+  error?: string;
+  metadata?: Record<string, unknown>;
+}
+
+export interface NavigationResult extends AutomationResult {
+  url: string;
+  loadTime: number;
+}
+
+export interface FormFillResult extends AutomationResult {
+  fieldName: string;
+  valueSet: string;
+}
+
+export interface ClickResult extends AutomationResult {
+  target: string;
+}
+
+export interface WaitResult extends AutomationResult {
+  target: string;
+  waitedMs: number;
+  found: boolean;
+}
+
+export interface ModalResult extends AutomationResult {
+  stepId: number;
+  action: string;
+}

packages/automation/application/ports/IAuthenticationService.ts

@@ -0,0 +1,76 @@
+import { AuthenticationState } from '@gridpilot/automation/domain/value-objects/AuthenticationState';
+import { BrowserAuthenticationState } from '@gridpilot/automation/domain/value-objects/BrowserAuthenticationState';
+import { Result } from '../../shared/result/Result';
+
+/**
+ * Port for authentication services implementing zero-knowledge login.
+ *
+ * GridPilot never sees, stores, or transmits user credentials.
+ * Authentication is handled by opening a visible browser window where
+ * the user logs in directly with iRacing. GridPilot only observes
+ * URL changes to detect successful authentication.
+ */
+export interface IAuthenticationService {
+  /**
+   * Check if user has a valid session without prompting login.
+   * Navigates to a protected iRacing page and checks for login redirects.
+   *
+   * @returns Result containing the current authentication state
+   */
+  checkSession(): Promise<Result<AuthenticationState>>;
+
+  /**
+   * Open browser for user to login manually.
+   * The browser window is visible so user can verify they're on the real iRacing site.
+   * GridPilot waits for URL change indicating successful login.
+   *
+   * @returns Result indicating success (login complete) or failure (cancelled/timeout)
+   */
+  initiateLogin(): Promise<Result<void>>;
+
+  /**
+   * Clear the persistent session (logout).
+   * Removes stored browser context and cookies.
+   *
+   * @returns Result indicating success or failure
+   */
+  clearSession(): Promise<Result<void>>;
+
+  /**
+   * Get current authentication state.
+   * Returns cached state without making network requests.
+   *
+   * @returns The current AuthenticationState
+   */
+  getState(): AuthenticationState;
+
+  /**
+   * Validate session with server-side check.
+   * Makes a lightweight HTTP request to verify cookies are still valid on the server.
+   *
+   * @returns Result containing true if server confirms validity, false otherwise
+   */
+  validateServerSide(): Promise<Result<boolean>>;
+
+  /**
+   * Refresh session state from cookie store.
+   * Re-reads cookies and updates internal state without server validation.
+   *
+   * @returns Result indicating success or failure
+   */
+  refreshSession(): Promise<Result<void>>;
+
+  /**
+   * Get session expiry date.
+   * Returns the expiry time extracted from session cookies.
+   *
+   * @returns Result containing the expiry Date or null if no expiration
+   */
+  getSessionExpiry(): Promise<Result<Date | null>>;
+
+  /**
+   * Verify browser page shows authenticated state.
+   * Checks page content for authentication indicators.
+   */
+  verifyPageAuthentication(): Promise<Result<BrowserAuthenticationState>>;
+}

packages/automation/application/ports/IAutomationEngine.ts

@@ -0,0 +1,13 @@
+import { HostedSessionConfig } from '@gridpilot/automation/domain/entities/HostedSessionConfig';
+import { StepId } from '@gridpilot/automation/domain/value-objects/StepId';
+
+export interface ValidationResult {
+  isValid: boolean;
+  error?: string;
+}
+
+export interface IAutomationEngine {
+  validateConfiguration(config: HostedSessionConfig): Promise<ValidationResult>;
+  executeStep(stepId: StepId, config: HostedSessionConfig): Promise<void>;
+  stopAutomation(): void;
+}

packages/automation/application/ports/IAutomationEventPublisher.ts

@@ -0,0 +1,10 @@
+export type AutomationEvent = {
+  actionId?: string
+  type: 'panel-attached'|'modal-opened'|'action-started'|'action-complete'|'action-failed'|'panel-missing'
+  timestamp: number
+  payload?: any
+}
+
+export interface IAutomationEventPublisher {
+  publish(event: AutomationEvent): Promise<void>
+}

packages/automation/application/ports/ICheckoutConfirmationPort.ts

@@ -0,0 +1,21 @@
+import { Result } from '../../shared/result/Result';
+import { CheckoutConfirmation } from '@gridpilot/automation/domain/value-objects/CheckoutConfirmation';
+import { CheckoutPrice } from '@gridpilot/automation/domain/value-objects/CheckoutPrice';
+import { CheckoutState } from '@gridpilot/automation/domain/value-objects/CheckoutState';
+
+export interface CheckoutConfirmationRequest {
+  price: CheckoutPrice;
+  state: CheckoutState;
+  sessionMetadata: {
+    sessionName: string;
+    trackId: string;
+    carIds: string[];
+  };
+  timeoutMs: number;
+}
+
+export interface ICheckoutConfirmationPort {
+  requestCheckoutConfirmation(
+    request: CheckoutConfirmationRequest
+  ): Promise<Result<CheckoutConfirmation>>;
+}

packages/automation/application/ports/ICheckoutService.ts

@@ -0,0 +1,14 @@
+import { Result } from '../../shared/result/Result';
+import { CheckoutPrice } from '@gridpilot/automation/domain/value-objects/CheckoutPrice';
+import { CheckoutState } from '@gridpilot/automation/domain/value-objects/CheckoutState';
+
+export interface CheckoutInfo {
+  price: CheckoutPrice | null;
+  state: CheckoutState;
+  buttonHtml: string;
+}
+
+export interface ICheckoutService {
+  extractCheckoutInfo(): Promise<Result<CheckoutInfo>>;
+  proceedWithCheckout(): Promise<Result<void>>;
+}

packages/automation/application/ports/ILogger.ts

@@ -0,0 +1,35 @@
+/**
+ * Log levels in order of severity (lowest to highest)
+ */
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'fatal';
+
+/**
+ * Contextual metadata attached to log entries
+ */
+export interface LogContext {
+  /** Unique session identifier for correlation */
+  sessionId?: string;
+  /** Current automation step (1-18) */
+  stepId?: number;
+  /** Step name for human readability */
+  stepName?: string;
+  /** Adapter or component name */
+  adapter?: string;
+  /** Operation duration in milliseconds */
+  durationMs?: number;
+  /** Additional arbitrary metadata */
+  [key: string]: unknown;
+}
+
+/**
+ * ILogger - Port interface for application-layer logging.
+ */
+export interface ILogger {
+  debug(message: string, context?: LogContext): void;
+  info(message: string, context?: LogContext): void;
+  warn(message: string, context?: LogContext): void;
+  error(message: string, error?: Error, context?: LogContext): void;
+  fatal(message: string, error?: Error, context?: LogContext): void;
+  child(context: LogContext): ILogger;
+  flush(): Promise<void>;
+}

packages/automation/application/ports/IOverlaySyncPort.ts

@@ -0,0 +1,7 @@
+export type OverlayAction = { id: string; label: string; meta?: Record<string, unknown>; timeoutMs?: number }
+export type ActionAck = { id: string; status: 'confirmed' | 'tentative' | 'failed'; reason?: string }
+
+export interface IOverlaySyncPort {
+  startAction(action: OverlayAction): Promise<ActionAck>
+  cancelAction(actionId: string): Promise<void>
+}

packages/automation/application/ports/IScreenAutomation.ts

@@ -0,0 +1,70 @@
+import { StepId } from '@gridpilot/automation/domain/value-objects/StepId';
+import {
+  NavigationResult,
+  FormFillResult,
+  ClickResult,
+  WaitResult,
+  ModalResult,
+  AutomationResult,
+} from './AutomationResults';
+
+/**
+ * Browser automation interface for Playwright-based automation.
+ *
+ * This interface defines the contract for browser automation using
+ * standard DOM manipulation via Playwright. All automation is done
+ * through browser DevTools protocol - no OS-level automation.
+ */
+export interface IBrowserAutomation {
+  /**
+   * Navigate to a URL.
+   */
+  navigateToPage(url: string): Promise<NavigationResult>;
+  
+  /**
+   * Fill a form field by name or selector.
+   */
+  fillFormField(fieldName: string, value: string): Promise<FormFillResult>;
+  
+  /**
+   * Click an element by selector or action name.
+   */
+  clickElement(target: string): Promise<ClickResult>;
+  
+  /**
+   * Wait for an element to appear.
+   */
+  waitForElement(target: string, maxWaitMs?: number): Promise<WaitResult>;
+  
+  /**
+   * Handle modal dialogs.
+   */
+  handleModal(stepId: StepId, action: string): Promise<ModalResult>;
+  
+  /**
+   * Execute a complete workflow step.
+   */
+  executeStep?(stepId: StepId, config: Record<string, unknown>): Promise<AutomationResult>;
+  
+  /**
+   * Initialize the browser connection.
+   * Returns an AutomationResult indicating success or failure.
+   */
+  connect?(): Promise<AutomationResult>;
+  
+  /**
+   * Clean up browser resources.
+   */
+  disconnect?(): Promise<void>;
+  
+  /**
+   * Check if browser is connected and ready.
+   */
+  isConnected?(): boolean;
+}
+
+/**
+ * @deprecated Use IBrowserAutomation directly. IScreenAutomation was for OS-level
+ * automation which has been removed in favor of browser-only automation.
+ */
+export type IScreenAutomation = IBrowserAutomation;

packages/automation/application/ports/ISessionRepository.ts

@@ -0,0 +1,11 @@
+import { AutomationSession } from '@gridpilot/automation/domain/entities/AutomationSession';
+import { SessionStateValue } from '@gridpilot/automation/domain/value-objects/SessionState';
+
+export interface ISessionRepository {
+  save(session: AutomationSession): Promise<void>;
+  findById(id: string): Promise<AutomationSession | null>;
+  update(session: AutomationSession): Promise<void>;
+  delete(id: string): Promise<void>;
+  findAll(): Promise<AutomationSession[]>;
+  findByState(state: SessionStateValue): Promise<AutomationSession[]>;
+}

packages/automation/application/ports/IUserConfirmationPort.ts

@@ -0,0 +1,3 @@
+export interface IUserConfirmationPort {
+  confirm(message: string): Promise<boolean>;
+}

packages/automation/application/services/OverlaySyncService.ts

@@ -0,0 +1,124 @@
+import { IOverlaySyncPort, OverlayAction, ActionAck } from '../ports/IOverlaySyncPort';
+import { IAutomationEventPublisher, AutomationEvent } from '../ports/IAutomationEventPublisher';
+import { IAutomationLifecycleEmitter, LifecycleCallback } from '../../infrastructure/adapters/IAutomationLifecycleEmitter';
+import { ILogger } from '../ports/ILogger';
+
+type ConstructorArgs = {
+  lifecycleEmitter: IAutomationLifecycleEmitter
+  publisher: IAutomationEventPublisher
+  logger: ILogger
+  initialPanelWaitMs?: number
+  maxPanelRetries?: number
+  backoffFactor?: number
+  defaultTimeoutMs?: number
+}
+
+export class OverlaySyncService implements IOverlaySyncPort {
+  private lifecycleEmitter: IAutomationLifecycleEmitter
+  private publisher: IAutomationEventPublisher
+  private logger: ILogger
+  private initialPanelWaitMs: number
+  private maxPanelRetries: number
+  private backoffFactor: number
+  private defaultTimeoutMs: number
+
+  constructor(args: ConstructorArgs) {
+    this.lifecycleEmitter = args.lifecycleEmitter
+    this.publisher = args.publisher
+    this.logger = args.logger
+    this.initialPanelWaitMs = args.initialPanelWaitMs ?? 500
+    this.maxPanelRetries = args.maxPanelRetries ?? 3
+    this.backoffFactor = args.backoffFactor ?? 2
+    this.defaultTimeoutMs = args.defaultTimeoutMs ?? 5000
+  }
+
+  async startAction(action: OverlayAction): Promise<ActionAck> {
+    const timeoutMs = action.timeoutMs ?? this.defaultTimeoutMs
+    const seenEvents: AutomationEvent[] = []
+    let settled = false
+
+    const cb: LifecycleCallback = async (ev) => {
+      seenEvents.push(ev)
+      if (ev.type === 'action-started' && ev.actionId === action.id) {
+        if (!settled) {
+          settled = true
+          cleanup()
+          resolveAck({ id: action.id, status: 'confirmed' })
+        }
+      }
+    }
+
+    const cleanup = () => {
+      try {
+        this.lifecycleEmitter.offLifecycle(cb)
+      } catch {
+        // ignore
+      }
+    }
+
+    let resolveAck: (ack: ActionAck) => void = () => {}
+    const promise = new Promise<ActionAck>((resolve) => {
+      resolveAck = resolve
+      try {
+        this.lifecycleEmitter.onLifecycle(cb)
+      } catch (e) {
+        const error = e instanceof Error ? e : new Error(String(e))
+        this.logger?.error?.('OverlaySyncService: failed to subscribe to lifecycleEmitter', error, {
+          actionId: action.id,
+        })
+      }
+    })
+
+    try {
+      void this.publisher.publish({
+        type: 'modal-opened',
+        timestamp: Date.now(),
+        payload: { actionId: action.id, label: action.label },
+        actionId: action.id,
+      } as AutomationEvent)
+    } catch (e) {
+      const error = e instanceof Error ? e : new Error(String(e))
+      this.logger?.warn?.('OverlaySyncService: publisher.publish failed', {
+        actionId: action.id,
+        error,
+      })
+    }
+
+    const timeoutPromise = new Promise<ActionAck>((res) => {
+      setTimeout(() => {
+        if (!settled) {
+          settled = true
+          cleanup()
+          this.logger?.info?.('OverlaySyncService: timeout waiting for confirmation', {
+            actionId: action.id,
+            timeoutMs,
+          })
+          const lastEvents = seenEvents.slice(-10)
+          this.logger?.debug?.('OverlaySyncService: recent lifecycle events', {
+            actionId: action.id,
+            events: lastEvents,
+          })
+          res({ id: action.id, status: 'tentative', reason: 'timeout' })
+        }
+      }, timeoutMs)
+    })
+
+    return Promise.race([promise, timeoutPromise])
+  }
+
+  async cancelAction(actionId: string): Promise<void> {
+    try {
+      await this.publisher.publish({
+        type: 'panel-missing',
+        timestamp: Date.now(),
+        actionId,
+      } as AutomationEvent)
+    } catch (e) {
+      const error = e instanceof Error ? e : new Error(String(e))
+      this.logger?.warn?.('OverlaySyncService: cancelAction publish failed', {
+        actionId,
+        error,
+      })
+    }
+  }
+}

packages/automation/application/use-cases/CheckAuthenticationUseCase.ts

@@ -0,0 +1,98 @@
+import { AuthenticationState } from '@gridpilot/automation/domain/value-objects/AuthenticationState';
+import { Result } from '../../shared/result/Result';
+import type { IAuthenticationService } from '../ports/IAuthenticationService';
+import { SessionLifetime } from '@gridpilot/automation/domain/value-objects/SessionLifetime';
+
+/**
+ * Port for optional server-side session validation.
+ */
+export interface ISessionValidator {
+  validateSession(): Promise<Result<boolean>>;
+}
+
+/**
+ * Use case for checking if the user has a valid iRacing session.
+ *
+ * This validates the session before automation starts, allowing
+ * the system to prompt for re-authentication if needed.
+ *
+ * Implements hybrid validation strategy:
+ * - File-based validation (fast, always executed)
+ * - Optional server-side validation (slow, requires network)
+ */
+export class CheckAuthenticationUseCase {
+  constructor(
+    private readonly authService: IAuthenticationService,
+    private readonly sessionValidator?: ISessionValidator
+  ) {}
+
+  /**
+   * Execute the authentication check.
+   *
+   * @param options Optional configuration for validation
+   * @returns Result containing the current AuthenticationState
+   */
+  async execute(options?: {
+    requireServerValidation?: boolean;
+    verifyPageContent?: boolean;
+  }): Promise<Result<AuthenticationState>> {
+    // Step 1: File-based validation (fast)
+    const fileResult = await this.authService.checkSession();
+    if (fileResult.isErr()) {
+      return fileResult;
+    }
+
+    const fileState = fileResult.unwrap();
+
+    // Step 2: Check session expiry if authenticated
+    if (fileState === AuthenticationState.AUTHENTICATED) {
+      const expiryResult = await this.authService.getSessionExpiry();
+      if (expiryResult.isErr()) {
+        // Don't fail completely if we can't get expiry, use file-based state
+        return Result.ok(fileState);
+      }
+
+      const expiry = expiryResult.unwrap();
+      if (expiry !== null) {
+        try {
+          const sessionLifetime = new SessionLifetime(expiry);
+          if (sessionLifetime.isExpired()) {
+            return Result.ok(AuthenticationState.EXPIRED);
+          }
+        } catch {
+          // Invalid expiry date, treat as expired for safety
+          return Result.ok(AuthenticationState.EXPIRED);
+        }
+      }
+    }
+
+    // Step 3: Optional page content verification
+    if (options?.verifyPageContent && fileState === AuthenticationState.AUTHENTICATED) {
+      const pageResult = await this.authService.verifyPageAuthentication();
+      
+      if (pageResult.isOk()) {
+        const browserState = pageResult.unwrap();
+        // If cookies valid but page shows login UI, session is expired
+        if (!browserState.isFullyAuthenticated()) {
+          return Result.ok(AuthenticationState.EXPIRED);
+        }
+      }
+      // Don't block on page verification errors, continue with file-based state
+    }
+
+    // Step 4: Optional server-side validation
+    if (this.sessionValidator && fileState === AuthenticationState.AUTHENTICATED) {
+      const serverResult = await this.sessionValidator.validateSession();
+      
+      // Don't block on server validation errors
+      if (serverResult.isOk()) {
+        const isValid = serverResult.unwrap();
+        if (!isValid) {
+          return Result.ok(AuthenticationState.EXPIRED);
+        }
+      }
+    }
+
+    return Result.ok(fileState);
+  }
+}

packages/automation/application/use-cases/ClearSessionUseCase.ts

@@ -0,0 +1,21 @@
+import { Result } from '../../shared/result/Result';
+import type { IAuthenticationService } from '../ports/IAuthenticationService';
+
+/**
+ * Use case for clearing the user's session (logout).
+ * 
+ * Removes stored browser context and cookies, effectively logging
+ * the user out. The next automation attempt will require re-authentication.
+ */
+export class ClearSessionUseCase {
+  constructor(private readonly authService: IAuthenticationService) {}
+
+  /**
+   * Execute the session clearing.
+   * 
+   * @returns Result indicating success or failure
+   */
+  async execute(): Promise<Result<void>> {
+    return this.authService.clearSession();
+  }
+}

packages/automation/application/use-cases/CompleteRaceCreationUseCase.ts

@@ -0,0 +1,38 @@
+import { Result } from '../../shared/result/Result';
+import { RaceCreationResult } from '@gridpilot/automation/domain/value-objects/RaceCreationResult';
+import type { ICheckoutService } from '../ports/ICheckoutService';
+
+export class CompleteRaceCreationUseCase {
+  constructor(private readonly checkoutService: ICheckoutService) {}
+
+  async execute(sessionId: string): Promise<Result<RaceCreationResult>> {
+    if (!sessionId || sessionId.trim() === '') {
+      return Result.err(new Error('Session ID is required'));
+    }
+
+    const infoResult = await this.checkoutService.extractCheckoutInfo();
+    
+    if (infoResult.isErr()) {
+      return Result.err(infoResult.unwrapErr());
+    }
+
+    const info = infoResult.unwrap();
+
+    if (!info.price) {
+      return Result.err(new Error('Could not extract price from checkout page'));
+    }
+
+    try {
+      const raceCreationResult = RaceCreationResult.create({
+        sessionId,
+        price: info.price.toDisplayString(),
+        timestamp: new Date(),
+      });
+
+      return Result.ok(raceCreationResult);
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error('Unknown error');
+      return Result.err(err);
+    }
+  }
+}

packages/automation/application/use-cases/ConfirmCheckoutUseCase.ts

@@ -0,0 +1,65 @@
+import { Result } from '../../shared/result/Result';
+import { ICheckoutService } from '../ports/ICheckoutService';
+import { ICheckoutConfirmationPort } from '../ports/ICheckoutConfirmationPort';
+import { CheckoutStateEnum } from '@gridpilot/automation/domain/value-objects/CheckoutState';
+
+interface SessionMetadata {
+  sessionName: string;
+  trackId: string;
+  carIds: string[];
+}
+
+export class ConfirmCheckoutUseCase {
+  private static readonly DEFAULT_TIMEOUT_MS = 30000;
+
+  constructor(
+    private readonly checkoutService: ICheckoutService,
+    private readonly confirmationPort: ICheckoutConfirmationPort
+  ) {}
+
+  async execute(sessionMetadata?: SessionMetadata): Promise<Result<void>> {
+    const infoResult = await this.checkoutService.extractCheckoutInfo();
+    
+    if (infoResult.isErr()) {
+      return Result.err(infoResult.unwrapErr());
+    }
+
+    const info = infoResult.unwrap();
+
+    if (info.state.getValue() === CheckoutStateEnum.INSUFFICIENT_FUNDS) {
+      return Result.err(new Error('Insufficient funds to complete checkout'));
+    }
+
+    if (!info.price) {
+      return Result.err(new Error('Could not extract price from checkout page'));
+    }
+
+    // Request confirmation via port with full checkout context
+    const confirmationResult = await this.confirmationPort.requestCheckoutConfirmation({
+      price: info.price,
+      state: info.state,
+      sessionMetadata: sessionMetadata || {
+        sessionName: 'Unknown Session',
+        trackId: 'unknown',
+        carIds: [],
+      },
+      timeoutMs: ConfirmCheckoutUseCase.DEFAULT_TIMEOUT_MS,
+    });
+
+    if (confirmationResult.isErr()) {
+      return Result.err(confirmationResult.unwrapErr());
+    }
+
+    const confirmation = confirmationResult.unwrap();
+
+    if (confirmation.isCancelled()) {
+      return Result.err(new Error('Checkout cancelled by user'));
+    }
+
+    if (confirmation.isTimeout()) {
+      return Result.err(new Error('Checkout confirmation timeout'));
+    }
+
+    return await this.checkoutService.proceedWithCheckout();
+  }
+}

packages/automation/application/use-cases/InitiateLoginUseCase.ts

@@ -0,0 +1,23 @@
+import { Result } from '../../shared/result/Result';
+import type { IAuthenticationService } from '../ports/IAuthenticationService';
+
+/**
+ * Use case for initiating the manual login flow.
+ * 
+ * Opens a visible browser window where the user can log into iRacing directly.
+ * GridPilot never sees the credentials - it only waits for the URL to change
+ * indicating successful login.
+ */
+export class InitiateLoginUseCase {
+  constructor(private readonly authService: IAuthenticationService) {}
+
+  /**
+   * Execute the login flow.
+   * Opens browser and waits for user to complete manual login.
+   * 
+   * @returns Result indicating success (login complete) or failure (cancelled/timeout)
+   */
+  async execute(): Promise<Result<void>> {
+    return this.authService.initiateLogin();
+  }
+}

packages/automation/application/use-cases/StartAutomationSessionUseCase.ts

@@ -0,0 +1,44 @@
+import { AutomationSession } from '@gridpilot/automation/domain/entities/AutomationSession';
+import { HostedSessionConfig } from '@gridpilot/automation/domain/entities/HostedSessionConfig';
+import { IAutomationEngine } from '../ports/IAutomationEngine';
+import type { IBrowserAutomation } from '../ports/IScreenAutomation';
+import { ISessionRepository } from '../ports/ISessionRepository';
+
+export interface SessionDTO {
+  sessionId: string;
+  state: string;
+  currentStep: number;
+  config: HostedSessionConfig;
+  startedAt?: Date;
+  completedAt?: Date;
+  errorMessage?: string;
+}
+
+export class StartAutomationSessionUseCase {
+  constructor(
+    private readonly automationEngine: IAutomationEngine,
+    private readonly browserAutomation: IBrowserAutomation,
+    private readonly sessionRepository: ISessionRepository
+  ) {}
+
+  async execute(config: HostedSessionConfig): Promise<SessionDTO> {
+    const session = AutomationSession.create(config);
+
+    const validationResult = await this.automationEngine.validateConfiguration(config);
+    if (!validationResult.isValid) {
+      throw new Error(validationResult.error);
+    }
+
+    await this.sessionRepository.save(session);
+
+    return {
+      sessionId: session.id,
+      state: session.state.value,
+      currentStep: session.currentStep.value,
+      config: session.config,
+      startedAt: session.startedAt,
+      completedAt: session.completedAt,
+      errorMessage: session.errorMessage,
+    };
+  }
+}

packages/automation/application/use-cases/VerifyAuthenticatedPageUseCase.ts

@@ -0,0 +1,30 @@
+import { IAuthenticationService } from '../ports/IAuthenticationService';
+import { Result } from '../../shared/result/Result';
+import { BrowserAuthenticationState } from '@gridpilot/automation/domain/value-objects/BrowserAuthenticationState';
+
+/**
+ * Use case for verifying browser shows authenticated page state.
+ * Combines cookie validation with page content verification.
+ */
+export class VerifyAuthenticatedPageUseCase {
+  constructor(
+    private readonly authService: IAuthenticationService
+  ) {}
+  
+  async execute(): Promise<Result<BrowserAuthenticationState>> {
+    try {
+      const result = await this.authService.verifyPageAuthentication();
+      
+      if (result.isErr()) {
+        const error = result.error ?? new Error('Page verification failed');
+        return Result.err<BrowserAuthenticationState>(error);
+      }
+      
+      const browserState = result.unwrap();
+      return Result.ok<BrowserAuthenticationState>(browserState);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return Result.err<BrowserAuthenticationState>(new Error(`Page verification failed: ${message}`));
+    }
+  }
+}