feat(automation): implement NODE_ENV-based automation mode with fixture server

2025-11-22 16:37:32 +01:00
parent d4fa7afc6f
commit 78fc323e43
8 changed files with 763 additions and 44 deletions
--- a/apps/companion/main/di-container.ts
+++ b/apps/companion/main/di-container.ts
@@ -4,8 +4,9 @@ import { BrowserDevToolsAdapter } from '@/packages/infrastructure/adapters/autom
 import { NutJsAutomationAdapter } from '@/packages/infrastructure/adapters/automation/NutJsAutomationAdapter';
 import { MockAutomationEngineAdapter } from '@/packages/infrastructure/adapters/automation/MockAutomationEngineAdapter';
 import { PermissionService } from '@/packages/infrastructure/adapters/automation/PermissionService';
+import { FixtureServerService } from '@/packages/infrastructure/adapters/automation/FixtureServerService';
 import { StartAutomationSessionUseCase } from '@/packages/application/use-cases/StartAutomationSessionUseCase';
-import { loadAutomationConfig, AutomationMode } from '@/packages/infrastructure/config';
+import { loadAutomationConfig, getAutomationMode, AutomationMode } from '@/packages/infrastructure/config';
 import { PinoLogAdapter } from '@/packages/infrastructure/adapters/logging/PinoLogAdapter';
 import { NoOpLogAdapter } from '@/packages/infrastructure/adapters/logging/NoOpLogAdapter';
 import { loadLoggingConfig } from '@/packages/infrastructure/config/LoggingConfig';
@@ -13,6 +14,7 @@ import type { ISessionRepository } from '@/packages/application/ports/ISessionRe
 import type { IBrowserAutomation } from '@/packages/application/ports/IBrowserAutomation';
 import type { IAutomationEngine } from '@/packages/application/ports/IAutomationEngine';
 import type { ILogger } from '@/packages/application/ports/ILogger';
