rename to core

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

@@ -0,0 +1,119 @@
+import { AuthenticationState } from '../../domain/value-objects/AuthenticationState';
+import type { ILogger } from '../../../shared/src/logging/ILogger';
+import { Result } from '../../../shared/result/Result';
+import type { AuthenticationServicePort } from '../ports/AuthenticationServicePort';
+import { SessionLifetime } from '../../domain/value-objects/SessionLifetime';
+import type { SessionValidatorPort } from '../ports/SessionValidatorPort';
+
+/**
+ * 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 logger: ILogger,
+    private readonly authService: AuthenticationServicePort,
+    private readonly sessionValidator?: SessionValidatorPort
+  ) {}
+
+  /**
+   * 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>> {
+    this.logger.debug('Executing CheckAuthenticationUseCase', { options });
+    try {
+      // Step 1: File-based validation (fast)
+      this.logger.debug('Performing file-based authentication check.');
+      const fileResult = await this.authService.checkSession();
+      if (fileResult.isErr()) {
+        this.logger.error('File-based authentication check failed.', { error: fileResult.unwrapErr() });
+        return fileResult;
+      }
+      this.logger.info('File-based authentication check succeeded.');
+
+      const fileState = fileResult.unwrap();
+      this.logger.debug(`File-based authentication state: ${fileState}`);
+
+      // Step 2: Check session expiry if authenticated
+      if (fileState === AuthenticationState.AUTHENTICATED) {
+        this.logger.debug('Session is authenticated, checking expiry.');
+        const expiryResult = await this.authService.getSessionExpiry();
+        if (expiryResult.isErr()) {
+          this.logger.warn('Could not retrieve session expiry, proceeding with file-based state.', { error: expiryResult.unwrapErr() });
+          // 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()) {
+              this.logger.info('Session has expired based on lifetime.');
+              return Result.ok(AuthenticationState.EXPIRED);
+            }
+            this.logger.debug('Session is not expired.');
+          } catch (error) {
+            this.logger.error('Invalid expiry date encountered, treating session as expired.', { expiry, error });
+            // 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) {
+        this.logger.debug('Performing optional page content verification.');
+        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()) {
+            this.logger.info('Page content verification indicated session expired.');
+            return Result.ok(AuthenticationState.EXPIRED);
+          }
+          this.logger.info('Page content verification succeeded.');
+        } else {
+          this.logger.warn('Page content verification failed, proceeding with file-based state.', { error: pageResult.unwrapErr() });
+        }
+        // Don't block on page verification errors, continue with file-based state
+      }
+
+      // Step 4: Optional server-side validation
+      if (this.sessionValidator && fileState === AuthenticationState.AUTHENTICATED) {
+        this.logger.debug('Performing optional server-side validation.');
+        const serverResult = await this.sessionValidator.validateSession();
+        
+        // Don't block on server validation errors
+        if (serverResult.isOk()) {
+          const isValid = serverResult.unwrap();
+          if (!isValid) {
+            this.logger.info('Server-side validation indicated session expired.');
+            return Result.ok(AuthenticationState.EXPIRED);
+          }
+          this.logger.info('Server-side validation succeeded.');
+        } else {
+          this.logger.warn('Server-side validation failed, proceeding with file-based state.', { error: serverResult.unwrapErr() });
+        }
+      }
+      this.logger.info(`CheckAuthenticationUseCase completed successfully with state: ${fileState}`);
+      return Result.ok(fileState);
+    } catch (error) {
+      this.logger.error('An unexpected error occurred during authentication check.', { error });
+      throw error;
+    }
+  }
+}

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

@@ -0,0 +1,47 @@
+import { Result } from '../../../shared/result/Result';
+import type { AuthenticationServicePort } from '../ports/AuthenticationServicePort';
+import type { ILogger } from '../../../shared/src/logging/ILogger';
+
+/**
+ * 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: AuthenticationServicePort,
+    private readonly logger: ILogger, // Inject ILogger
+  ) {}
+
+  /**
+   * Execute the session clearing.
+   * 
+   * @returns Result indicating success or failure
+   */
+  async execute(): Promise<Result<void>> {
+    this.logger.debug('Attempting to clear user session.', {
+      useCase: 'ClearSessionUseCase'
+    });
+    try {
+      const result = await this.authService.clearSession();
+
+      if (result.isSuccess) {
+        this.logger.info('User session cleared successfully.', {
+          useCase: 'ClearSessionUseCase'
+        });
+      } else {
+        this.logger.warn('Failed to clear user session.', {
+          useCase: 'ClearSessionUseCase',
+          error: result.error,
+        });
+      }
+      return result;
+    } catch (error: any) {
+      this.logger.error('Error clearing user session.', error, {
+        useCase: 'ClearSessionUseCase'
+      });
+      return Result.fail(error.message);
+    }
+  }
+}

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

