jettypod 4.4.120 → 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/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';