+import type { IFixtureServerService } from '@/packages/infrastructure/adapters/automation/FixtureServerService';

 export interface BrowserConnectionResult {
  success: boolean;
@@ -36,6 +38,11 @@ function createLogger(): ILogger {
 /**
 * Create browser automation adapter based on configuration mode.
 *
+ * Mode mapping:
+ * - 'development' → BrowserDevToolsAdapter with fixture server URL
+ * - 'production'  → NutJsAutomationAdapter with iRacing window
+ * - 'test'        → MockBrowserAutomationAdapter
+ *
 * @param mode - The automation mode from configuration
 * @param logger - Logger instance for the adapter
 * @returns IBrowserAutomation adapter instance
@@ -44,13 +51,14 @@ function createBrowserAutomationAdapter(mode: AutomationMode, logger: ILogger):
  const config = loadAutomationConfig();
  
  switch (mode) {
-    case 'dev':
+    case 'development':
      return new BrowserDevToolsAdapter({
        debuggingPort: config.devTools?.debuggingPort ?? 9222,
        browserWSEndpoint: config.devTools?.browserWSEndpoint,
        defaultTimeout: config.defaultTimeout,
        launchBrowser: true,
-        startUrl: 'https://members-ng.iracing.com/web/racing/hosted/browse-sessions',
+        headless: false,
+        startUrl: `http://localhost:${config.fixtureServer?.port ?? 3456}/01-hosted-racing.html`,
      }, logger.child({ adapter: 'BrowserDevTools' }));
    
    case 'production':
@@ -60,7 +68,7 @@ function createBrowserAutomationAdapter(mode: AutomationMode, logger: ILogger):
        defaultTimeout: config.defaultTimeout,
      }, logger.child({ adapter: 'NutJs' }));
    
-    case 'mock':
+    case 'test':
    default:
      return new MockBrowserAutomationAdapter();
  }
@@ -76,14 +84,20 @@ export class DIContainer {
  private startAutomationUseCase: StartAutomationSessionUseCase;
  private automationMode: AutomationMode;
  private permissionService: PermissionService;
+  private fixtureServer: IFixtureServerService | null = null;
+  private fixtureServerInitialized: boolean = false;

  private constructor() {
    // Initialize logger first - it's needed by other components
    this.logger = createLogger();
-    this.logger.info('DIContainer initializing', { automationMode: process.env.AUTOMATION_MODE });
+    
+    this.automationMode = getAutomationMode();
+    this.logger.info('DIContainer initializing', {
+      automationMode: this.automationMode,
+      nodeEnv: process.env.NODE_ENV
+    });
    
    const config = loadAutomationConfig();
-    this.automationMode = config.mode;
    
    this.sessionRepository = new InMemorySessionRepository();
    this.browserAutomation = createBrowserAutomationAdapter(config.mode, this.logger);
@@ -109,8 +123,9 @@ export class DIContainer {
  
  private getBrowserAutomationType(mode: AutomationMode): string {
    switch (mode) {
-      case 'dev': return 'BrowserDevToolsAdapter';
+      case 'development': return 'BrowserDevToolsAdapter';
      case 'production': return 'NutJsAutomationAdapter';
+      case 'test':
      default: return 'MockBrowserAutomationAdapter';
    }
  }
@@ -151,22 +166,73 @@ export class DIContainer {
  }

  /**
-   * Initialize browser connection for dev mode.
-   * In dev mode, connects to the browser via Chrome DevTools Protocol.
-   * In mock mode, returns success immediately (no connection needed).
+   * Initialize fixture server for development mode.
+   * Starts an embedded HTTP server serving static HTML fixtures.
+   * This should be called before initializing browser connection.
+   */
+  private async initializeFixtureServer(): Promise<BrowserConnectionResult> {
+    const config = loadAutomationConfig();
+    
+    if (!config.fixtureServer?.autoStart) {
+      this.logger.debug('Fixture server auto-start disabled');
+      return { success: true };
+    }
+
+    if (this.fixtureServerInitialized) {
+      this.logger.debug('Fixture server already initialized');
+      return { success: true };
+    }
+
+    this.fixtureServer = new FixtureServerService();
+    const port = config.fixtureServer.port;
+    const fixturesPath = config.fixtureServer.fixturesPath;
+
+    try {
+      await this.fixtureServer.start(port, fixturesPath);
+      const isReady = await this.fixtureServer.waitForReady(5000);
+      
+      if (!isReady) {
+        throw new Error('Fixture server failed to become ready within timeout');
+      }
+
+      this.fixtureServerInitialized = true;
+      this.logger.info(`Fixture server started on port ${port}`, {
+        port,
+        fixturesPath,
+        baseUrl: this.fixtureServer.getBaseUrl()
+      });
+      
+      return { success: true };
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : 'Failed to start fixture server';
+      this.logger.error('Fixture server initialization failed', error instanceof Error ? error : new Error(errorMsg));
+      return { success: false, error: errorMsg };
+    }
+  }
+
+  /**
+   * Initialize browser connection based on mode.
+   * In development mode, starts fixture server (if configured) then connects to browser via CDP.
+   * In production mode, connects to iRacing window via nut.js.
+   * In test mode, returns success immediately (no connection needed).
   */
  public async initializeBrowserConnection(): Promise<BrowserConnectionResult> {
    this.logger.info('Initializing browser connection', { mode: this.automationMode });
    
-    if (this.automationMode === 'dev') {
+    if (this.automationMode === 'development') {
+      const fixtureResult = await this.initializeFixtureServer();
+      if (!fixtureResult.success) {
+        return fixtureResult;
+      }
+
      try {
        const devToolsAdapter = this.browserAutomation as BrowserDevToolsAdapter;
        await devToolsAdapter.connect();
-        this.logger.info('Browser connection established', { mode: 'dev', adapter: 'BrowserDevTools' });
+        this.logger.info('Browser connection established', { mode: 'development', adapter: 'BrowserDevTools' });
        return { success: true };
      } catch (error) {
        const errorMsg = error instanceof Error ? error.message : 'Failed to connect to browser';
-        this.logger.error('Browser connection failed', error instanceof Error ? error : new Error(errorMsg), { mode: 'dev' });
+        this.logger.error('Browser connection failed', error instanceof Error ? error : new Error(errorMsg), { mode: 'development' });
        return {
          success: false,
          error: errorMsg
@@ -192,8 +258,43 @@ export class DIContainer {
        };
      }
    }
-    this.logger.debug('Mock mode - no browser connection needed');
-    return { success: true }; // Mock mode doesn't need connection
+    this.logger.debug('Test mode - no browser connection needed');
+    return { success: true }; // Test mode doesn't need connection
+  }
+
+  /**
+   * Get the fixture server instance (may be null if not in development mode or not auto-started).
+   */
+  public getFixtureServer(): IFixtureServerService | null {
+    return this.fixtureServer;
+  }
+
+  /**
+   * Shutdown the container and cleanup resources.
+   * Should be called when the application is closing.
+   */
+  public async shutdown(): Promise<void> {
+    this.logger.info('DIContainer shutting down');
+
+    if (this.fixtureServer?.isRunning()) {
+      try {
+        await this.fixtureServer.stop();
+        this.logger.info('Fixture server stopped');
+      } catch (error) {
+        this.logger.error('Error stopping fixture server', error instanceof Error ? error : new Error('Unknown error'));
+      }
+    }
+
+    if (this.browserAutomation && 'disconnect' in this.browserAutomation) {
+      try {
+        await (this.browserAutomation as BrowserDevToolsAdapter).disconnect();
+        this.logger.info('Browser automation disconnected');
+      } catch (error) {
+        this.logger.error('Error disconnecting browser automation', error instanceof Error ? error : new Error('Unknown error'));
+      }
+    }
+
+    this.logger.info('DIContainer shutdown complete');
  }

  /**