jettypod 4.4.118 → 4.4.121

package/apps/dashboard/lib/proof-scenario-runner.ts

@@ -0,0 +1,346 @@
+/**
+ * Proof Scenario Runner — spawns cucumber-js and streams BDD results
+ * in real time to the proof dashboard.
+ *
+ * Uses Tauri IPC (spawn_process) when available, simulated behavior otherwise.
+ * Parses cucumber-js message format output for step-by-step progress.
+ */
+
+import { invoke, listen, isTauri } from './tauri';
+
+// ─── Types ───────────────────────────────────────────────────
+
+export interface ScenarioStep {
+  keyword: string;
+  text: string;
+  status: 'passed' | 'running' | 'pending' | 'failed' | 'skipped';
+  duration?: number;
+}
+
+export interface Scenario {
+  title: string;
+  status: 'passed' | 'running' | 'pending' | 'failed';
+  steps: ScenarioStep[];
+  duration?: number;
+}
+
+export interface ScenarioRunnerStatus {
+  scenarios: Scenario[];
+  logs: string[];
+  state: 'idle' | 'running' | 'complete' | 'failed';
+}
+
+export type ScenarioRunnerCallback = (status: ScenarioRunnerStatus) => void;
+
+// ─── Simulated scenario data ─────────────────────────────────
+
+const SIMULATED_SCENARIOS: { title: string; steps: { keyword: string; text: string }[] }[] = [
+  {
+    title: 'User can reach proof dashboard from kanban card',
+    steps: [
+      { keyword: 'Given', text: 'I am viewing the kanban board' },
+      { keyword: 'And', text: 'there is a work item that is ready for review' },
+      { keyword: 'When', text: 'I click the QA button on that card' },
+      { keyword: 'Then', text: 'I am on the proof dashboard for that work item' },
+      { keyword: 'And', text: 'I see the service health strip' },
+      { keyword: 'And', text: 'I see the scenario list' },
+    ],
+  },
+  {
+    title: 'Services auto-launch when proof starts',
+    steps: [
+      { keyword: 'Given', text: 'I am on the proof dashboard for a work item' },
+      { keyword: 'When', text: 'I click the Run Proof button' },
+      { keyword: 'Then', text: 'required services start in dependency order' },
+      { keyword: 'And', text: 'each service shows a health indicator' },
+      { keyword: 'And', text: 'the proof waits until all services are healthy' },
+    ],
+  },
+  {
+    title: 'BDD scenarios stream results in real time',
+    steps: [
+      { keyword: 'Given', text: 'I am on the proof dashboard for a work item' },
+      { keyword: 'And', text: 'all required services are healthy' },
+      { keyword: 'When', text: 'the proof run begins' },
+      { keyword: 'Then', text: 'each scenario appears in the scenario list' },
+      { keyword: 'And', text: 'each step streams its status as it executes' },
+      { keyword: 'And', text: 'the progress bar updates with each completed step' },
+    ],
+  },
+  {
+    title: 'Inspector tabs show proof details',
+    steps: [
+      { keyword: 'Given', text: 'a proof run is in progress' },
+      { keyword: 'When', text: 'I switch between inspector tabs' },
+      { keyword: 'Then', text: 'the Flow tab shows chronological event traces' },
+      { keyword: 'And', text: 'the Scenarios tab shows step-by-step BDD progress' },
+      { keyword: 'And', text: 'the API tab shows HTTP and IPC calls with latency' },
+      { keyword: 'And', text: 'the DB tab shows table mutations with before and after values' },
+      { keyword: 'And', text: 'the Logs tab shows raw service output' },
+    ],
+  },
+];
+
+// ─── Scenario Runner ─────────────────────────────────────────
+
+export class ScenarioRunner {
+  private scenarios: Scenario[] = [];
+  private logs: string[] = [];
+  private state: ScenarioRunnerStatus['state'] = 'idle';
+  private onUpdate: ScenarioRunnerCallback;
+  private unlisteners: (() => void)[] = [];
+  private pid: number | null = null;
+  private outputBuffer = '';
+
+  constructor(onUpdate: ScenarioRunnerCallback) {
+    this.onUpdate = onUpdate;
+  }
+
+  getStatus(): ScenarioRunnerStatus {
+    return {
+      scenarios: this.scenarios.map(s => ({ ...s, steps: [...s.steps] })),
+      logs: [...this.logs],
+      state: this.state,
+    };
+  }
+
+  async run(featureFile: string | null): Promise<void> {
+    this.state = 'running';
+    this.scenarios = [];
+    this.logs = [];
+    this.notify();
+
+    if (featureFile && isTauri()) {
+      await this.runReal(featureFile);
+    } else if (featureFile && !isTauri()) {
+      // Outside Tauri with a real feature file — can't spawn processes,
+      // fall back to simulated run
+      this.addLog(`Feature file: ${featureFile} (simulated — no Tauri IPC)`);
+      await this.runSimulated();
+    } else {
+      // No feature file — simulated run
+      this.addLog('No feature file linked to this work item — running simulated scenarios');
+      await this.runSimulated();
+    }
+  }
+
+  async stop(): Promise<void> {
+    if (this.pid && isTauri()) {
+      try {
+        await invoke('kill_process', { pid: this.pid });
+      } catch { /* best effort */ }
+    }
+    this.state = 'idle';
+    this.pid = null;
+    this.notify();
+  }
+
+  destroy(): void {
+    for (const unlisten of this.unlisteners) {
+      unlisten();
+    }
+    this.unlisteners = [];
+  }
+
+  // ─── Real Tauri IPC implementation ──────────────────────
+
+  private async runReal(featureFile: string): Promise<void> {
+    // Listen for process output to parse cucumber messages
+    const outputUnlisten = await listen<{ pid: number; lines: string[] }>(
+      'process-output-batch',
+      (event) => {
+        if (event.payload.pid !== this.pid) return;
+
+        for (const line of event.payload.lines) {
+          this.addLog(line);
+          this.outputBuffer += line;
+          this.parseCucumberOutput();
+        }
+      },
+    );
+    this.unlisteners.push(outputUnlisten);
+
+    const exitUnlisten = await listen<{ pid: number; code: number }>(
+      'process-exit',
+      (event) => {
+        if (event.payload.pid !== this.pid) return;
+        this.state = event.payload.code === 0 ? 'complete' : 'failed';
+        this.pid = null;
+        this.notify();
+      },
+    );
+    this.unlisteners.push(exitUnlisten);
+
+    // Spawn cucumber-js with message format for streaming
+    this.pid = await invoke<number>('spawn_process', {
+      command: 'npx',
+      args: ['cucumber-js', featureFile, '--format', 'message'],
+      label: 'cucumber-bdd',
+      kind: 'DevServer',
+      cwd: null,
+      envVars: {},
+    });
+  }
+
+  private parseCucumberOutput(): void {
+    // Parse newline-delimited JSON messages from cucumber
+    const lines = this.outputBuffer.split('\n');
+    this.outputBuffer = lines.pop() || ''; // Keep incomplete last line
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed || !trimmed.startsWith('{')) continue;
+
+      try {
+        const msg = JSON.parse(trimmed);
+        this.handleCucumberMessage(msg);
+      } catch {
+        // Not valid JSON, skip
+      }
+    }
+  }
+
+  private handleCucumberMessage(msg: Record<string, unknown>): void {
+    // Cucumber message format events
+    if (msg.pickle) {
+      const pickle = msg.pickle as { name: string; steps: { text: string; keyword?: string }[] };
+      this.scenarios.push({
+        title: pickle.name,
+        status: 'pending',
+        steps: pickle.steps.map(s => ({
+          keyword: (s.keyword || 'Step').trim(),
+          text: s.text,
+          status: 'pending' as const,
+        })),
+      });
+      this.notify();
+    }
+
+    if (msg.testCaseStarted) {
+      // Mark the next pending scenario as running
+      const pendingScenario = this.scenarios.find(s => s.status === 'pending');
+      if (pendingScenario) {
+        pendingScenario.status = 'running';
+        if (pendingScenario.steps.length > 0) {
+          pendingScenario.steps[0].status = 'running';
+        }
+        this.notify();
+      }
+    }
+
+    if (msg.testStepFinished) {
+      const result = msg.testStepFinished as { testStepResult: { status: string; duration?: { nanos: number } } };
+      const runningScenario = this.scenarios.find(s => s.status === 'running');
+      if (runningScenario) {
+        const runningStep = runningScenario.steps.find(s => s.status === 'running');
+        if (runningStep) {
+          const status = result.testStepResult.status.toLowerCase();
+          runningStep.status = (status === 'passed' ? 'passed' : 'failed') as ScenarioStep['status'];
+          if (result.testStepResult.duration) {
+            runningStep.duration = Math.round(result.testStepResult.duration.nanos / 1_000_000);
+          }
+
+          if (runningStep.status === 'failed') {
+            // Skip all remaining pending steps in this scenario
+            for (const step of runningScenario.steps) {
+              if (step.status === 'pending') {
+                step.status = 'skipped';
+              }
+            }
+          } else {
+            // Mark next pending step as running
+            const nextPending = runningScenario.steps.find(s => s.status === 'pending');
+            if (nextPending) {
+              nextPending.status = 'running';
+            }
+          }
+        }
+        this.notify();
+      }
+    }
+
+    if (msg.testCaseFinished) {
+      const runningScenario = this.scenarios.find(s => s.status === 'running');
+      if (runningScenario) {
+        const allPassed = runningScenario.steps.every(s => s.status === 'passed');
+        runningScenario.status = allPassed ? 'passed' : 'failed';
+
+        // Calculate total duration
+        const totalDuration = runningScenario.steps.reduce(
+          (acc, s) => acc + (s.duration || 0), 0
+        );
+        runningScenario.duration = totalDuration;
+        this.notify();
+      }
+    }
+  }
+
+  // ─── Simulated implementation (dev mode) ────────────────
+
+  private async runSimulated(): Promise<void> {
+    // Create all scenarios in pending state first
+    this.scenarios = SIMULATED_SCENARIOS.map(s => ({
+      title: s.title,
+      status: 'pending' as const,
+      steps: s.steps.map(step => ({
+        ...step,
+        status: 'pending' as const,
+      })),
+    }));
+    this.notify();
+
+    // Run through each scenario
+    for (const scenario of this.scenarios) {
+      scenario.status = 'running';
+      this.notify();
+
+      const scenarioStart = Date.now();
+
+      let scenarioFailed = false;
+
+      for (const step of scenario.steps) {
+        if (scenarioFailed) {
+          step.status = 'skipped';
+          this.addLog(`  - ${step.keyword} ${step.text} (skipped)`);
+          this.notify();
+          continue;
+        }
+
+        step.status = 'running';
+        this.notify();
+
+        // Simulate step execution (100-400ms per step)
+        const stepStart = Date.now();
+        const delay = 100 + Math.random() * 300;
+        await new Promise(resolve => setTimeout(resolve, delay));
+
+        step.status = 'passed';
+        step.duration = Date.now() - stepStart;
+        this.addLog(`  ✓ ${step.keyword} ${step.text} (${step.duration}ms)`);
+        this.notify();
+      }
+
+      scenario.status = scenarioFailed ? 'failed' : 'passed';
+      scenario.duration = Date.now() - scenarioStart;
+      this.addLog(`${scenarioFailed ? '✗' : '✓'} Scenario: ${scenario.title} (${scenario.duration}ms)`);
+      this.notify();
+    }
+
+    this.state = 'complete';
+    this.notify();
+  }
+
+  // ─── Helpers ────────────────────────────────────────────
+
+  private addLog(line: string): void {
+    this.logs.push(line);
+    // Keep last 500 lines
+    if (this.logs.length > 500) {
+      this.logs = this.logs.slice(-500);
+    }
+  }
+
+  private notify(): void {
+    this.onUpdate(this.getStatus());
+  }
+}

