jettypod 4.4.118 → 4.4.121

package/apps/dashboard/lib/service-recovery.ts

@@ -0,0 +1,326 @@
+/**
+ * Service Recovery — pre-flight checks and stderr-based recovery
+ * for the QA environment launch flow.
+ *
+ * Phase 1 (pre-flight): Detects and fixes common issues BEFORE spawning.
+ * Phase 2 (stderr recovery): Matches crash output to known patterns and retries.
+ *
+ * Uses Tauri IPC (run_shell_command) for all shell operations since this
+ * runs in browser context where child_process is unavailable.
+ */
+
+import { runShellCommand, isTauri } from './tauri';
+import type { ServiceDefinition } from './environment-config';
+
+// ─── Types ──────────────────────────────────────────────────
+
+export interface RecoveryStatus {
+  phase: 'preflight' | 'recovery';
+  service: string;
+  action: string;
+  severity?: 'info' | 'warning';
+}
+
+export interface PreflightResult {
+  check: string;
+  label: string;
+  fixed: boolean;
+  reason?: string;
+}
+
+export interface RecoveryResult {
+  shouldRetry: boolean;
+  fixApplied: string | null;
+  reason: string;
+}
+
+interface PreflightCheck {
+  name: string;
+  label: (ctx: Record<string, unknown>) => string;
+  detect: (service: ServiceDefinition, cwd: string | null) => Promise<Record<string, unknown> | null>;
+  fix: (ctx: Record<string, unknown>) => Promise<{ fixed: boolean; reason?: string }>;
+}
+
+interface StderrPattern {
+  name: string;
+  pattern: RegExp;
+  label: () => string;
+  fix: (ctx: { stderr: string; service: ServiceDefinition; cwd: string | null }) => Promise<{ fixed: boolean; reason?: string }>;
+}
+
+// ─── Dependency Install Strategies ──────────────────────────
+
+interface DependencyStrategy {
+  /** File that indicates this ecosystem */
+  marker: string;
+  /** Command to run */
+  command: string;
+  /** Arguments */
+  args: string[];
+  /** Timeout in ms */
+  timeoutMs: number;
+}
+
+const DEPENDENCY_STRATEGIES: DependencyStrategy[] = [
+  { marker: 'package.json', command: 'npm', args: ['install'], timeoutMs: 120_000 },
+  { marker: 'requirements.txt', command: 'pip', args: ['install', '-r', 'requirements.txt'], timeoutMs: 120_000 },
+  { marker: 'pyproject.toml', command: 'pip', args: ['install', '.'], timeoutMs: 120_000 },
+  { marker: 'Gemfile', command: 'bundle', args: ['install'], timeoutMs: 120_000 },
+  { marker: 'go.mod', command: 'go', args: ['mod', 'download'], timeoutMs: 120_000 },
+  { marker: 'Cargo.toml', command: 'cargo', args: ['build'], timeoutMs: 300_000 },
+];
+
+/** Detect which dependency strategy applies by checking for marker files. */
+async function detectDependencyStrategy(cwd: string): Promise<DependencyStrategy | null> {
+  for (const strategy of DEPENDENCY_STRATEGIES) {
+    const result = await runShellCommand('test', ['-f', strategy.marker], { cwd });
+    if (result.exit_code === 0) return strategy;
+  }
+  return null;
+}
+
+/** Check if a dependency directory exists (node_modules, venv, vendor, etc.) */
+async function hasDependencyDir(cwd: string, strategy: DependencyStrategy): Promise<boolean> {
+  const dirMap: Record<string, string> = {
+    'package.json': 'node_modules',
+    'Gemfile': 'vendor/bundle',
+    'go.mod': 'vendor',
+  };
+  const dir = dirMap[strategy.marker];
+  if (!dir) return true; // No dependency dir concept for this ecosystem
+  const result = await runShellCommand('test', ['-d', dir], { cwd });
+  return result.exit_code === 0;
+}
+
+// ─── Pre-flight Checks ─────────────────────────────────────
+
+export const PREFLIGHT_CHECKS: PreflightCheck[] = [
+  {
+    name: 'port-in-use',
+    label: (ctx) => `Freeing port ${ctx.port}...`,
+    detect: async (service) => {
+      if (!service.port) return null;
+      // Use lsof to check if port is in use
+      const result = await runShellCommand('lsof', ['-ti', `:${service.port}`], { timeoutMs: 5000 });
+      if (result.exit_code === 0 && result.stdout.trim()) {
+        return { port: service.port, pid: result.stdout.trim().split('\n')[0] };
+      }
+      return null;
+    },
+    fix: async (ctx) => {
+      const pid = ctx.pid as string;
+      if (!pid) return { fixed: false, reason: 'Could not identify process holding port' };
+
+      // Kill the process holding the port
+      await runShellCommand('kill', ['-TERM', pid], { timeoutMs: 5000 });
+
+      // Wait briefly then verify it's free
+      await new Promise(resolve => setTimeout(resolve, 500));
+
+      const check = await runShellCommand('lsof', ['-ti', `:${ctx.port}`], { timeoutMs: 5000 });
+      if (check.exit_code === 0 && check.stdout.trim()) {
+        // Still in use — force kill
+        await runShellCommand('kill', ['-KILL', pid], { timeoutMs: 5000 });
+        await new Promise(resolve => setTimeout(resolve, 300));
+      }
+      return { fixed: true };
+    },
+  },
+  {
+    name: 'missing-dependencies',
+    label: () => 'Installing dependencies...',
+    detect: async (service, cwd) => {
+      if (!cwd) return null;
+      const strategy = await detectDependencyStrategy(cwd);
+      if (!strategy) return null;
+      const hasDeps = await hasDependencyDir(cwd, strategy);
+      return hasDeps ? null : { cwd, strategy };
+    },
+    fix: async (ctx) => {
+      const strategy = ctx.strategy as DependencyStrategy;
+      const cwd = ctx.cwd as string;
+      const result = await runShellCommand(strategy.command, strategy.args, {
+        cwd,
+        timeoutMs: strategy.timeoutMs,
+      });
+      if (result.exit_code === 0) return { fixed: true };
+      return { fixed: false, reason: `${strategy.command} ${strategy.args.join(' ')} failed: ${result.stderr.slice(0, 200)}` };
+    },
+  },
+  {
+    name: 'command-not-found',
+    label: (ctx) => `Command "${ctx.command}" not found`,
+    detect: async (service) => {
+      const command = service.command.split(/\s+/)[0];
+      const result = await runShellCommand('which', [command], { timeoutMs: 5000 });
+      if (result.exit_code !== 0) return { command };
+      return null;
+    },
+    fix: async (ctx) => {
+      // Can't auto-fix missing commands — but we fail fast with a clear message
+      return { fixed: false, reason: `"${ctx.command}" is not installed` };
+    },
+  },
+];
+
+// ─── Stderr Patterns ────────────────────────────────────────
+
+export const STDERR_PATTERNS: StderrPattern[] = [
+  {
+    name: 'eaddrinuse',
+    pattern: /EADDRINUSE|address already in use|port.*already.*in.*use/i,
+    label: () => 'Port conflict detected, freeing port...',
+    fix: async (ctx) => {
+      // Extract port from stderr if possible, otherwise use service port
+      const portMatch = ctx.stderr.match(/port\s+(\d+)|:(\d+)/);
+      const port = portMatch ? parseInt(portMatch[1] || portMatch[2]) : ctx.service.port;
+      if (!port) return { fixed: false, reason: 'Could not determine port' };
+
+      const lsof = await runShellCommand('lsof', ['-ti', `:${port}`], { timeoutMs: 5000 });
+      const pid = lsof.stdout.trim().split('\n')[0];
+      if (pid) {
+        await runShellCommand('kill', ['-TERM', pid], { timeoutMs: 5000 });
+        await new Promise(resolve => setTimeout(resolve, 500));
+        return { fixed: true };
+      }
+      // Port may have been freed by the crashing process itself
+      const recheck = await runShellCommand('lsof', ['-ti', `:${port}`], { timeoutMs: 5000 });
+      return { fixed: recheck.exit_code !== 0 || !recheck.stdout.trim() };
+    },
+  },
+  {
+    name: 'module-not-found',
+    pattern: /Cannot find module|MODULE_NOT_FOUND|Error: Cannot find package|ModuleNotFoundError|No module named|cannot load such file|cannot find package/i,
+    label: () => 'Missing dependency detected, installing...',
+    fix: async (ctx) => {
+      const cwd = ctx.cwd;
+      if (!cwd) return { fixed: false, reason: 'No project directory' };
+      const strategy = await detectDependencyStrategy(cwd);
+      if (!strategy) return { fixed: false, reason: 'Unknown project type' };
+      const result = await runShellCommand(strategy.command, strategy.args, {
+        cwd,
+        timeoutMs: strategy.timeoutMs,
+      });
+      return { fixed: result.exit_code === 0, reason: result.exit_code !== 0 ? result.stderr.slice(0, 200) : undefined };
+    },
+  },
+  {
+    name: 'eacces-permission',
+    pattern: /EACCES|permission denied/i,
+    label: () => 'Permission error detected',
+    fix: async () => {
+      return { fixed: false, reason: 'Permission denied — check file permissions' };
+    },
+  },
+  {
+    name: 'env-var-missing',
+    pattern: /env.*not.*defined|missing.*environment|undefined.*env|process\.env\.\w+.*undefined/i,
+    label: () => 'Missing environment variable detected',
+    fix: async () => {
+      return { fixed: false, reason: 'Missing environment variable — check .env file' };
+    },
+  },
+];
+
+// ─── Service Recovery Orchestrator ──────────────────────────
+
+export class ServiceRecovery {
+  private onStatus: (status: RecoveryStatus) => void;
+
+  constructor(onStatus?: (status: RecoveryStatus) => void) {
+    this.onStatus = onStatus || (() => {});
+  }
+
+  /**
+   * Phase 1: Run pre-flight checks before spawning a service.
+   * Returns list of issues found and whether they were fixed.
+   */
+  async runPreflightChecks(
+    service: ServiceDefinition,
+    cwd: string | null,
+  ): Promise<PreflightResult[]> {
+    if (!isTauri()) return [];
+
+    const results: PreflightResult[] = [];
+
+    for (const check of PREFLIGHT_CHECKS) {
+      try {
+        const issue = await check.detect(service, cwd);
+        if (issue) {
+          const label = check.label(issue);
+          this.onStatus({ phase: 'preflight', service: service.name, action: label });
+
+          try {
+            const result = await check.fix(issue);
+            results.push({ check: check.name, label, ...result });
+
+            if (!result.fixed) {
+              this.onStatus({
+                phase: 'preflight',
+                service: service.name,
+                action: `Could not fix: ${result.reason}`,
+                severity: 'warning',
+              });
+            }
+          } catch (fixErr) {
+            const reason = fixErr instanceof Error ? fixErr.message : String(fixErr);
+            console.error(`[ServiceRecovery] Fix "${check.name}" threw for "${service.name}":`, reason);
+            results.push({ check: check.name, label, fixed: false, reason });
+            this.onStatus({
+              phase: 'preflight',
+              service: service.name,
+              action: `Could not fix: ${reason}`,
+              severity: 'warning',
+            });
+          }
+        }
+      } catch (detectErr) {
+        const reason = detectErr instanceof Error ? detectErr.message : String(detectErr);
+        console.error(`[ServiceRecovery] Check "${check.name}" threw for "${service.name}":`, reason);
+        results.push({ check: check.name, label: check.name, fixed: false, reason });
+        this.onStatus({
+          phase: 'preflight',
+          service: service.name,
+          action: `Check failed: ${reason}`,
+          severity: 'warning',
+        });
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Phase 2: Analyze stderr from a crashed service and attempt recovery.
+   * Returns whether the service should be retried.
+   */
+  async analyzeFailure(
+    service: ServiceDefinition,
+    stderr: string,
+    cwd: string | null,
+  ): Promise<RecoveryResult> {
+    if (!isTauri()) return { shouldRetry: false, fixApplied: null, reason: 'Not in Tauri' };
+
+    for (const pattern of STDERR_PATTERNS) {
+      if (pattern.pattern.test(stderr)) {
+        const label = pattern.label();
+        this.onStatus({ phase: 'recovery', service: service.name, action: label });
+
+        try {
+          const result = await pattern.fix({ stderr, service, cwd });
+          if (result.fixed) {
+            return { shouldRetry: true, fixApplied: pattern.name, reason: label };
+          } else {
+            return { shouldRetry: false, fixApplied: null, reason: result.reason || 'Fix failed' };
+          }
+        } catch (fixErr) {
+          const reason = fixErr instanceof Error ? fixErr.message : String(fixErr);
+          console.error(`[ServiceRecovery] Recovery fix "${pattern.name}" threw for "${service.name}":`, reason);
+          return { shouldRetry: false, fixApplied: null, reason };
+        }
+      }
+    }
+
+    return { shouldRetry: false, fixApplied: null, reason: 'Unrecognized failure' };
+  }
+}

package/apps/dashboard/lib/session-state-machine.ts

@@ -280,6 +280,7 @@ export function streamStatusToSessionState(status: string): SessionState {
     case 'idle':
       return 'idle';
     case 'connecting':
+    case 'creating':  // Stream manager uses 'creating' for first-message delay
       return 'connecting';
     case 'streaming':
       return 'streaming';

package/apps/dashboard/lib/session-state-utils.ts

@@ -57,170 +57,6 @@ export function createSyncRef<T>(initialValue: T): SyncRef<T> {
   };
 }
 
-// ============================================================================
-// Atomic State Updates
-// ============================================================================
-
-/**
- * Result of an atomic update operation.
- */
-export interface AtomicUpdateResult<T> {
-  /** Whether the update was applied */
-  applied: boolean;
-  /** The resulting state (whether updated or not) */
-  state: T;
-  /** If not applied, the reason */
-  reason?: 'version_mismatch' | 'condition_failed' | 'locked';
-}
-
-/**
- * Options for atomic update.
- */
-export interface AtomicUpdateOptions<T> {
-  /** Only apply if this condition returns true */
-  condition?: (currentState: T) => boolean;
-  /** Timeout for acquiring lock (ms). Default: 5000 */
-  timeoutMs?: number;
-}
-
-/**
- * Atomic state container that prevents concurrent update races.
- * Uses optimistic locking with version numbers.
- */
-export class AtomicState<T> {
-  private state: T;
-  private version: number = 0;
-  private locked: boolean = false;
-  private lockQueue: Array<() => void> = [];
-
-  constructor(initialState: T) {
-    this.state = initialState;
-  }
-
-  /**
-   * Get current state and version.
-   */
-  get(): { state: T; version: number } {
-    return { state: this.state, version: this.version };
-  }
-
-  /**
-   * Attempt to update state atomically.
-   * Only succeeds if the version matches (no concurrent updates).
-   *
-   * @param expectedVersion - The version you read before making changes
-   * @param newState - The new state to apply
-   * @param options - Optional conditions and timeout
-   */
-  compareAndSet(
-    expectedVersion: number,
-    newState: T,
-    options?: AtomicUpdateOptions<T>
-  ): AtomicUpdateResult<T> {
-    // Check version
-    if (this.version !== expectedVersion) {
-      return {
-        applied: false,
-        state: this.state,
-        reason: 'version_mismatch',
-      };
-    }
-
-    // Check condition if provided
-    if (options?.condition && !options.condition(this.state)) {
-      return {
-        applied: false,
-        state: this.state,
-        reason: 'condition_failed',
-      };
-    }
-
-    // Apply update
-    this.state = newState;
-    this.version++;
-
-    return {
-      applied: true,
-      state: this.state,
-    };
-  }
-
-  /**
-   * Update state with a transform function, handling retries automatically.
-   * This is the recommended way to update state when you need read-modify-write.
-   *
-   * @param transform - Function that takes current state and returns new state
-   * @param maxRetries - Maximum retries on version conflict. Default: 3
-   */
-  update(transform: (current: T) => T, maxRetries: number = 3): AtomicUpdateResult<T> {
-    for (let attempt = 0; attempt <= maxRetries; attempt++) {
-      const { state: current, version } = this.get();
-      const newState = transform(current);
-      const result = this.compareAndSet(version, newState);
-
-      if (result.applied) {
-        return result;
-      }
-
-      // Version mismatch - retry with fresh state
-      if (result.reason !== 'version_mismatch') {
-        return result;
-      }
-    }
-
-    // All retries exhausted
-    return {
-      applied: false,
-      state: this.state,
-      reason: 'version_mismatch',
-    };
-  }
-
-  /**
-   * Acquire exclusive lock for complex multi-step operations.
-   * Use sparingly - prefer compareAndSet or update for simple cases.
-   */
-  async lock(timeoutMs: number = 5000): Promise<() => void> {
-    if (!this.locked) {
-      this.locked = true;
-      return () => this.unlock();
-    }
-
-    // Wait for lock
-    return new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        const index = this.lockQueue.indexOf(tryAcquire);
-        if (index >= 0) this.lockQueue.splice(index, 1);
-        reject(new Error('Lock acquisition timeout'));
-      }, timeoutMs);
-
-      const tryAcquire = () => {
-        clearTimeout(timeout);
-        this.locked = true;
-        resolve(() => this.unlock());
-      };
-
-      this.lockQueue.push(tryAcquire);
-    });
-  }
-
-  private unlock(): void {
-    if (this.lockQueue.length > 0) {
-      const next = this.lockQueue.shift();
-      next?.();
-    } else {
-      this.locked = false;
-    }
-  }
-
-  /**
-   * Get current version (for debugging/monitoring).
-   */
-  getVersion(): number {
-    return this.version;
-  }
-}
-
 // ============================================================================
 // Session-Specific Helpers
 // ============================================================================