mmintel/gridpilot.gg
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

wip

Browse Source
This commit is contained in:
Marc Mintel
2025-12-01 17:27:56 +01:00
parent e7ada8aa23
commit 98a09a3f2b
41 changed files with 2341 additions and 1525 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
packages/domain/services/PageStateValidator.ts
View File

@@ -167,11 +167,17 @@ export class PageStateValidator {
// Check required selectors are present (with fallbacks for real mode)
const missingSelectors = requiredSelectors.filter(selector => {
if (realMode) {
// In real mode, check if ANY of the enhanced selectors match
const relatedSelectors = selectorsToCheck.filter(s =>
s.includes(expectedStep) ||
s.includes(selector.replace(/[\[\]"']/g, '').replace('data-indicator=', ''))
s.includes(
selector
.replace(/[\[\]"']/g, '')
.replace('data-indicator=', ''),
),
);
if (relatedSelectors.length === 0) {
return !actualState(selector);
}
return !relatedSelectors.some(s => actualState(s));
}
return !actualState(selector);

98
packages/domain/value-objects/ImageTemplate.ts
View File

@@ -1,98 +0,0 @@
import type { ScreenRegion } from './ScreenRegion';
/**
* Represents an image template used for visual element detection.
* Templates are reference images that are matched against screen captures
* to locate UI elements without relying on CSS selectors or DOM access.
*/
export interface ImageTemplate {
/** Unique identifier for the template */
id: string;
/** Path to the template image file (relative to resources directory) */
imagePath: string;
/** Confidence threshold for matching (0.0-1.0, higher = more strict) */
confidence: number;
/** Optional region to limit search area for better performance */
searchRegion?: ScreenRegion;
/** Human-readable description of what this template represents */
description: string;
}
/**
* Template categories for organization and filtering.
*/
export type TemplateCategory =
| 'login'
| 'navigation'
| 'wizard'
| 'button'
| 'field'
| 'modal'
| 'indicator';
/**
* Extended template with category metadata.
*/
export interface CategorizedTemplate extends ImageTemplate {
category: TemplateCategory;
stepId?: number;
}
/**
* Create an ImageTemplate with default confidence.
*/
export function createImageTemplate(
id: string,
imagePath: string,
description: string,
options?: {
confidence?: number;
searchRegion?: ScreenRegion;
}
): ImageTemplate {
return {
id,
imagePath,
description,
confidence: options?.confidence ?? 0.9,
searchRegion: options?.searchRegion,
};
}
/**
* Validate that an ImageTemplate has all required fields.
*/
export function isValidTemplate(template: unknown): template is ImageTemplate {
if (typeof template !== 'object' || template === null) {
return false;
}
const t = template as Record<string, unknown>;
return (
typeof t.id === 'string' &&
t.id.length > 0 &&
typeof t.imagePath === 'string' &&
t.imagePath.length > 0 &&
typeof t.confidence === 'number' &&
t.confidence >= 0 &&
t.confidence <= 1 &&
typeof t.description === 'string'
);
}
/**
* Default confidence thresholds for different template types.
*/
export const DEFAULT_CONFIDENCE = {
/** High confidence for exact matches (buttons, icons) */
HIGH: 0.95,
/** Standard confidence for most UI elements */
STANDARD: 0.9,
/** Lower confidence for variable elements (text fields with content) */
LOW: 0.8,
/** Minimum acceptable confidence */
MINIMUM: 0.7,
/** Very low confidence for testing/debugging template matching issues */
DEBUG: 0.5,
} as const;

188
packages/infrastructure/adapters/automation/core/PlaywrightAutomationAdapter.ts
View File

@@ -565,56 +565,40 @@ export class PlaywrightAutomationAdapter implements IBrowserAutomation, IAuthent
}
try {
// Create a function that checks if selectors exist on the page
const checkSelector = (selector: string): boolean => {
// Synchronously check if selector exists (count > 0)
// We'll need to make this sync-compatible, so we check in the validator call
return false; // Placeholder - will be resolved in evaluate
};
const selectorChecks: Record<string, boolean> = {};
// Use page.evaluate to check all selectors at once in the browser context
const selectorChecks = await this.page.evaluate(
({ requiredSelectors, forbiddenSelectors }) => {
const results: Record<string, boolean> = {};
// Check required selectors
for (const selector of requiredSelectors) {
try {
results[selector] = document.querySelectorAll(selector).length > 0;
} catch {
results[selector] = false;
}
}
// Check forbidden selectors
for (const selector of forbiddenSelectors || []) {
try {
results[selector] = document.querySelectorAll(selector).length > 0;
} catch {
results[selector] = false;
}
}
return results;
},
{
requiredSelectors: validation.requiredSelectors,
forbiddenSelectors: validation.forbiddenSelectors || []
for (const selector of validation.requiredSelectors) {
try {
const count = await this.page.locator(selector).count();
selectorChecks[selector] = count > 0;
} catch {
selectorChecks[selector] = false;
}
);
}
for (const selector of validation.forbiddenSelectors || []) {
try {
const count = await this.page.locator(selector).count();
selectorChecks[selector] = count > 0;
} catch {
selectorChecks[selector] = false;
}
}
// Create actualState function that uses the captured results
const actualState = (selector: string): boolean => {
return selectorChecks[selector] === true;
};
// Validate using domain service
return this.pageStateValidator.validateStateEnhanced(actualState, validation, this.isRealMode());
return this.pageStateValidator.validateStateEnhanced(
actualState,
validation,
this.isRealMode(),
);
} catch (error) {
return Result.err(
error instanceof Error
? error
: new Error(`Page state validation failed: ${String(error)}`)
: new Error(`Page state validation failed: ${String(error)}`),
);
}
}
@@ -775,29 +759,53 @@ export class PlaywrightAutomationAdapter implements IBrowserAutomation, IAuthent
async executeStep(stepId: StepId, config: Record<string, unknown>): Promise<AutomationResult> {
const stepNumber = stepId.value;
if (!this.isRealMode() && this.config.baseUrl) {
if (stepNumber >= 2 && stepNumber <= this.totalSteps) {
try {
const fixture = getFixtureForStep(stepNumber);
if (fixture) {
const base = this.config.baseUrl.replace(/\/$/, '');
const url = `${base}/${fixture}`;
this.log('debug', 'Mock mode: navigating to fixture for step', {
const skipFixtureNavigation =
(config as any).__skipFixtureNavigation === true;
if (!skipFixtureNavigation) {
if (!this.isRealMode() && this.config.baseUrl) {
if (stepNumber >= 2 && stepNumber <= this.totalSteps) {
try {
const fixture = getFixtureForStep(stepNumber);
if (fixture) {
const base = this.config.baseUrl.replace(/\/$/, '');
const url = `${base}/${fixture}`;
this.log('debug', 'Mock mode: navigating to fixture for step', {
step: stepNumber,
url,
});
await this.navigator.navigateToPage(url);
}
} catch (error) {
this.log('debug', 'Mock mode fixture navigation failed (non-fatal)', {
step: stepNumber,
url,
error: String(error),
});
}
}
} else if (this.isRealMode() && this.config.baseUrl && !this.config.baseUrl.includes('members.iracing.com')) {
if (stepNumber >= 2 && stepNumber <= this.totalSteps) {
try {
const fixture = getFixtureForStep(stepNumber);
if (fixture) {
const base = this.config.baseUrl.replace(/\/$/, '');
const url = `${base}/${fixture}`;
this.log('info', 'Fixture host (real mode): navigating to fixture for step', {
step: stepNumber,
url,
});
await this.navigator.navigateToPage(url);
}
} catch (error) {
this.log('warn', 'Real-mode fixture navigation failed (non-fatal)', {
step: stepNumber,
error: String(error),
});
await this.navigator.navigateToPage(url);
}
} catch (error) {
this.log('debug', 'Mock mode fixture navigation failed (non-fatal)', {
step: stepNumber,
error: String(error),
});
}
}
}
return this.stepOrchestrator.executeStep(stepId, config);
}
@@ -1852,8 +1860,10 @@ export class PlaywrightAutomationAdapter implements IBrowserAutomation, IAuthent
}
/**
* Click the "New Race" button in the modal that appears after clicking "Create a Race".
* This modal asks whether to use "Last Settings" or "New Race".
* Click the "New Race" option in the modal that appears after clicking "Create a Race".
* Supports both:
* - Direct "New Race" button
* - Dropdown menu with "Last Settings" / "New Race" items (fixture HTML)
*/
private async clickNewRaceInModal(): Promise<void> {
if (!this.page) {
@@ -1863,26 +1873,58 @@ export class PlaywrightAutomationAdapter implements IBrowserAutomation, IAuthent
try {
this.log('info', 'Waiting for Create Race modal to appear');
// Wait for the modal - use 'attached' because iRacing elements may have class="hidden"
const modalSelector = IRACING_SELECTORS.hostedRacing.createRaceModal;
await this.page.waitForSelector(modalSelector, {
state: 'attached',
timeout: IRACING_TIMEOUTS.elementWait,
});
this.log('info', 'Create Race modal attached, clicking New Race button');
this.log('info', 'Create Race modal attached, resolving New Race control');
// Click the "New Race" button - use 'attached' for consistency
const newRaceSelector = IRACING_SELECTORS.hostedRacing.newRaceButton;
await this.page.waitForSelector(newRaceSelector, {
state: 'attached',
timeout: IRACING_TIMEOUTS.elementWait,
});
await this.safeClick(newRaceSelector, { timeout: IRACING_TIMEOUTS.elementWait });
const directSelector = IRACING_SELECTORS.hostedRacing.newRaceButton;
const direct = this.page.locator(directSelector).first();
const hasDirect =
(await direct.count().catch(() => 0)) > 0 &&
(await direct.isVisible().catch(() => false));
this.log('info', 'Clicked New Race button, waiting for form to load');
if (hasDirect) {
this.log('info', 'Clicking direct New Race button', { selector: directSelector });
await this.safeClick(directSelector, { timeout: IRACING_TIMEOUTS.elementWait });
} else {
const dropdownToggleSelector =
'.btn-toolbar .btn-group.dropup > a.dropdown-toggle, .btn-group.dropup > a.dropdown-toggle';
const dropdownToggle = this.page.locator(dropdownToggleSelector).first();
const hasDropdown =
(await dropdownToggle.count().catch(() => 0)) > 0 &&
(await dropdownToggle.isVisible().catch(() => false));
// Wait a moment for the form to load
if (!hasDropdown) {
throw new Error(
`Create Race modal present but no direct New Race button or dropdown toggle found (selectors: ${directSelector}, ${dropdownToggleSelector})`,
);
}
this.log('info', 'Clicking dropdown toggle to open New Race menu', {
selector: dropdownToggleSelector,
});
await this.safeClick(dropdownToggleSelector, {
timeout: IRACING_TIMEOUTS.elementWait,
});
const menuSelector =
'.dropdown-menu a.dropdown-item.text-danger:has-text("New Race"), .dropdown-menu a.dropdown-item:has-text("New Race")';
this.log('debug', 'Waiting for New Race entry in dropdown menu', {
selector: menuSelector,
});
await this.page.waitForSelector(menuSelector, {
state: 'attached',
timeout: IRACING_TIMEOUTS.elementWait,
});
await this.safeClick(menuSelector, { timeout: IRACING_TIMEOUTS.elementWait });
this.log('info', 'Clicked New Race dropdown item');
}
this.log('info', 'Waiting for Race Information form to load after New Race selection');
await this.page.waitForTimeout(500);
} catch (error) {
const message = error instanceof Error ? error.message : String(error);
@@ -1949,7 +1991,13 @@ export class PlaywrightAutomationAdapter implements IBrowserAutomation, IAuthent
*/
private async handleLogin(): Promise<AutomationResult> {
try {
// Check session cookies FIRST before launching browser
if (this.config.baseUrl && !this.config.baseUrl.includes('members.iracing.com')) {
this.log('info', 'Fixture baseUrl detected, treating session as authenticated for Step 1', {
baseUrl: this.config.baseUrl,
});
return { success: true };
}
const sessionResult = await this.checkSession();
if (

80
packages/infrastructure/adapters/automation/core/WizardStepOrchestrator.ts
View File

@@ -486,6 +486,11 @@ export class WizardStepOrchestrator {
const skipOffset = this.synchronizeStepCounter(step, actualPage);
if (skipOffset > 0) {
if (this.config.baseUrl) {
const errorMsg = `Step 8 FAILED validation: Wizard auto-skip detected (expected "cars" but on "${actualPage}")`;
this.log('error', errorMsg, { actualPage, skipOffset });
throw new Error(errorMsg);
}
this.log('info', `Step ${step} was auto-skipped by wizard`, {
actualPage,
skipOffset,
@@ -557,9 +562,11 @@ export class WizardStepOrchestrator {
const step8Validation = await this.validatePageState({
expectedStep: 'cars',
requiredSelectors: this.isRealMode()
? [IRACING_SELECTORS.steps.addCarButton]
? [IRACING_SELECTORS.wizard.stepContainers.cars]
: ['#set-cars, .wizard-step[id*="cars"], .cars-panel'],
forbiddenSelectors: ['#set-track'],
forbiddenSelectors: [
IRACING_SELECTORS.wizard.stepContainers.track,
],
});
if (step8Validation.isErr()) {
@@ -592,19 +599,24 @@ export class WizardStepOrchestrator {
case 9:
this.log('info', 'Step 9: Validating we are still on Cars page');
if (this.isRealMode()) {
const actualPage = await this.detectCurrentWizardPage();
const skipOffset = this.synchronizeStepCounter(step, actualPage);
if (skipOffset > 0) {
if (this.config.baseUrl) {
const errorMsg = `Step 9 FAILED validation: Wizard auto-skip detected (expected "cars" but on "${actualPage}")`;
this.log('error', errorMsg, { actualPage, skipOffset });
throw new Error(errorMsg);
}
this.log('info', `Step ${step} was auto-skipped by wizard`, {
actualPage,
skipOffset,
});
return { success: true };
}
const wizardFooter = await this.page!
.locator('.wizard-footer')
.innerText()
@@ -612,37 +624,42 @@ export class WizardStepOrchestrator {
this.log('info', 'Step 9: Current wizard footer', {
footer: wizardFooter,
});
const onTrackPage =
wizardFooter.includes('Track Options') ||
(await this.page!
.locator(IRACING_SELECTORS.wizard.stepContainers.track)
.isVisible()
.catch(() => false));
if (onTrackPage) {
const errorMsg = `FATAL: Step 9 attempted on Track page (Step 11) - navigation bug detected. Wizard footer: "${wizardFooter}"`;
const errorMsg = `Step 9 FAILED validation: Wizard footer indicates Track page while executing Cars-add-car step. Wizard footer: "${wizardFooter}"`;
this.log('error', errorMsg);
throw new Error(errorMsg);
}
}
const validation = await this.validatePageState({
expectedStep: 'cars',
requiredSelectors: this.isRealMode()
? [IRACING_SELECTORS.steps.addCarButton]
? [
IRACING_SELECTORS.wizard.stepContainers.cars,
IRACING_SELECTORS.steps.addCarButton,
]
: ['#set-cars, .wizard-step[id*="cars"], .cars-panel'],
forbiddenSelectors: ['#set-track'],
forbiddenSelectors: [
IRACING_SELECTORS.wizard.stepContainers.track,
],
});
if (validation.isErr()) {
const errorMsg = `Step 9 validation error: ${
const errorMsg = `Step 9 FAILED validation: ${
validation.error?.message ?? 'unknown error'
}`;
this.log('error', errorMsg);
throw new Error(errorMsg);
}
const validationResult = validation.unwrap();
this.log('info', 'Step 9 validation result', {
isValid: validationResult.isValid,
@@ -650,12 +667,14 @@ export class WizardStepOrchestrator {
missingSelectors: validationResult.missingSelectors,
unexpectedSelectors: validationResult.unexpectedSelectors,
});
if (!validationResult.isValid) {
const errorMsg = `Step 9 FAILED validation: ${
validationResult.message
}. Browser is ${
validationResult.unexpectedSelectors?.includes('#set-track')
validationResult.unexpectedSelectors?.includes(
IRACING_SELECTORS.wizard.stepContainers.track,
)
? '3 steps ahead on Track page'
: 'on wrong page'
}`;
@@ -665,7 +684,7 @@ export class WizardStepOrchestrator {
});
throw new Error(errorMsg);
}
this.log('info', 'Step 9 validation passed - confirmed on Cars page');
const carIds = config.carIds as string[] | undefined;
@@ -675,6 +694,18 @@ export class WizardStepOrchestrator {
carIds?.[0];
if (this.isRealMode()) {
const isFixtureHost =
this.config.baseUrl &&
!this.config.baseUrl.includes('members.iracing.com');
if (isFixtureHost) {
this.log('info', 'Step 9: fixture host detected, skipping Add Car interactions (DOM already has cars table)', {
baseUrl: this.config.baseUrl,
carSearchTerm,
});
return { success: true };
}
if (carSearchTerm) {
await this.clickAddCarButton();
await this.waitForAddCarModal();
@@ -685,7 +716,7 @@ export class WizardStepOrchestrator {
car: carSearchTerm,
});
}
await this.clickNextButton('Car Classes');
} else {
if (carSearchTerm) {
@@ -804,9 +835,20 @@ export class WizardStepOrchestrator {
await this.waitForWizardStep('trackOptions');
await this.checkWizardDismissed(step);
const isFixtureHost =
this.config.baseUrl &&
!this.config.baseUrl.includes('members.iracing.com');
const trackSearchTerm =
config.trackSearch || config.track || config.trackId;
if (trackSearchTerm) {
if (isFixtureHost) {
this.log(
'info',
'Step 13: fixture host detected, skipping Add Track interactions (track already present in fixture)',
{ baseUrl: this.config.baseUrl, trackSearchTerm },
);
} else if (trackSearchTerm) {
await this.clickAddTrackButton();
await this.waitForAddTrackModal();
await this.fillField('trackSearch', String(trackSearchTerm));

79
packages/infrastructure/adapters/automation/dom/IRacingDomInteractor.ts
View File

@@ -10,6 +10,7 @@ import type { PlaywrightConfig } from '../core/PlaywrightAutomationAdapter';
import { PlaywrightBrowserSession } from '../core/PlaywrightBrowserSession';
import { IRACING_SELECTORS, IRACING_TIMEOUTS } from './IRacingSelectors';
import { SafeClickService } from './SafeClickService';
import { getFixtureForStep } from '../engine/FixtureServer';
export class IRacingDomInteractor {
constructor(
@@ -953,28 +954,84 @@ export class IRacingDomInteractor {
async clickNewRaceInModal(): Promise<void> {
const page = this.getPage();
const modalSelector = IRACING_SELECTORS.hostedRacing.createRaceModal;
const newRaceSelector = IRACING_SELECTORS.hostedRacing.newRaceButton;
try {
this.log('info', 'Waiting for Create Race modal to appear');
const modalSelector = IRACING_SELECTORS.hostedRacing.createRaceModal;
const isFixtureHost =
this.isRealMode() &&
this.config.baseUrl &&
!this.config.baseUrl.includes('members.iracing.com');
if (isFixtureHost) {
try {
await page.waitForSelector(modalSelector, {
state: 'attached',
timeout: 3000,
});
} catch {
const fixture = getFixtureForStep(2);
if (fixture) {
const base = this.config.baseUrl.replace(/\/$/, '');
const url = `${base}/${fixture}`;
this.log('info', 'Fixture host detected, navigating directly to Step 2 fixture before New Race click', {
url,
});
await page.goto(url, {
waitUntil: 'domcontentloaded',
timeout: IRACING_TIMEOUTS.navigation,
});
}
}
}
await page.waitForSelector(modalSelector, {
state: 'attached',
timeout: IRACING_TIMEOUTS.elementWait,
});
this.log('info', 'Create Race modal attached, clicking New Race button');
const newRaceSelector = IRACING_SELECTORS.hostedRacing.newRaceButton;
this.log('info', 'Create Race modal attached, resolving New Race control', {
modalSelector,
newRaceSelector,
});
await page.waitForSelector(newRaceSelector, {
state: 'attached',
timeout: IRACING_TIMEOUTS.elementWait,
});
await this.safeClickService.safeClick(newRaceSelector, { timeout: IRACING_TIMEOUTS.elementWait });
this.log('info', 'Clicked New Race button, waiting for form to load');
await this.safeClickService.safeClick(newRaceSelector, {
timeout: IRACING_TIMEOUTS.elementWait,
});
this.log('info', 'Clicked New Race button, waiting for Race Information form to load');
await page.waitForTimeout(500);
if (isFixtureHost) {
const raceInfoFixture = getFixtureForStep(3);
if (raceInfoFixture) {
const base = this.config.baseUrl.replace(/\/$/, '');
const url = `${base}/${raceInfoFixture}`;
this.log(
'info',
'Fixture host detected, navigating directly to Step 3 Race Information fixture after New Race click',
{ url },
);
await page.goto(url, {
waitUntil: 'domcontentloaded',
timeout: IRACING_TIMEOUTS.navigation,
});
const raceInfoSelector =
IRACING_SELECTORS.wizard.stepContainers.raceInformation;
await page.waitForSelector(raceInfoSelector, {
state: 'attached',
timeout: IRACING_TIMEOUTS.elementWait,
});
}
}
} catch (error) {
const message = error instanceof Error ? error.message : String(error);
this.log('error', 'Failed to click New Race in modal', { error: message });

93
packages/infrastructure/adapters/automation/dom/IRacingSelectors.ts
View File

@@ -13,16 +13,31 @@ export const IRACING_SELECTORS = {
submitButton: 'button[type="submit"], button:has-text("Sign In")',
},
// Hosted Racing page (Step 2)
// Hosted Racing page (Step 1/2)
hostedRacing: {
// Main "Create a Race" button on the hosted sessions page
createRaceButton: 'button:has-text("Create a Race"), button[aria-label="Create a Race"]',
createRaceButton:
'button:has-text("Create a Race"), button[aria-label="Create a Race"], button.chakra-button:has-text("Create a Race")',
hostedTab: 'a:has-text("Hosted")',
// Modal that appears after clicking "Create a Race"
createRaceModal: '#modal-children-container, .modal-content',
// "New Race" button in the modal body (not footer) - two side-by-side buttons in a row
newRaceButton: 'a.btn:has-text("New Race")',
lastSettingsButton: 'a.btn:has-text("Last Settings")',
createRaceModal:
'#confirm-create-race-modal-modal-content, ' +
'#create-race-modal-modal-content, ' +
'#confirm-create-race-modal, ' +
'#create-race-modal, ' +
'#modal-children-container, ' +
'.modal-content',
newRaceButton:
'#confirm-create-race-modal-modal-content a.btn.btn-lg:has-text("New Race"), ' +
'#create-race-modal-modal-content a.btn.btn-lg:has-text("New Race"), ' +
'a.btn.btn-lg:has-text("New Race"), ' +
'a.btn.btn-info:has-text("New Race"), ' +
'.dropdown-menu a.dropdown-item.text-danger:has-text("New Race"), ' +
'.dropdown-menu a.dropdown-item:has-text("New Race"), ' +
'button.chakra-button:has-text("New Race")',
lastSettingsButton:
'#confirm-create-race-modal-modal-content a.btn.btn-lg:has-text("Last Settings"), ' +
'#create-race-modal-modal-content a.btn.btn-lg:has-text("Last Settings"), ' +
'a.btn.btn-lg:has-text("Last Settings"), ' +
'a.btn.btn-info:has-text("Last Settings")',
},
// Common modal/wizard selectors - VERIFIED from real HTML
@@ -31,28 +46,34 @@ export const IRACING_SELECTORS = {
modalDialog: '#create-race-modal-modal-dialog, .modal-dialog',
modalContent: '#create-race-modal-modal-content, .modal-content',
modalTitle: '[data-testid="modal-title"]',
// Wizard footer buttons - CORRECTED: The footer contains navigation buttons and dropup menus
// The main navigation is via the sidebar links, footer has Back/Next style buttons
// Based on dumps, footer has .btn-group with buttons for navigation
nextButton: '.modal-footer .btn-toolbar a.btn:not(.dropdown-toggle), .modal-footer .btn-group a.btn:last-child',
backButton: '.modal-footer .btn-group a.btn:first-child',
// Wizard footer buttons (fixture + live)
// Primary navigation uses sidebar; footer has Back/Next-style step links.
nextButton:
'.wizard-footer .btn-group.pull-xs-left a.btn.btn-sm:last-child, ' +
'.wizard-footer .btn-group a.btn.btn-sm:last-child, ' +
'.modal-footer .btn-toolbar a.btn:not(.dropdown-toggle), ' +
'.modal-footer .btn-group a.btn:last-child',
backButton:
'.wizard-footer .btn-group.pull-xs-left a.btn.btn-sm:first-child, ' +
'.wizard-footer .btn-group a.btn.btn-sm:first-child, ' +
'.modal-footer .btn-group a.btn:first-child',
// Modal footer actions
confirmButton: '.modal-footer a.btn-success, .modal-footer button:has-text("Confirm"), button:has-text("OK")',
cancelButton: '.modal-footer a.btn-secondary, button:has-text("Cancel")',
closeButton: '[data-testid="button-close-modal"]',
// Wizard sidebar navigation links - VERIFIED from dumps
// Wizard sidebar navigation links (use real sidebar IDs so text is present)
sidebarLinks: {
raceInformation: '[data-testid="wizard-nav-set-session-information"]',
serverDetails: '[data-testid="wizard-nav-set-server-details"]',
admins: '[data-testid="wizard-nav-set-admins"]',
timeLimit: '[data-testid="wizard-nav-set-time-limit"]',
cars: '[data-testid="wizard-nav-set-cars"]',
track: '[data-testid="wizard-nav-set-track"]',
trackOptions: '[data-testid="wizard-nav-set-track-options"]',
timeOfDay: '[data-testid="wizard-nav-set-time-of-day"]',
weather: '[data-testid="wizard-nav-set-weather"]',
raceOptions: '[data-testid="wizard-nav-set-race-options"]',
trackConditions: '[data-testid="wizard-nav-set-track-conditions"]',
raceInformation: '#wizard-sidebar-link-set-session-information',
serverDetails: '#wizard-sidebar-link-set-server-details',
admins: '#wizard-sidebar-link-set-admins',
timeLimit: '#wizard-sidebar-link-set-time-limit',
cars: '#wizard-sidebar-link-set-cars',
track: '#wizard-sidebar-link-set-track',
trackOptions: '#wizard-sidebar-link-set-track-options',
timeOfDay: '#wizard-sidebar-link-set-time-of-day',
weather: '#wizard-sidebar-link-set-weather',
raceOptions: '#wizard-sidebar-link-set-race-options',
trackConditions: '#wizard-sidebar-link-set-track-conditions',
},
// Wizard step containers (the visible step content)
stepContainers: {
@@ -121,14 +142,20 @@ export const IRACING_SELECTORS = {
race: '#set-time-limit input[id*="time-limit-slider"]',
// Step 8/9: Cars
carSearch: 'input[placeholder*="Search"]',
carList: 'table.table.table-striped',
// Add Car button - CORRECTED: Uses specific class and text
addCarButton: 'a.btn.btn-primary.btn-block.btn-sm:has-text("Add a Car")',
// Car selection interface - drawer that opens within the wizard sidebar
addCarModal: '.drawer-container .drawer',
// Select button inside car dropdown - opens config selection
carSelectButton: 'a.btn.btn-primary.btn-xs.dropdown-toggle:has-text("Select")',
carSearch:
'#select-car-set-cars input[placeholder*="Search"], ' +
'input[placeholder*="Search"]',
carList: '#select-car-set-cars table.table.table-striped, table.table.table-striped',
addCarButton:
'#select-car-set-cars a.btn.btn-primary:has-text("Add a Car"), ' +
'#select-car-set-cars a.btn.btn-primary:has-text("Add a Car 16 Available")',
addCarModal:
'#select-car-compact-content, ' +
'.drawer-container, ' +
'.drawer-container .drawer',
carSelectButton:
'#select-car-set-cars a.btn.btn-block:has-text("Select"), ' +
'a.btn.btn-block:has-text("Select")',
// Step 10/11/12: Track
trackSearch: 'input[placeholder*="Search"]',

9
packages/infrastructure/adapters/automation/engine/AutomationEngineAdapter.ts
View File

@@ -3,7 +3,7 @@ import { HostedSessionConfig } from '../../../../domain/entities/HostedSessionCo
import { StepId } from '../../../../domain/value-objects/StepId';
import type { IBrowserAutomation } from '../../../../application/ports/IScreenAutomation';
import { ISessionRepository } from '../../../../application/ports/ISessionRepository';
import { getStepName } from './templates/IRacingTemplateMap';
import { StepTransitionValidator } from '../../../../domain/services/StepTransitionValidator';
/**
* Real Automation Engine Adapter.
@@ -84,10 +84,10 @@ export class AutomationEngineAdapter implements IAutomationEngine {
// Execute current step using the browser automation
if (this.browserAutomation.executeStep) {
// Use real workflow automation with IRacingSelectorMap
const result = await this.browserAutomation.executeStep(currentStep, config as unknown as Record<string, unknown>);
if (!result.success) {
const errorMessage = `Step ${currentStep.value} (${getStepName(currentStep.value)}) failed: ${result.error}`;
const stepDescription = StepTransitionValidator.getStepDescription(currentStep);
const errorMessage = `Step ${currentStep.value} (${stepDescription}) failed: ${result.error}`;
console.error(errorMessage);
// Stop automation and mark session as failed
@@ -114,7 +114,8 @@ export class AutomationEngineAdapter implements IAutomationEngine {
if (this.browserAutomation.executeStep) {
const result = await this.browserAutomation.executeStep(nextStep, config as unknown as Record<string, unknown>);
if (!result.success) {
const errorMessage = `Step ${nextStep.value} (${getStepName(nextStep.value)}) failed: ${result.error}`;
const stepDescription = StepTransitionValidator.getStepDescription(nextStep);
const errorMessage = `Step ${nextStep.value} (${stepDescription}) failed: ${result.error}`;
console.error(errorMessage);
// Don't try to fail terminal session - just log the error
// Session is already in STOPPED_AT_STEP_18 state after transitionToStep()

13
packages/infrastructure/adapters/automation/engine/MockAutomationEngineAdapter.ts
View File

@@ -3,7 +3,7 @@ import { HostedSessionConfig } from '../../../../domain/entities/HostedSessionCo
import { StepId } from '../../../../domain/value-objects/StepId';
import type { IBrowserAutomation } from '../../../../application/ports/IScreenAutomation';
import { ISessionRepository } from '../../../../application/ports/ISessionRepository';
import { getStepName } from './templates/IRacingTemplateMap';
import { StepTransitionValidator } from '../../../../domain/services/StepTransitionValidator';
export class MockAutomationEngineAdapter implements IAutomationEngine {
private isRunning = false;
@@ -67,15 +67,13 @@ export class MockAutomationEngineAdapter implements IAutomationEngine {
// Execute current step using the browser automation
if (this.browserAutomation.executeStep) {
// Use real workflow automation with IRacingSelectorMap
const result = await this.browserAutomation.executeStep(
currentStep,
config as unknown as Record<string, unknown>,
);
if (!result.success) {
const errorMessage = `Step ${currentStep.value} (${getStepName(
currentStep.value,
)}) failed: ${result.error}`;
const stepDescription = StepTransitionValidator.getStepDescription(currentStep);
const errorMessage = `Step ${currentStep.value} (${stepDescription}) failed: ${result.error}`;
console.error(errorMessage);
// Stop automation and mark session as failed
@@ -105,9 +103,8 @@ export class MockAutomationEngineAdapter implements IAutomationEngine {
config as unknown as Record<string, unknown>,
);
if (!result.success) {
const errorMessage = `Step ${nextStep.value} (${getStepName(
nextStep.value,
)}) failed: ${result.error}`;
const stepDescription = StepTransitionValidator.getStepDescription(nextStep);
const errorMessage = `Step ${nextStep.value} (${stepDescription}) failed: ${result.error}`;
console.error(errorMessage);
// Don't try to fail terminal session - just log the error
// Session is already in STOPPED_AT_STEP_18 state after transitionToStep()

890
packages/infrastructure/adapters/automation/engine/templates/IRacingTemplateMap.ts
View File

@@ -1,890 +0,0 @@
import { createImageTemplate, DEFAULT_CONFIDENCE, type CategorizedTemplate } from '@/packages/domain/value-objects/ImageTemplate';
import type { ImageTemplate } from '@/packages/domain/value-objects/ImageTemplate';
/**
* Template definitions for iRacing UI elements.
*
* These templates replace CSS selectors with image-based matching for TOS-compliant
* OS-level automation. Templates reference images in resources/templates/iracing/
*
* Template images should be captured from the actual iRacing UI at standard resolution.
* Recommended: 1920x1080 or 2560x1440 with PNG format for lossless quality.
*/
/**
* Step template configuration containing all templates needed for a workflow step.
*/
export interface StepTemplates {
/** Templates to detect if we're on this step */
indicators: ImageTemplate[];
/** Button templates for navigation and actions */
buttons: Record<string, ImageTemplate>;
/** Field templates for form inputs */
fields?: Record<string, ImageTemplate>;
/** Modal-related templates if applicable */
modal?: {
indicator: ImageTemplate;
closeButton: ImageTemplate;
confirmButton?: ImageTemplate;
searchInput?: ImageTemplate;
};
}
/**
* Complete template map type for iRacing automation.
*/
export interface IRacingTemplateMapType {
/** Common templates used across multiple steps */
common: {
/** Logged-in state indicators */
loginIndicators: ImageTemplate[];
/** Logged-out state indicators */
logoutIndicators: ImageTemplate[];
/** Generic navigation buttons */
navigation: Record<string, ImageTemplate>;
/** Loading indicators */
loading: ImageTemplate[];
};
/** Step-specific templates */
steps: Record<number, StepTemplates>;
/** Base path for template images */
templateBasePath: string;
}
/**
* Template paths for iRacing UI elements.
* All paths are relative to resources/templates/iracing/
*/
const TEMPLATE_PATHS = {
common: {
login: 'common/login-indicator.png',
logout: 'common/logout-indicator.png',
userAvatar: 'common/user-avatar.png',
memberBadge: 'common/member-badge.png',
loginButton: 'common/login-button.png',
loadingSpinner: 'common/loading-spinner.png',
nextButton: 'common/next-button.png',
backButton: 'common/back-button.png',
checkoutButton: 'common/checkout-button.png',
closeModal: 'common/close-modal-button.png',
},
steps: {
1: {
loginForm: 'step01-login/login-form.png',
emailField: 'step01-login/email-field.png',
passwordField: 'step01-login/password-field.png',
submitButton: 'step01-login/submit-button.png',
},
2: {
hostedRacingTab: 'step02-hosted/hosted-racing-tab.png',
// Using 1x template - will be scaled by 2x for Retina displays
createRaceButton: 'step02-hosted/create-race-button.png',
sessionList: 'step02-hosted/session-list.png',
},
3: {
createRaceModal: 'step03-create/create-race-modal.png',
confirmButton: 'step03-create/confirm-button.png',
},
4: {
stepIndicator: 'step04-info/race-info-indicator.png',
sessionNameField: 'step04-info/session-name-field.png',
passwordField: 'step04-info/password-field.png',
descriptionField: 'step04-info/description-field.png',
nextButton: 'step04-info/next-button.png',
},
5: {
stepIndicator: 'step05-server/server-details-indicator.png',
regionDropdown: 'step05-server/region-dropdown.png',
startNowToggle: 'step05-server/start-now-toggle.png',
nextButton: 'step05-server/next-button.png',
},
6: {
stepIndicator: 'step06-admins/admins-indicator.png',
addAdminButton: 'step06-admins/add-admin-button.png',
adminModal: 'step06-admins/admin-modal.png',
searchField: 'step06-admins/search-field.png',
nextButton: 'step06-admins/next-button.png',
},
7: {
stepIndicator: 'step07-time/time-limits-indicator.png',
practiceField: 'step07-time/practice-field.png',
qualifyField: 'step07-time/qualify-field.png',
raceField: 'step07-time/race-field.png',
nextButton: 'step07-time/next-button.png',
},
8: {
stepIndicator: 'step08-cars/cars-indicator.png',
addCarButton: 'step08-cars/add-car-button.png',
carList: 'step08-cars/car-list.png',
nextButton: 'step08-cars/next-button.png',
},
9: {
carModal: 'step09-addcar/car-modal.png',
searchField: 'step09-addcar/search-field.png',
carGrid: 'step09-addcar/car-grid.png',
selectButton: 'step09-addcar/select-button.png',
closeButton: 'step09-addcar/close-button.png',
},
10: {
stepIndicator: 'step10-classes/car-classes-indicator.png',
classDropdown: 'step10-classes/class-dropdown.png',
nextButton: 'step10-classes/next-button.png',
},
11: {
stepIndicator: 'step11-track/track-indicator.png',
addTrackButton: 'step11-track/add-track-button.png',
trackList: 'step11-track/track-list.png',
nextButton: 'step11-track/next-button.png',
},
12: {
trackModal: 'step12-addtrack/track-modal.png',
searchField: 'step12-addtrack/search-field.png',
trackGrid: 'step12-addtrack/track-grid.png',
selectButton: 'step12-addtrack/select-button.png',
closeButton: 'step12-addtrack/close-button.png',
},
13: {
stepIndicator: 'step13-trackopts/track-options-indicator.png',
configDropdown: 'step13-trackopts/config-dropdown.png',
nextButton: 'step13-trackopts/next-button.png',
},
14: {
stepIndicator: 'step14-tod/time-of-day-indicator.png',
timeSlider: 'step14-tod/time-slider.png',
datePicker: 'step14-tod/date-picker.png',
nextButton: 'step14-tod/next-button.png',
},
15: {
stepIndicator: 'step15-weather/weather-indicator.png',
weatherDropdown: 'step15-weather/weather-dropdown.png',
temperatureField: 'step15-weather/temperature-field.png',
nextButton: 'step15-weather/next-button.png',
},
16: {
stepIndicator: 'step16-race/race-options-indicator.png',
maxDriversField: 'step16-race/max-drivers-field.png',
rollingStartToggle: 'step16-race/rolling-start-toggle.png',
nextButton: 'step16-race/next-button.png',
},
17: {
stepIndicator: 'step17-team/team-driving-indicator.png',
teamDrivingToggle: 'step17-team/team-driving-toggle.png',
nextButton: 'step17-team/next-button.png',
},
18: {
stepIndicator: 'step18-conditions/track-conditions-indicator.png',
trackStateDropdown: 'step18-conditions/track-state-dropdown.png',
marblesToggle: 'step18-conditions/marbles-toggle.png',
// NOTE: No checkout button template - automation stops here for safety
},
},
} as const;
/**
* Complete template map for iRacing hosted session automation.
* Templates are organized by common elements and workflow steps.
*/
export const IRacingTemplateMap: IRacingTemplateMapType = {
templateBasePath: 'resources/templates/iracing',
common: {
loginIndicators: [
createImageTemplate(
'login-user-avatar',
TEMPLATE_PATHS.common.userAvatar,
'User avatar indicating logged-in state',
{ confidence: DEFAULT_CONFIDENCE.HIGH }
),
createImageTemplate(
'login-member-badge',
TEMPLATE_PATHS.common.memberBadge,
'Member badge indicating logged-in state',
{ confidence: DEFAULT_CONFIDENCE.STANDARD }
),
],
logoutIndicators: [
createImageTemplate(
'logout-login-button',
TEMPLATE_PATHS.common.loginButton,
'Login button indicating logged-out state',
{ confidence: DEFAULT_CONFIDENCE.HIGH }
),
],
navigation: {
next: createImageTemplate(
'nav-next',
TEMPLATE_PATHS.common.nextButton,
'Next button for wizard navigation',
{ confidence: DEFAULT_CONFIDENCE.STANDARD }
),
back: createImageTemplate(
'nav-back',
TEMPLATE_PATHS.common.backButton,
'Back button for wizard navigation',
{ confidence: DEFAULT_CONFIDENCE.STANDARD }
),
checkout: createImageTemplate(
'nav-checkout',
TEMPLATE_PATHS.common.checkoutButton,
'Checkout/submit button',
{ confidence: DEFAULT_CONFIDENCE.HIGH }
),
closeModal: createImageTemplate(
'nav-close-modal',
TEMPLATE_PATHS.common.closeModal,
'Close modal button',
{ confidence: DEFAULT_CONFIDENCE.STANDARD }
),
},
loading: [
createImageTemplate(
'loading-spinner',
TEMPLATE_PATHS.common.loadingSpinner,
'Loading spinner indicator',
{ confidence: DEFAULT_CONFIDENCE.LOW }
),
],
},
steps: {
// Step 1: LOGIN (handled externally, templates for detection only)
1: {
indicators: [
createImageTemplate(
'step1-login-form',
TEMPLATE_PATHS.steps[1].loginForm,
'Login form indicator',
{ confidence: DEFAULT_CONFIDENCE.STANDARD }
),
],
buttons: {
submit: createImageTemplate(
'step1-submit',
TEMPLATE_PATHS.steps[1].submitButton,
'Login submit button',
{ confidence: DEFAULT_CONFIDENCE.HIGH }
),
},
fields: {
email: createImageTemplate(
'step1-email',
TEMPLATE_PATHS.steps[1].emailField,
'Email input field',
{ confidence: DEFAULT_CONFIDENCE.STANDARD }
),
password: createImageTemplate(
'step1-password',
TEMPLATE_PATHS.steps[1].passwordField,
'Password input field',
{ confidence: DEFAULT_CONFIDENCE.STANDARD }
),
},
},
// Step 2: HOSTED_RACING
// NOTE: Using DEBUG confidence (0.5) temporarily to test template matching
// after fixing the Retina scaling issue (DISPLAY_SCALE_FACTOR=1)
2: {
indicators: [
createImageTemplate(
'step2-hosted-tab',
TEMPLATE_PATHS.steps[2].hostedRacingTab,
'Hosted racing tab indicator',
{ confidence: DEFAULT_CONFIDENCE.DEBUG }
),
],
buttons: {
createRace: createImageTemplate(
'step2-create-race',
TEMPLATE_PATHS.steps[2].createRaceButton,
'Create a Race button',
{ confidence: DEFAULT_CONFIDENCE.DEBUG }
),
},
},
// Step 3: CREATE_RACE
3: {
indicators: [
createImageTemplate(
'step3-modal',
TEMPLATE_PATHS.steps[3].createRaceModal,
'Create race modal indicator',
{ confidence: DEFAULT_CONFIDENCE.STANDARD }
),
],
buttons: {
confirm: createImageTemplate(
'step3-confirm',
TEMPLATE_PATHS.steps[3].confirmButton,
'Confirm create race button',
{ confidence: DEFAULT_CONFIDENCE.HIGH }
),
},
},
// Step 4: RACE_INFORMATION
4: {
indicators: [
createImageTemplate(
'step4-indicator',
TEMPLATE_PATHS.steps[4].stepIndicator,
'Race information step indicator',
{ confidence: DEFAULT_CONFIDENCE.STANDARD }
),
],
buttons: {
next: createImageTemplate(
'step4-next',
TEMPLATE_PATHS.steps[4].nextButton,
'Next to Server Details button',
{ confidence: DEFAULT_CONFIDENCE.HIGH }
),
},
fields: {
sessionName: createImageTemplate(
'step4-session-name',
TEMPLATE_PATHS.steps[4].sessionNameField,
'Session name input field',
{ confidence: DEFAULT_CONFIDENCE.STANDARD }
),
password: createImageTemplate(
'step4-password',
TEMPLATE_PATHS.steps[4].passwordField,
'Session password input field',
{ confidence: DEFAULT_CONFIDENCE.STANDARD }
),
description: createImageTemplate(
'step4-description',
TEMPLATE_PATHS.steps[4].descriptionField,
'Session description textarea',
{ confidence: DEFAULT_CONFIDENCE.STANDARD }
),
},
},
// Step 5: SERVER_DETAILS
5: {
indicators: [
createImageTemplate(
'step5-indicator',
TEMPLATE_PATHS.steps[5].stepIndicator,
'Server details step indicator',
{ confidence: DEFAULT_CONFIDENCE.STANDARD }
),
],
buttons: {
next: createImageTemplate(
'step5-next',
TEMPLATE_PATHS.steps[5].nextButton,
'Next to Admins button',
{ confidence: DEFAULT_CONFIDENCE.HIGH }
),
},
fields: {
region: createImageTemplate(
'step5-region',
TEMPLATE_PATHS.steps[5].regionDropdown,
'Server region dropdown',
{ confidence: DEFAULT_CONFIDENCE.STANDARD }
),
startNow: createImageTemplate(
'step5-start-now',
TEMPLATE_PATHS.steps[5].startNowToggle,
'Start now toggle',
{ confidence: DEFAULT_CONFIDENCE.STANDARD }
),
},
},
// Step 6: SET_ADMINS (modal step)
6: {
indicators: [
createImageTemplate(
'step6-indicator',
TEMPLATE_PATHS.steps[6].stepIndicator,
'Admins step indicator',
{ confidence: DEFAULT_CONFIDENCE.STANDARD }
),
],
buttons: {
addAdmin: createImageTemplate(
'step6-add-admin',
TEMPLATE_PATHS.steps[6].addAdminButton,
'Add admin button',
{ confidence: DEFAULT_CONFIDENCE.HIGH }
),
next: createImageTemplate(
'step6-next',
TEMPLATE_PATHS.steps[6].nextButton,
'Next to Time Limits button',
{ confidence: DEFAULT_CONFIDENCE.HIGH }
),
},
modal: {
indicator: createImageTemplate(
'step6-modal',
TEMPLATE_PATHS.steps[6].adminModal,
'Add admin modal indicator',
{ confidence: DEFAULT_CONFIDENCE.STANDARD }
),
closeButton: createImageTemplate(
'step6-modal-close',
TEMPLATE_PATHS.common.closeModal,
'Close admin modal button',
{ confidence: DEFAULT_CONFIDENCE.STANDARD }
),
searchInput: createImageTemplate(
'step6-search',
TEMPLATE_PATHS.steps[6].searchField,
'Admin search field',
{ confidence: DEFAULT_CONFIDENCE.STANDARD }
),
},
},
// Step 7: TIME_LIMITS
7: {
indicators: [
createImageTemplate(
'step7-indicator',
TEMPLATE_PATHS.steps[7].stepIndicator,
'Time limits step indicator',
{ confidence: DEFAULT_CONFIDENCE.STANDARD }
),
],
buttons: {
next: createImageTemplate(
'step7-next',
TEMPLATE_PATHS.steps[7].nextButton,
'Next to Cars button',
{ confidence: DEFAULT_CONFIDENCE.HIGH }
),
},
fields: {
practice: createImageTemplate(
'step7-practice',
TEMPLATE_PATHS.steps[7].practiceField,
'Practice length field',
{ confidence: DEFAULT_CONFIDENCE.STANDARD }
),
qualify: createImageTemplate(
'step7-qualify',
TEMPLATE_PATHS.steps[7].qualifyField,
'Qualify length field',
{ confidence: DEFAULT_CONFIDENCE.STANDARD }
),
race: createImageTemplate(
'step7-race',
TEMPLATE_PATHS.steps[7].raceField,
'Race length field',
{ confidence: DEFAULT_CONFIDENCE.STANDARD }
),
},
},
// Step 8: SET_CARS
8: {
indicators: [
createImageTemplate(
'step8-indicator',
TEMPLATE_PATHS.steps[8].stepIndicator,
'Cars step indicator',
{ confidence: DEFAULT_CONFIDENCE.STANDARD }
),
],
buttons: {
addCar: createImageTemplate(
'step8-add-car',
TEMPLATE_PATHS.steps[8].addCarButton,
'Add car button',
{ confidence: DEFAULT_CONFIDENCE.HIGH }
),
next: createImageTemplate(
'step8-next',
TEMPLATE_PATHS.steps[8].nextButton,
'Next to Track button',
{ confidence: DEFAULT_CONFIDENCE.HIGH }
),
},
},
// Step 9: ADD_CAR (modal step)
9: {
indicators: [
createImageTemplate(
'step9-modal',
TEMPLATE_PATHS.steps[9].carModal,
'Add car modal indicator',
{ confidence: DEFAULT_CONFIDENCE.STANDARD }
),
],
buttons: {
select: createImageTemplate(
'step9-select',
TEMPLATE_PATHS.steps[9].selectButton,
'Select car button',
{ confidence: DEFAULT_CONFIDENCE.HIGH }
),
},
modal: {
indicator: createImageTemplate(
'step9-modal-indicator',
TEMPLATE_PATHS.steps[9].carModal,
'Car selection modal',
{ confidence: DEFAULT_CONFIDENCE.STANDARD }
),
closeButton: createImageTemplate(
'step9-close',
TEMPLATE_PATHS.steps[9].closeButton,
'Close car modal button',
{ confidence: DEFAULT_CONFIDENCE.STANDARD }
),
searchInput: createImageTemplate(
'step9-search',
TEMPLATE_PATHS.steps[9].searchField,
'Car search field',
{ confidence: DEFAULT_CONFIDENCE.STANDARD }
),
},
},
// Step 10: SET_CAR_CLASSES
10: {
indicators: [
createImageTemplate(
'step10-indicator',
TEMPLATE_PATHS.steps[10].stepIndicator,
'Car classes step indicator',
{ confidence: DEFAULT_CONFIDENCE.STANDARD }
),
],
buttons: {
next: createImageTemplate(
'step10-next',
TEMPLATE_PATHS.steps[10].nextButton,
'Next to Track button',
{ confidence: DEFAULT_CONFIDENCE.HIGH }
),
},
fields: {
class: createImageTemplate(
'step10-class',
TEMPLATE_PATHS.steps[10].classDropdown,
'Car class dropdown',
{ confidence: DEFAULT_CONFIDENCE.STANDARD }
),
},
},
// Step 11: SET_TRACK
11: {
indicators: [
createImageTemplate(
'step11-indicator',
TEMPLATE_PATHS.steps[11].stepIndicator,
'Track step indicator',
{ confidence: DEFAULT_CONFIDENCE.STANDARD }
),
],
buttons: {
addTrack: createImageTemplate(
'step11-add-track',
TEMPLATE_PATHS.steps[11].addTrackButton,
'Add track button',
{ confidence: DEFAULT_CONFIDENCE.HIGH }
),
next: createImageTemplate(
'step11-next',
TEMPLATE_PATHS.steps[11].nextButton,
'Next to Track Options button',
{ confidence: DEFAULT_CONFIDENCE.HIGH }
),
},
},
// Step 12: ADD_TRACK (modal step)
12: {
indicators: [
createImageTemplate(
'step12-modal',
TEMPLATE_PATHS.steps[12].trackModal,
'Add track modal indicator',
{ confidence: DEFAULT_CONFIDENCE.STANDARD }
),
],
buttons: {
select: createImageTemplate(
'step12-select',
TEMPLATE_PATHS.steps[12].selectButton,
'Select track button',
{ confidence: DEFAULT_CONFIDENCE.HIGH }
),
},
modal: {
indicator: createImageTemplate(
'step12-modal-indicator',
TEMPLATE_PATHS.steps[12].trackModal,
'Track selection modal',
{ confidence: DEFAULT_CONFIDENCE.STANDARD }
),
closeButton: createImageTemplate(
'step12-close',
TEMPLATE_PATHS.steps[12].closeButton,
'Close track modal button',
{ confidence: DEFAULT_CONFIDENCE.STANDARD }
),
searchInput: createImageTemplate(
'step12-search',
TEMPLATE_PATHS.steps[12].searchField,
'Track search field',
{ confidence: DEFAULT_CONFIDENCE.STANDARD }
),
},
},
// Step 13: TRACK_OPTIONS
13: {
indicators: [
createImageTemplate(
'step13-indicator',
TEMPLATE_PATHS.steps[13].stepIndicator,
'Track options step indicator',
{ confidence: DEFAULT_CONFIDENCE.STANDARD }
),
],
buttons: {
next: createImageTemplate(
'step13-next',
TEMPLATE_PATHS.steps[13].nextButton,
'Next to Time of Day button',
{ confidence: DEFAULT_CONFIDENCE.HIGH }
),
},
fields: {
config: createImageTemplate(
'step13-config',
TEMPLATE_PATHS.steps[13].configDropdown,
'Track configuration dropdown',
{ confidence: DEFAULT_CONFIDENCE.STANDARD }
),
},
},
// Step 14: TIME_OF_DAY
14: {
indicators: [
createImageTemplate(
'step14-indicator',
TEMPLATE_PATHS.steps[14].stepIndicator,
'Time of day step indicator',
{ confidence: DEFAULT_CONFIDENCE.STANDARD }
),
],
buttons: {
next: createImageTemplate(
'step14-next',
TEMPLATE_PATHS.steps[14].nextButton,
'Next to Weather button',
{ confidence: DEFAULT_CONFIDENCE.HIGH }
),
},
fields: {
time: createImageTemplate(
'step14-time',
TEMPLATE_PATHS.steps[14].timeSlider,
'Time of day slider',
{ confidence: DEFAULT_CONFIDENCE.STANDARD }
),
date: createImageTemplate(
'step14-date',
TEMPLATE_PATHS.steps[14].datePicker,
'Date picker',
{ confidence: DEFAULT_CONFIDENCE.STANDARD }
),
},
},
// Step 15: WEATHER
15: {
indicators: [
createImageTemplate(
'step15-indicator',
TEMPLATE_PATHS.steps[15].stepIndicator,
'Weather step indicator',
{ confidence: DEFAULT_CONFIDENCE.STANDARD }
),
],
buttons: {
next: createImageTemplate(
'step15-next',
TEMPLATE_PATHS.steps[15].nextButton,
'Next to Race Options button',
{ confidence: DEFAULT_CONFIDENCE.HIGH }
),
},
fields: {
weather: createImageTemplate(
'step15-weather',
TEMPLATE_PATHS.steps[15].weatherDropdown,
'Weather type dropdown',
{ confidence: DEFAULT_CONFIDENCE.STANDARD }
),
temperature: createImageTemplate(
'step15-temperature',
TEMPLATE_PATHS.steps[15].temperatureField,
'Temperature field',
{ confidence: DEFAULT_CONFIDENCE.STANDARD }
),
},
},
// Step 16: RACE_OPTIONS
16: {
indicators: [
createImageTemplate(
'step16-indicator',
TEMPLATE_PATHS.steps[16].stepIndicator,
'Race options step indicator',
{ confidence: DEFAULT_CONFIDENCE.STANDARD }
),
],
buttons: {
next: createImageTemplate(
'step16-next',
TEMPLATE_PATHS.steps[16].nextButton,
'Next to Track Conditions button',
{ confidence: DEFAULT_CONFIDENCE.HIGH }
),
},
fields: {
maxDrivers: createImageTemplate(
'step16-max-drivers',
TEMPLATE_PATHS.steps[16].maxDriversField,
'Maximum drivers field',
{ confidence: DEFAULT_CONFIDENCE.STANDARD }
),
rollingStart: createImageTemplate(
'step16-rolling-start',
TEMPLATE_PATHS.steps[16].rollingStartToggle,
'Rolling start toggle',
{ confidence: DEFAULT_CONFIDENCE.STANDARD }
),
},
},
// Step 17: TEAM_DRIVING
17: {
indicators: [
createImageTemplate(
'step17-indicator',
TEMPLATE_PATHS.steps[17].stepIndicator,
'Team driving step indicator',
{ confidence: DEFAULT_CONFIDENCE.STANDARD }
),
],
buttons: {
next: createImageTemplate(
'step17-next',
TEMPLATE_PATHS.steps[17].nextButton,
'Next to Track Conditions button',
{ confidence: DEFAULT_CONFIDENCE.HIGH }
),
},
fields: {
teamDriving: createImageTemplate(
'step17-team-driving',
TEMPLATE_PATHS.steps[17].teamDrivingToggle,
'Team driving toggle',
{ confidence: DEFAULT_CONFIDENCE.STANDARD }
),
},
},
// Step 18: TRACK_CONDITIONS (final step - no checkout for safety)
18: {
indicators: [
createImageTemplate(
'step18-indicator',
TEMPLATE_PATHS.steps[18].stepIndicator,
'Track conditions step indicator',
{ confidence: DEFAULT_CONFIDENCE.STANDARD }
),
],
buttons: {
// NOTE: No checkout button - automation intentionally stops here
// User must manually review and submit
},
fields: {
trackState: createImageTemplate(
'step18-track-state',
TEMPLATE_PATHS.steps[18].trackStateDropdown,
'Track state dropdown',
{ confidence: DEFAULT_CONFIDENCE.STANDARD }
),
marbles: createImageTemplate(
'step18-marbles',
TEMPLATE_PATHS.steps[18].marblesToggle,
'Marbles toggle',
{ confidence: DEFAULT_CONFIDENCE.STANDARD }
),
},
},
},
};
/**
* Get templates for a specific step.
*/
export function getStepTemplates(stepId: number): StepTemplates | undefined {
return IRacingTemplateMap.steps[stepId];
}
/**
* Check if a step is a modal step (requires opening a secondary dialog).
*/
export function isModalStep(stepId: number): boolean {
const templates = IRacingTemplateMap.steps[stepId];
return templates?.modal !== undefined;
}
/**
* Get the step name for logging/debugging.
*/
export function getStepName(stepId: number): string {
const stepNames: Record<number, string> = {
1: 'LOGIN',
2: 'HOSTED_RACING',
3: 'CREATE_RACE',
4: 'RACE_INFORMATION',
5: 'SERVER_DETAILS',
6: 'SET_ADMINS',
7: 'TIME_LIMITS',
8: 'SET_CARS',
9: 'ADD_CAR',
10: 'SET_CAR_CLASSES',
11: 'SET_TRACK',
12: 'ADD_TRACK',
13: 'TRACK_OPTIONS',
14: 'TIME_OF_DAY',
15: 'WEATHER',
16: 'RACE_OPTIONS',
17: 'TEAM_DRIVING',
18: 'TRACK_CONDITIONS',
};
return stepNames[stepId] || `UNKNOWN_STEP_${stepId}`;
}
/**
* Get all login indicator templates.
*/
export function getLoginIndicators(): ImageTemplate[] {
return IRacingTemplateMap.common.loginIndicators;
}
/**
* Get all logout indicator templates.
*/
export function getLogoutIndicators(): ImageTemplate[] {
return IRacingTemplateMap.common.logoutIndicators;
}

12
packages/infrastructure/adapters/automation/index.ts
View File

@@ -5,7 +5,6 @@
* - MockBrowserAutomationAdapter: Mock adapter for testing
* - PlaywrightAutomationAdapter: Browser automation via Playwright
* - FixtureServer: HTTP server for serving fixture HTML files
* - IRacingTemplateMap: Template map for iRacing UI elements
*/
// Adapters
@@ -17,13 +16,4 @@ export type { PlaywrightConfig, AutomationAdapterMode } from './core/PlaywrightA
export { FixtureServer, getFixtureForStep, getAllStepFixtureMappings } from './engine/FixtureServer';
export type { IFixtureServer } from './engine/FixtureServer';
// Template map and utilities
export {
IRacingTemplateMap,
getStepTemplates,
getStepName,
isModalStep,
getLoginIndicators,
getLogoutIndicators,
} from './engine/templates/IRacingTemplateMap';
export type { IRacingTemplateMapType, StepTemplates } from './engine/templates/IRacingTemplateMap';
// Template map and utilities removed (image-based automation deprecated)