@@ -0,0 +1,46 @@
+import { Result } from '../../../shared/result/Result';
+import { RaceCreationResult } from '../../domain/value-objects/RaceCreationResult';
+import type { CheckoutServicePort } from '../ports/CheckoutServicePort';
+import type { ILogger } from '../../../shared/src/logging/ILogger';
+
+export class CompleteRaceCreationUseCase {
+  constructor(private readonly checkoutService: CheckoutServicePort, private readonly logger: ILogger) {}
+
+  async execute(sessionId: string): Promise<Result<RaceCreationResult>> {
+    this.logger.debug(`Attempting to complete race creation for session ID: ${sessionId}`);
+    if (!sessionId || sessionId.trim() === '') {
+      this.logger.error('Session ID is required for completing race creation.');
+      return Result.err(new Error('Session ID is required'));
+    }
+
+    const infoResult = await this.checkoutService.extractCheckoutInfo();
+    
+    if (infoResult.isErr()) {
+      this.logger.error(`Failed to extract checkout info: ${infoResult.unwrapErr().message}`);
+      return Result.err(infoResult.unwrapErr());
+    }
+
+    const info = infoResult.unwrap();
+    this.logger.debug(`Extracted checkout information: ${JSON.stringify(info)}`);
+
+    if (!info.price) {
+      this.logger.error('Could not extract price from checkout page.');
+      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(),
+      });
+
+      this.logger.info(`Race creation completed successfully for session ID: ${sessionId}`);
+      return Result.ok(raceCreationResult);
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error('Unknown error');
+      this.logger.error(`Error completing race creation for session ID ${sessionId}: ${err.message}`);
+      return Result.err(err);
+    }
+  }
+}

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

@@ -0,0 +1,88 @@
+import { Result } from '../../../shared/result/Result';
+import type { ILogger } from '../../../shared/src/logging/ILogger';
+import type { CheckoutServicePort } from '../ports/CheckoutServicePort';
+import type { CheckoutConfirmationPort } from '../ports/CheckoutConfirmationPort';
+import { CheckoutStateEnum } from '../../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: CheckoutServicePort,
+    private readonly confirmationPort: CheckoutConfirmationPort,
+    private readonly logger: ILogger,
+  ) {}
+
+  async execute(sessionMetadata?: SessionMetadata): Promise<Result<void>> {
+    this.logger.debug('Executing ConfirmCheckoutUseCase', { sessionMetadata });
+
+    const infoResult = await this.checkoutService.extractCheckoutInfo();
+    
+    if (infoResult.isErr()) {
+      this.logger.error('Failed to extract checkout info', { error: infoResult.unwrapErr() });
+      return Result.err(infoResult.unwrapErr());
+    }
+
+    const info = infoResult.unwrap();
+    this.logger.info('Extracted checkout info', { state: info.state.getValue(), price: info.price });
+
+
+    if (info.state.getValue() === CheckoutStateEnum.INSUFFICIENT_FUNDS) {
+      this.logger.error('Insufficient funds to complete checkout');
+      return Result.err(new Error('Insufficient funds to complete checkout'));
+    }
+
+    if (!info.price) {
+      this.logger.error('Could not extract price from checkout page');
+      return Result.err(new Error('Could not extract price from checkout page'));
+    }
+
+    this.logger.debug('Requesting checkout confirmation', { price: info.price, state: info.state.getValue(), sessionMetadata });
+
+    // 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()) {
+      this.logger.error('Checkout confirmation failed', { error: confirmationResult.unwrapErr() });
+      return Result.err(confirmationResult.unwrapErr());
+    }
+
+    const confirmation = confirmationResult.unwrap();
+    this.logger.info('Checkout confirmation received', { confirmation });
+
+    if (confirmation.isCancelled()) {
+      this.logger.error('Checkout cancelled by user');
+      return Result.err(new Error('Checkout cancelled by user'));
+    }
+
+    if (confirmation.isTimeout()) {
+      this.logger.error('Checkout confirmation timeout');
+      return Result.err(new Error('Checkout confirmation timeout'));
+    }
+
+    this.logger.info('Proceeding with checkout');
+    const checkoutResult = await this.checkoutService.proceedWithCheckout();
+
+    if (checkoutResult.isOk()) {
+      this.logger.info('Checkout process completed successfully.');
+    } else {
+      this.logger.error('Checkout process failed', { error: checkoutResult.unwrapErr() });
+    }
+    return checkoutResult;
+  }
+}

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

