@showrun/core 0.1.0

package/dist/authResilience.d.ts

@@ -0,0 +1,146 @@
+/**
+ * Auth resilience module: handles "run once" steps, auth failure detection, and recovery
+ */
+import type { Page } from 'playwright';
+import type { DslStep } from './dsl/types.js';
+import type { AuthPolicy, AuthGuard, Logger } from './types.js';
+import type { NetworkEntrySerializable } from './networkCapture.js';
+/**
+ * Outputs produced by a step (vars, collectibles, and network entries)
+ */
+export interface StepOutput {
+    vars: Record<string, unknown>;
+    collectibles: Record<string, unknown>;
+    /** Network entries referenced by this step (for network_find/network_replay caching) */
+    networkEntries?: NetworkEntrySerializable[];
+}
+/**
+ * Cache for tracking executed "once" steps per session/profile.
+ * Stores step outputs (vars and collectibles) to restore them when steps are skipped.
+ * Can be loaded from and persisted to disk when sessionId/profileId are provided.
+ */
+export declare class OnceCache {
+    private sessionCache;
+    private profileCache;
+    /**
+     * Create a cache, optionally loading from disk for the given sessionId and/or profileId.
+     *
+     * Storage locations:
+     * - Session cache: always in temp directory (ephemeral, cleared on server restart)
+     * - Profile cache: in profileCacheDir/.once-cache/profile.json if provided, else temp directory
+     */
+    static fromDisk(sessionId?: string, profileId?: string, profileCacheDir?: string): OnceCache;
+    /**
+     * Persist cache to disk for the given sessionId and/or profileId.
+     *
+     * Storage locations:
+     * - Session cache: always in temp directory (ephemeral)
+     * - Profile cache: in profileCacheDir/.once-cache/profile.json if provided, else temp directory
+     */
+    persist(sessionId?: string, profileId?: string, profileCacheDir?: string): void;
+    /**
+     * Check if a step should be skipped (already executed)
+     */
+    isExecuted(stepId: string, scope: 'session' | 'profile' | undefined): boolean;
+    /**
+     * Mark a step as executed with its outputs
+     */
+    markExecuted(stepId: string, scope: 'session' | 'profile', outputs?: StepOutput): void;
+    /**
+     * Get cached outputs for a step
+     */
+    getOutputs(stepId: string, scope: 'session' | 'profile'): StepOutput | undefined;
+    /**
+     * Clear cache for a specific scope
+     */
+    clear(scope: 'session' | 'profile'): void;
+    /**
+     * Clear all caches
+     */
+    clearAll(): void;
+}
+/**
+ * Auth failure detection result
+ */
+export interface AuthFailure {
+    url: string;
+    status: number;
+    stepId?: string;
+}
+/**
+ * Auth failure monitor that watches network responses
+ */
+export declare class AuthFailureMonitor {
+    private authPolicy;
+    private failures;
+    private urlRegex?;
+    constructor(authPolicy: AuthPolicy);
+    /**
+     * Check if auth policy is enabled
+     */
+    isEnabled(): boolean;
+    /**
+     * Check if a response indicates auth failure
+     */
+    isAuthFailure(url: string, status: number): boolean;
+    /**
+     * Record an auth failure
+     */
+    recordFailure(failure: AuthFailure): void;
+    /**
+     * Get the latest auth failure
+     */
+    getLatestFailure(): AuthFailure | undefined;
+    /**
+     * Get max recoveries allowed
+     */
+    getMaxRecoveries(): number;
+    /**
+     * Get max step retries after recovery
+     */
+    getMaxStepRetries(): number;
+    /**
+     * Get cooldown delay in ms
+     */
+    getCooldownMs(): number;
+    /**
+     * Clear recorded failures (for testing or reset)
+     */
+    clearFailures(): void;
+    /**
+     * Clear failures for a specific step ID
+     */
+    clearFailuresForStep(stepId: string): void;
+    /**
+     * Get failures for a specific step ID
+     */
+    getFailuresForStep(stepId: string): AuthFailure[];
+}
+/**
+ * Auth guard for proactive checks (OFF by default)
+ */
+export declare class AuthGuardChecker {
+    private guard;
+    constructor(guard: AuthGuard);
+    /**
+     * Check if guard is enabled
+     */
+    isEnabled(): boolean;
+    /**
+     * Check auth status using configured strategy
+     */
+    checkAuth(page: Page): Promise<boolean>;
+}
+/**
+ * Setup network response monitoring for browser sessions
+ */
+export declare function setupBrowserAuthMonitoring(page: Page, monitor: AuthFailureMonitor, logger: Logger, currentStepId?: string): void;
+/**
+ * Check if a step should be skipped due to "once" cache
+ */
+export declare function shouldSkipStep(step: DslStep, onceCache: OnceCache, sessionId?: string, profileId?: string): boolean;
+/**
+ * Get steps that should be rerun during recovery (all steps with once flag)
+ */
+export declare function getOnceSteps(steps: DslStep[]): DslStep[];
+//# sourceMappingURL=authResilience.d.ts.map