package/apps/dashboard/lib/run-migrations.js

@@ -99,14 +99,36 @@ function runMigrations(betterDb) {
     )
   `);
 
-  // Get already-applied migrations
-  const applied = betterDb.prepare('SELECT id FROM migrations').all().map(r => r.id);
+  // Create _meta table for schema versioning
+  betterDb.exec(`
+    CREATE TABLE IF NOT EXISTS _meta (
+      key TEXT PRIMARY KEY,
+      value TEXT
+    )
+  `);
 
   // Load migration files
   const files = fs.readdirSync(migrationsDir)
     .filter(f => f.endsWith('.js') && f !== 'index.js' && !f.endsWith('.test.js'))
     .sort();
 
+  const knownMigrationCount = files.length;
+
+  // Check schema version for forward-compatibility
+  const versionRow = betterDb.prepare('SELECT value FROM _meta WHERE key = ?').get('schema_version');
+  const currentVersion = versionRow ? parseInt(versionRow.value, 10) : 0;
+
+  if (currentVersion > knownMigrationCount) {
+    console.warn(
+      `⚠️  Database schema version (${currentVersion}) is newer than this version of JettyPod supports (${knownMigrationCount}).` +
+      '\n   Please update JettyPod to avoid compatibility issues.'
+    );
+    return; // Don't run migrations — the DB is from a newer version
+  }
+
+  // Get already-applied migrations
+  const applied = betterDb.prepare('SELECT id FROM migrations').all().map(r => r.id);
+
   // Create shim for callback-based migration API
   const shim = createDbShim(betterDb);
 
@@ -140,6 +162,9 @@ function runMigrations(betterDb) {
       throw err;
     }
   }
+
+  // Update schema version to reflect current state
+  betterDb.prepare('INSERT OR REPLACE INTO _meta (key, value) VALUES (?, ?)').run('schema_version', String(knownMigrationCount));
 }
 
 module.exports = { runMigrations };