@@ -0,0 +1,39 @@
+import { Result } from '../../../shared/result/Result';
+import type { AuthenticationServicePort } from '../ports/AuthenticationServicePort';
+import type { ILogger } from '../../../shared/logger/ILogger';
+
+/**
+ * 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: AuthenticationServicePort,
+    private readonly logger: ILogger,
+  ) {}
+
+  /**
+   * 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>> {
+    this.logger.debug('Initiating login flow...');
+    try {
+      const result = await this.authService.initiateLogin();
+      if (result.isOk()) {
+        this.logger.info('Login flow initiated successfully.');
+      } else {
+        this.logger.warn('Login flow initiation failed.', { error: result.error });
+      }
+      return result;
+    } catch (error: any) {
+      this.logger.error('Error initiating login flow.', error);
+      return Result.fail(error.message || 'Unknown error during login initiation.');
+    }
+  }
+}

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

@@ -0,0 +1,49 @@
+import type { AsyncUseCase } from '@gridpilot/shared/application';
+import type { ILogger } from '../../../shared/src/logging/ILogger';
+import { AutomationSession } from '../../domain/entities/AutomationSession';
+import type { HostedSessionConfig } from '../../domain/types/HostedSessionConfig';
+import { AutomationEnginePort } from '../ports/AutomationEnginePort';
+import type { IBrowserAutomation } from '../ports/ScreenAutomationPort';
+import { SessionRepositoryPort } from '../ports/SessionRepositoryPort';
+import type { SessionDTO } from '../dto/SessionDTO';
+
+export class StartAutomationSessionUseCase
+  implements AsyncUseCase<HostedSessionConfig, SessionDTO> {
+  constructor(
+    private readonly automationEngine: AutomationEnginePort,
+    private readonly browserAutomation: IBrowserAutomation,
+    private readonly sessionRepository: SessionRepositoryPort,
+    private readonly logger: ILogger
+  ) {}
+
+  async execute(config: HostedSessionConfig): Promise<SessionDTO> {
+    this.logger.debug('Starting automation session execution', { config });
+
+    const session = AutomationSession.create(config);
+    this.logger.info(`Automation session created with ID: ${session.id}`);
+
+    const validationResult = await this.automationEngine.validateConfiguration(config);
+    if (!validationResult.isValid) {
+      this.logger.warn('Automation session configuration validation failed', { config, error: validationResult.error });
+      this.logger.error('Automation session configuration validation failed', { config, error: validationResult.error });
+      throw new Error(validationResult.error);
+    }
+    this.logger.debug('Automation session configuration validated successfully.');
+
+    await this.sessionRepository.save(session);
+    this.logger.info(`Automation session with ID: ${session.id} saved to repository.`);
+
+    const dto: SessionDTO = {
+      sessionId: session.id,
+      state: session.state.value,
+      currentStep: session.currentStep.value,
+      config: session.config,
+      ...(session.startedAt ? { startedAt: session.startedAt } : {}),
+      ...(session.completedAt ? { completedAt: session.completedAt } : {}),
+      ...(session.errorMessage ? { errorMessage: session.errorMessage } : {}),
+    };
+
+    this.logger.debug('Automation session executed successfully, returning DTO.', { dto });
+    return dto;
+  }
+}

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

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