package/dist/authResilience.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authResilience.d.ts","sourceRoot":"","sources":["../src/authResilience.ts"],"names":[],"mappings":"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"}

package/dist/authResilience.js

@@ -0,0 +1,378 @@
+/**
+ * Auth resilience module: handles "run once" steps, auth failure detection, and recovery
+ */
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+const ONCE_CACHE_DIR_ENV = 'SHOWRUN_ONCE_CACHE_DIR';
+function getOnceCacheDir() {
+    const dir = process.env[ONCE_CACHE_DIR_ENV] ?? join(tmpdir(), 'showrun-once-cache');
+    return dir;
+}
+/** Sanitize id for use in cache filename (no path separators) */
+function sanitizeCacheId(id) {
+    return id.replace(/[/\\]/g, '-');
+}
+/**
+ * Cache for tracking executed "once" steps per session/profile.
+ * Stores step outputs (vars and collectibles) to restore them when steps are skipped.
+ * Can be loaded from and persisted to disk when sessionId/profileId are provided.
+ */
+export class OnceCache {
+    sessionCache = new Map();
+    profileCache = new Map();
+    /**
+     * Create a cache, optionally loading from disk for the given sessionId and/or profileId.
+     *
+     * Storage locations:
+     * - Session cache: always in temp directory (ephemeral, cleared on server restart)
+     * - Profile cache: in profileCacheDir/.once-cache/profile.json if provided, else temp directory
+     */
+    static fromDisk(sessionId, profileId, profileCacheDir) {
+        const defaultDir = getOnceCacheDir();
+        const cache = new OnceCache();
+        // Session cache always in temp directory (ephemeral)
+        if (sessionId) {
+            const file = join(defaultDir, `once-session-${sanitizeCacheId(sessionId)}.json`);
+            if (existsSync(file)) {
+                try {
+                    const data = readFileSync(file, 'utf-8');
+                    const parsed = JSON.parse(data);
+                    // Backward compatibility: if data is an array (old format), convert to Map with empty outputs
+                    if (Array.isArray(parsed)) {
+                        parsed.forEach((id) => cache.sessionCache.set(id, { vars: {}, collectibles: {} }));
+                    }
+                    else if (typeof parsed === 'object' && parsed !== null) {
+                        // New format: object with stepId -> StepOutput
+                        for (const [stepId, outputs] of Object.entries(parsed)) {
+                            const stepOutput = outputs;
+                            cache.sessionCache.set(stepId, {
+                                vars: stepOutput.vars ?? {},
+                                collectibles: stepOutput.collectibles ?? {},
+                                networkEntries: stepOutput.networkEntries,
+                            });
+                        }
+                    }
+                }
+                catch {
+                    // Ignore corrupt or missing file
+                }
+            }
+        }
+        // Profile cache in pack directory if provided, else default temp dir
+        if (profileId) {
+            let profileFile;
+            if (profileCacheDir) {
+                const cacheSubdir = join(profileCacheDir, '.once-cache');
+                profileFile = join(cacheSubdir, 'profile.json');
+            }
+            else {
+                profileFile = join(defaultDir, `once-profile-${sanitizeCacheId(profileId)}.json`);
+            }
+            if (existsSync(profileFile)) {
+                try {
+                    const data = readFileSync(profileFile, 'utf-8');
+                    const parsed = JSON.parse(data);
+                    // Backward compatibility: if data is an array (old format), convert to Map with empty outputs
+                    if (Array.isArray(parsed)) {
+                        parsed.forEach((id) => cache.profileCache.set(id, { vars: {}, collectibles: {} }));
+                    }
+                    else if (typeof parsed === 'object' && parsed !== null) {
+                        // New format: object with stepId -> StepOutput
+                        for (const [stepId, outputs] of Object.entries(parsed)) {
+                            const stepOutput = outputs;
+                            cache.profileCache.set(stepId, {
+                                vars: stepOutput.vars ?? {},
+                                collectibles: stepOutput.collectibles ?? {},
+                                networkEntries: stepOutput.networkEntries,
+                            });
+                        }
+                    }
+                }
+                catch {
+                    // Ignore corrupt or missing file
+                }
+            }
+        }
+        return cache;
+    }
+    /**
+     * Persist cache to disk for the given sessionId and/or profileId.
+     *
+     * Storage locations:
+     * - Session cache: always in temp directory (ephemeral)
+     * - Profile cache: in profileCacheDir/.once-cache/profile.json if provided, else temp directory
+     */
+    persist(sessionId, profileId, profileCacheDir) {
+        const defaultDir = getOnceCacheDir();
+        // Session cache always in temp directory
+        if (sessionId) {
+            try {
+                mkdirSync(defaultDir, { recursive: true });
+                const file = join(defaultDir, `once-session-${sanitizeCacheId(sessionId)}.json`);
+                const cacheObj = {};
+                for (const [stepId, outputs] of this.sessionCache) {
+                    cacheObj[stepId] = outputs;
+                }
+                writeFileSync(file, JSON.stringify(cacheObj, null, 2), 'utf-8');
+            }
+            catch {
+                // Ignore write errors
+            }
+        }
+        // Profile cache in pack directory if provided, else default temp dir
+        if (profileId) {
+            let profileFile;
+            let profileDir;
+            if (profileCacheDir) {
+                profileDir = join(profileCacheDir, '.once-cache');
+                profileFile = join(profileDir, 'profile.json');
+            }
+            else {
+                profileDir = defaultDir;
+                profileFile = join(defaultDir, `once-profile-${sanitizeCacheId(profileId)}.json`);
+            }
+            try {
+                mkdirSync(profileDir, { recursive: true });
+                const cacheObj = {};
+                for (const [stepId, outputs] of this.profileCache) {
+                    cacheObj[stepId] = outputs;
+                }
+                writeFileSync(profileFile, JSON.stringify(cacheObj, null, 2), 'utf-8');
+            }
+            catch {
+                // Ignore write errors
+            }
+        }
+    }
+    /**
+     * Check if a step should be skipped (already executed)
+     */
+    isExecuted(stepId, scope) {
+        if (!scope)
+            return false;
+        if (scope === 'session') {
+            return this.sessionCache.has(stepId);
+        }
+        else {
+            return this.profileCache.has(stepId);
+        }
+    }
+    /**
+     * Mark a step as executed with its outputs
+     */
+    markExecuted(stepId, scope, outputs = { vars: {}, collectibles: {} }) {
+        if (scope === 'session') {
+            this.sessionCache.set(stepId, outputs);
+        }
+        else {
+            this.profileCache.set(stepId, outputs);
+        }
+    }
+    /**
+     * Get cached outputs for a step
+     */
+    getOutputs(stepId, scope) {
+        const cache = scope === 'session' ? this.sessionCache : this.profileCache;
+        return cache.get(stepId);
+    }
+    /**
+     * Clear cache for a specific scope
+     */
+    clear(scope) {
+        if (scope === 'session') {
+            this.sessionCache.clear();
+        }
+        else {
+            this.profileCache.clear();
+        }
+    }
+    /**
+     * Clear all caches
+     */
+    clearAll() {
+        this.sessionCache.clear();
+        this.profileCache.clear();
+    }
+}
+/**
+ * Auth failure monitor that watches network responses
+ */
+export class AuthFailureMonitor {
+    authPolicy;
+    failures = [];
+    urlRegex;
+    constructor(authPolicy) {
+        this.authPolicy = {
+            enabled: authPolicy.enabled ?? true,
+            statusCodes: authPolicy.statusCodes ?? [401, 403],
+            urlIncludes: authPolicy.urlIncludes ?? [],
+            urlRegex: authPolicy.urlRegex,
+            loginUrlIncludes: authPolicy.loginUrlIncludes ?? [],
+            maxRecoveriesPerRun: authPolicy.maxRecoveriesPerRun ?? 1,
+            maxStepRetryAfterRecovery: authPolicy.maxStepRetryAfterRecovery ?? 1,
+            cooldownMs: authPolicy.cooldownMs ?? 0,
+        };
+        if (this.authPolicy.urlRegex) {
+            this.urlRegex = new RegExp(this.authPolicy.urlRegex);
+        }
+    }
+    /**
+     * Check if auth policy is enabled
+     */
+    isEnabled() {
+        return this.authPolicy.enabled;
+    }
+    /**
+     * Check if a response indicates auth failure
+     */
+    isAuthFailure(url, status) {
+        if (!this.authPolicy.enabled)
+            return false;
+        if (!this.authPolicy.statusCodes.includes(status))
+            return false;
+        // Check URL patterns if configured
+        if (this.authPolicy.urlIncludes.length > 0) {
+            const matches = this.authPolicy.urlIncludes.some((pattern) => url.includes(pattern));
+            if (!matches)
+                return false;
+        }
+        // Check URL regex if configured
+        if (this.urlRegex) {
+            if (!this.urlRegex.test(url))
+                return false;
+        }
+        return true;
+    }
+    /**
+     * Record an auth failure
+     */
+    recordFailure(failure) {
+        this.failures.push(failure);
+    }
+    /**
+     * Get the latest auth failure
+     */
+    getLatestFailure() {
+        return this.failures[this.failures.length - 1];
+    }
+    /**
+     * Get max recoveries allowed
+     */
+    getMaxRecoveries() {
+        return this.authPolicy.maxRecoveriesPerRun;
+    }
+    /**
+     * Get max step retries after recovery
+     */
+    getMaxStepRetries() {
+        return this.authPolicy.maxStepRetryAfterRecovery;
+    }
+    /**
+     * Get cooldown delay in ms
+     */
+    getCooldownMs() {
+        return this.authPolicy.cooldownMs;
+    }
+    /**
+     * Clear recorded failures (for testing or reset)
+     */
+    clearFailures() {
+        this.failures = [];
+    }
+    /**
+     * Clear failures for a specific step ID
+     */
+    clearFailuresForStep(stepId) {
+        this.failures = this.failures.filter((f) => f.stepId !== stepId);
+    }
+    /**
+     * Get failures for a specific step ID
+     */
+    getFailuresForStep(stepId) {
+        return this.failures.filter((f) => f.stepId === stepId);
+    }
+}
+/**
+ * Auth guard for proactive checks (OFF by default)
+ */
+export class AuthGuardChecker {
+    guard;
+    constructor(guard) {
+        this.guard = {
+            enabled: guard.enabled ?? false,
+            strategy: guard.strategy,
+        };
+    }
+    /**
+     * Check if guard is enabled
+     */
+    isEnabled() {
+        return this.guard.enabled ?? false;
+    }
+    /**
+     * Check auth status using configured strategy
+     */
+    async checkAuth(page) {
+        if (!this.isEnabled())
+            return true; // Guard disabled = assume auth is valid
+        const strategy = this.guard.strategy;
+        if (!strategy)
+            return true; // No strategy = assume auth is valid
+        // Check visible selector
+        if (strategy.visibleSelector) {
+            try {
+                const element = page.locator(strategy.visibleSelector);
+                const isVisible = await element.isVisible({ timeout: 5000 }).catch(() => false);
+                return isVisible;
+            }
+            catch {
+                return false;
+            }
+        }
+        // Check URL pattern
+        if (strategy.urlIncludes) {
+            const currentUrl = page.url();
+            return currentUrl.includes(strategy.urlIncludes);
+        }
+        return true; // Default: assume valid
+    }
+}
+/**
+ * Setup network response monitoring for browser sessions
+ */
+export function setupBrowserAuthMonitoring(page, monitor, logger, currentStepId) {
+    if (!monitor.isEnabled())
+        return;
+    page.on('response', (response) => {
+        const url = response.url();
+        const status = response.status();
+        if (monitor.isAuthFailure(url, status)) {
+            monitor.recordFailure({ url, status, stepId: currentStepId });
+            logger.log({
+                type: 'auth_failure_detected',
+                data: {
+                    url,
+                    status,
+                    stepId: currentStepId,
+                },
+            });
+        }
+    });
+}
+/**
+ * Check if a step should be skipped due to "once" cache
+ */
+export function shouldSkipStep(step, onceCache, sessionId, profileId) {
+    if (!step.once)
+        return false;
+    // Determine scope: if sessionId provided, use session; otherwise use profile
+    const scope = step.once === 'session' && sessionId ? 'session' : 'profile';
+    return onceCache.isExecuted(step.id, scope);
+}
+/**
+ * Get steps that should be rerun during recovery (all steps with once flag)
+ */
+export function getOnceSteps(steps) {
+    return steps.filter((step) => step.once !== undefined);
+}

package/dist/browserLauncher.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Unified browser launcher
+ *
+ * Provides a unified interface for launching browsers with different engines
+ * (Chromium, Camoufox) and persistence modes.
+ */
+import { type Browser, type BrowserContext, type Page } from 'playwright';
+import type { BrowserEngine, BrowserSettings, BrowserPersistence } from './types.js';
+/**
+ * Browser session returned by launchBrowser
+ */
+export interface BrowserSession {
+    /**
+     * Browser context (for both Chromium and Camoufox)
+     */
+    context: BrowserContext;
+    /**
+     * Main page in the context
+     */
+    page: Page;
+    /**
+     * Browser instance (null for Camoufox which returns context directly)
+     */
+    browser: Browser | null;
+    /**
+     * Engine used for this session
+     */
+    engine: BrowserEngine;
+    /**
+     * Persistence mode
+     */
+    persistence: BrowserPersistence;
+    /**
+     * User data directory path (if persistence is enabled)
+     */
+    userDataDir?: string;
+    /**
+     * Close the browser session
+     */
+    close(): Promise<void>;
+}
+/**
+ * Configuration for launching a browser
+ */
+export interface LaunchBrowserConfig {
+    /**
+     * Browser settings from task pack
+     */
+    browserSettings?: BrowserSettings;
+    /**
+     * Run in headless mode (default: true)
+     */
+    headless?: boolean;
+    /**
+     * Session ID for session persistence
+     */
+    sessionId?: string;
+    /**
+     * Pack directory path for profile persistence
+     */
+    packPath?: string;
+}
+/**
+ * Launches a browser with the specified configuration
+ *
+ * @param config - Browser launch configuration
+ * @returns Browser session with context, page, and close function
+ */
+export declare function launchBrowser(config: LaunchBrowserConfig): Promise<BrowserSession>;
+/**
+ * Checks if a browser engine is available
+ */
+export declare function isBrowserEngineAvailable(engine: BrowserEngine): Promise<boolean>;
+//# sourceMappingURL=browserLauncher.d.ts.map

package/dist/browserLauncher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browserLauncher.d.ts","sourceRoot":"","sources":["../src/browserLauncher.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAY,KAAK,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,IAAI,EAAE,MAAM,YAAY,CAAC;AACpF,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAGrF;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B;;OAEG;IACH,OAAO,EAAE,cAAc,CAAC;IACxB;;OAEG;IACH,IAAI,EAAE,IAAI,CAAC;IACX;;OAEG;IACH,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;IACxB;;OAEG;IACH,MAAM,EAAE,aAAa,CAAC;IACtB;;OAEG;IACH,WAAW,EAAE,kBAAkB,CAAC;IAChC;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;OAEG;IACH,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC;;OAEG;IACH,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC;;OAEG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;;GAKG;AACH,wBAAsB,aAAa,CAAC,MAAM,EAAE,mBAAmB,GAAG,OAAO,CAAC,cAAc,CAAC,CAgCxF;AA4HD;;GAEG;AACH,wBAAsB,wBAAwB,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,OAAO,CAAC,CAgBtF"}