jettypod 4.4.118 → 4.4.121

package/apps/dashboard/lib/environment-config.ts

@@ -0,0 +1,173 @@
+/**
+ * Environment config loader — reads user-defined service configuration
+ * from .jettypod/config.json via Tauri IPC.
+ *
+ * The config.json "environment" key is captured by the Rust config reader's
+ * `extra` field (#[serde(flatten)]), so it's returned by db_get_config.
+ */
+
+import { invoke, isTauri } from './tauri';
+import type { ServiceConfig } from './proof-run';
+
+// ─── Config Types ────────────────────────────────────────────
+
+export type ServiceCategory = 'server' | 'infrastructure' | 'managed' | 'test-runner' | 'build-tool';
+
+const VALID_CATEGORIES = new Set<ServiceCategory>(['server', 'infrastructure', 'managed', 'test-runner', 'build-tool']);
+
+/** Coerce unknown category to valid ServiceCategory, defaulting to 'server' */
+export function validateCategory(value: unknown): ServiceCategory {
+  if (typeof value === 'string' && VALID_CATEGORIES.has(value as ServiceCategory)) {
+    return value as ServiceCategory;
+  }
+  return 'server';
+}
+
+/** Validate faIcon string — must start with 'fa-' */
+export function validateFaIcon(value: unknown): string | undefined {
+  if (typeof value === 'string' && value.startsWith('fa-')) return value;
+  return undefined;
+}
+
+export interface ServiceDefinition {
+  /** Display name shown in Environment Bar */
+  name: string;
+  /** Shell command to start this service */
+  command: string;
+  /** Port to health-check against */
+  port: number;
+  /** Health check strategy: http, ws, or tcp */
+  healthCheck: 'http' | 'ws' | 'tcp';
+  /** Optional: stdout pattern that means "ready" (faster than polling port) */
+  readyPattern?: string;
+  /** Optional services don't block "Ready for QA" */
+  optional?: boolean;
+  /** Launch order (lower = first). Same order = parallel. */
+  order: number;
+  /** Category for two-zone layout grouping */
+  category: ServiceCategory;
+  /** FontAwesome icon class (e.g. 'fa-database', 'fa-server') */
+  faIcon?: string;
+}
+
+/** Non-launchable stack items (managed services, test runners, build tools) */
+export interface ContextItem {
+  /** Display name */
+  name: string;
+  /** Category determines zone placement and UX controls */
+  category: Extract<ServiceCategory, 'managed' | 'test-runner' | 'build-tool'>;
+  /** FontAwesome icon class */
+  faIcon?: string;
+  /** Shell command (e.g. test runner run command, connection test) */
+  command?: string;
+  /** Connection string or URL for managed services */
+  connectionUrl?: string;
+}
+
+export interface EnvironmentConfig {
+  services: ServiceDefinition[];
+  /** Non-launchable stack items displayed in the context zone */
+  contextItems: ContextItem[];
+  /** 'required' = all non-optional services must be up. 'all' = everything. */
+  readyWhen: 'required' | 'all';
+  /** Kill spawned processes when QA page unmounts. Default true. */
+  teardownOnClose: boolean;
+}
+
+// ─── Loader ──────────────────────────────────────────────────
+
+/**
+ * Load environment config from .jettypod/config.json via Tauri IPC.
+ * Returns null if no environment section is configured or not running in Tauri.
+ */
+export async function loadEnvironmentConfig(): Promise<EnvironmentConfig | null> {
+  if (!isTauri()) return null;
+
+  try {
+    const fullConfig = await invoke<Record<string, unknown>>('db_get_config');
+    const env = fullConfig?.environment as Record<string, unknown> | undefined;
+    if (!env || !Array.isArray(env.services) || env.services.length === 0) {
+      return null;
+    }
+
+    const contextItems = Array.isArray(env.contextItems)
+      ? (env.contextItems as ContextItem[]).map(item => ({
+          name: item.name,
+          category: item.category,
+          faIcon: item.faIcon,
+          command: item.command,
+          connectionUrl: item.connectionUrl,
+        }))
+      : [];
+
+    return {
+      services: (env.services as ServiceDefinition[]).map((svc, i) => ({
+        name: svc.name,
+        command: svc.command,
+        port: svc.port,
+        healthCheck: svc.healthCheck || 'http',
+        readyPattern: svc.readyPattern,
+        optional: svc.optional ?? false,
+        order: svc.order ?? i + 1,
+        category: validateCategory(svc.category),
+        faIcon: validateFaIcon(svc.faIcon),
+      })),
+      contextItems,
+      readyWhen: (env.readyWhen as EnvironmentConfig['readyWhen']) || 'required',
+      teardownOnClose: env.teardownOnClose !== false,
+    };
+  } catch {
+    // IPC failure (db not initialized, config read error) — fall back to passive detection
+    return null;
+  }
+}
+
+// ─── Health Check Helpers ────────────────────────────────────
+
+function checkHttp(port: number): Promise<boolean> {
+  return new Promise((resolve) => {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 2000);
+    fetch(`http://localhost:${port}/`, { signal: controller.signal, mode: 'no-cors' })
+      .then(() => { clearTimeout(timeout); resolve(true); })
+      .catch(() => { clearTimeout(timeout); resolve(false); });
+  });
+}
+
+function checkWs(port: number): Promise<boolean> {
+  return new Promise((resolve) => {
+    const timeout = setTimeout(() => { ws.close(); resolve(false); }, 2000);
+    const ws = new WebSocket(`ws://localhost:${port}`);
+    ws.onopen = () => { clearTimeout(timeout); ws.close(); resolve(true); };
+    ws.onerror = () => { clearTimeout(timeout); resolve(false); };
+  });
+}
+
+// ─── Converter ───────────────────────────────────────────────
+
+/**
+ * Convert EnvironmentConfig into ServiceConfig[] that ProofRunManager accepts.
+ * Maps the string-based healthCheck type to actual check functions.
+ */
+/** Categories that are part of the QA launch sequence */
+const LAUNCHABLE_CATEGORIES: ServiceCategory[] = ['server', 'infrastructure'];
+
+export function toServiceConfigs(config: EnvironmentConfig): ServiceConfig[] {
+  const checkers: Record<string, (port: number) => Promise<boolean>> = {
+    http: checkHttp,
+    ws: checkWs,
+    tcp: checkHttp, // TCP check uses same HTTP probe (any response = port open)
+  };
+
+  return config.services
+    .filter(svc => LAUNCHABLE_CATEGORIES.includes(svc.category))
+    .map(svc => ({
+      name: svc.name,
+      port: svc.port,
+      order: svc.order,
+      healthCheck: () => {
+        const checker = checkers[svc.healthCheck] || checkHttp;
+        return checker(svc.port);
+      },
+    }));
+}

package/apps/dashboard/lib/environment-verification.ts

@@ -0,0 +1,119 @@
+/**
+ * Environment Verification — fire-and-teardown wrapper around ProofRunManager.
+ *
+ * Used by ProjectStackSection after saving a new environment config to verify
+ * that all services actually start and pass health checks before transitioning
+ * to the "configured" state. Services are torn down immediately after verification.
+ */
+
+import { ProofRunManager } from './proof-run';
+import type { ProofRunStatus, ServiceStatus } from './proof-run';
+import type { EnvironmentConfig } from './environment-config';
+
+// ─── Types ───────────────────────────────────────────────────
+
+export interface VerificationServiceResult {
+  name: string;
+  port: number | null;
+  passed: boolean;
+  error?: string;
+}
+
+export interface VerificationResult {
+  allPassed: boolean;
+  services: VerificationServiceResult[];
+}
+
+export type VerificationState = 'idle' | 'verifying' | 'done';
+
+export interface VerificationUpdate {
+  state: VerificationState;
+  services: ServiceStatus[];
+  result?: VerificationResult;
+}
+
+// ─── Verification Runner ─────────────────────────────────────
+
+/** Default timeout for verification (ms) */
+const DEFAULT_VERIFICATION_TIMEOUT_MS = 60_000;
+
+/**
+ * Launch all services from an EnvironmentConfig, health-check them,
+ * report per-service results, then tear everything down.
+ *
+ * @param config - The environment config to verify
+ * @param projectCwd - The project working directory for spawning processes
+ * @param onUpdate - Callback for live status updates during verification
+ * @param timeoutMs - Maximum time to wait for all services (default 60s)
+ * @returns VerificationResult with per-service pass/fail
+ */
+export async function runVerification(
+  config: EnvironmentConfig,
+  projectCwd: string | null,
+  onUpdate: (update: VerificationUpdate) => void,
+  timeoutMs: number = DEFAULT_VERIFICATION_TIMEOUT_MS,
+): Promise<VerificationResult> {
+  let lastStatus: ProofRunStatus | null = null;
+
+  // Create a ProofRunManager to handle the actual launch + health checks
+  const manager = new ProofRunManager(
+    undefined,
+    (status: ProofRunStatus) => {
+      lastStatus = status;
+      onUpdate({
+        state: 'verifying',
+        services: status.services,
+      });
+    },
+    config,
+    projectCwd,
+  );
+
+  // Notify: starting verification
+  onUpdate({ state: 'verifying', services: manager.getStatus().services });
+
+  try {
+    // Launch services with a timeout to prevent hanging forever
+    const timeoutPromise = new Promise<'timeout'>((resolve) =>
+      setTimeout(() => resolve('timeout'), timeoutMs),
+    );
+
+    const raceResult = await Promise.race([
+      manager.startServices().then(() => 'done' as const),
+      timeoutPromise,
+    ]);
+
+    // Build result from final service statuses
+    const finalStatus = lastStatus ?? manager.getStatus();
+
+    const result: VerificationResult = {
+      allPassed: raceResult !== 'timeout' && finalStatus.services.every(s => s.status === 'running'),
+      services: finalStatus.services.map(s => {
+        const isTimedOut = raceResult === 'timeout' && s.status !== 'running';
+        return {
+          name: s.name,
+          port: s.port,
+          passed: s.status === 'running',
+          error: isTimedOut
+            ? `Verification timed out waiting for ${s.name} on port ${s.port}`
+            : s.status === 'crashed'
+              ? `Service failed to start on port ${s.port}`
+              : undefined,
+        };
+      }),
+    };
+
+    // Notify with result before teardown
+    onUpdate({
+      state: 'done',
+      services: finalStatus.services,
+      result,
+    });
+
+    return result;
+  } finally {
+    // Always tear down — verification is fire-and-forget
+    await manager.stopServices();
+    manager.destroy();
+  }
+}

package/apps/dashboard/lib/kanban-utils.ts

@@ -0,0 +1,270 @@
+import type { InFlightItem, KanbanGroup, WorkItem } from '@/lib/db';
+
+export interface KanbanData {
+  inFlight: InFlightItem[];
+  backlog: Map<string, KanbanGroup>;
+  done: Map<string, KanbanGroup>;
+  /** O(1) item lookup by ID — built once during transform in data-bridge */
+  itemMap: Map<number, InFlightItem>;
+  /** O(1) status lookup by ID — built once during transform in data-bridge */
+  statusMap: Map<number, string>;
+}
+
+// O(1) item lookup using the pre-built itemMap from data-bridge
+export function findItemById(data: KanbanData, id: number): { item: InFlightItem; status: string } | null {
+  const item = data.itemMap.get(id);
+  if (!item) return null;
+  const status = data.statusMap.get(id) ?? item.status;
+  return { item, status };
+}
+
+// Extract onboarding chore items from kanban data for the OnboardingWelcome component
+export function getOnboardingItems(data: KanbanData): WorkItem[] {
+  for (const group of data.backlog.values()) {
+    if (group.epicTitle === 'Project Planning') {
+      return group.items;
+    }
+  }
+  return [];
+}
+
+// Returns the pre-built statusMap from data-bridge (O(1) — no iteration needed)
+export function buildStatusMap(kanbanData: KanbanData): Map<number, string> {
+  return kanbanData.statusMap;
+}
+
+// ---- Optimistic update helpers ----
+// Pure functions that return new KanbanData with a mutation applied locally.
+// Used by RealTimeKanbanWrapper to update the UI instantly before IPC completes.
+
+/** Determine which column a status belongs to */
+function statusColumn(status: string): 'inFlight' | 'backlog' | 'done' {
+  if (status === 'in_progress' || status === 'blocked') return 'inFlight';
+  if (status === 'done' || status === 'cancelled') return 'done';
+  return 'backlog';
+}
+
+/** Remove an item from grouped columns (backlog or done Maps) */
+function removeFromGroups(groups: Map<string, KanbanGroup>, id: number): Map<string, KanbanGroup> {
+  const result = new Map<string, KanbanGroup>();
+  for (const [key, group] of groups) {
+    const filtered = group.items.filter(i => i.id !== id);
+    if (filtered.length > 0) {
+      result.set(key, { ...group, items: filtered });
+    }
+  }
+  return result;
+}
+
+/** Add an item to the appropriate epic group in a grouped column */
+function addToGroups(groups: Map<string, KanbanGroup>, item: InFlightItem, sort: 'display_order' | 'completed_at_desc' = 'display_order'): Map<string, KanbanGroup> {
+  const result = new Map(groups);
+  const key = item.parent_id ? String(item.parent_id) : 'ungrouped';
+  const compareFn = sort === 'completed_at_desc'
+    ? (a: InFlightItem, b: InFlightItem) => (b.completed_at ?? '').localeCompare(a.completed_at ?? '')
+    : (a: InFlightItem, b: InFlightItem) => (a.display_order ?? a.id * 10) - (b.display_order ?? b.id * 10);
+  const existing = result.get(key);
+  if (existing) {
+    const items = [...existing.items, item].sort(compareFn);
+    result.set(key, { ...existing, items });
+  } else {
+    result.set(key, {
+      epicId: item.parent_id,
+      epicTitle: item.parent_title,
+      items: [item],
+    });
+  }
+  return result;
+}
+
+/** Replace an item in a flat array */
+function replaceInArray(arr: InFlightItem[], id: number, updated: InFlightItem): InFlightItem[] {
+  return arr.map(i => i.id === id ? updated : i);
+}
+
+/** Replace an item in grouped columns */
+function replaceInGroups(groups: Map<string, KanbanGroup>, id: number, updated: InFlightItem): Map<string, KanbanGroup> {
+  const result = new Map<string, KanbanGroup>();
+  for (const [key, group] of groups) {
+    if (group.items.some(i => i.id === id)) {
+      result.set(key, { ...group, items: group.items.map(i => i.id === id ? updated : i) });
+    } else {
+      result.set(key, group);
+    }
+  }
+  return result;
+}
+
+/** Apply a status change optimistically. Moves item to the correct column. */
+export function applyStatusChange(
+  data: KanbanData,
+  id: number,
+  newStatus: string,
+  rejection?: { reason: string },
+): KanbanData {
+  const existing = data.itemMap.get(id);
+  if (!existing) return data;
+
+  const updatedItem: InFlightItem = {
+    ...existing,
+    status: newStatus,
+    ...(rejection && {
+      rejection_reason: rejection.reason,
+      rejection_count: existing.rejection_count + 1,
+      ready_for_review: 0,
+    }),
+    // Set completed_at when moving to done/cancelled so sort-by-recent works
+    ...(statusColumn(newStatus) === 'done' && !existing.completed_at && {
+      completed_at: new Date().toISOString(),
+    }),
+  };
+
+  // Remove from all columns
+  let newInFlight = data.inFlight.filter(i => i.id !== id);
+  const newBacklog = removeFromGroups(data.backlog, id);
+  const newDone = removeFromGroups(data.done, id);
+
+  // Add to correct column
+  const col = statusColumn(newStatus);
+  let finalBacklog = newBacklog;
+  let finalDone = newDone;
+  if (col === 'inFlight') {
+    newInFlight = [...newInFlight, updatedItem].sort((a, b) => (a.display_order ?? a.id * 10) - (b.display_order ?? b.id * 10));
+  } else if (col === 'done') {
+    finalDone = addToGroups(newDone, updatedItem, 'completed_at_desc');
+  } else {
+    finalBacklog = addToGroups(newBacklog, updatedItem);
+  }
+
+  const newItemMap = new Map(data.itemMap);
+  newItemMap.set(id, updatedItem);
+  const newStatusMap = new Map(data.statusMap);
+  newStatusMap.set(id, newStatus);
+
+  return { inFlight: newInFlight, backlog: finalBacklog, done: finalDone, itemMap: newItemMap, statusMap: newStatusMap };
+}
+
+/** Apply a title change optimistically. */
+export function applyTitleChange(data: KanbanData, id: number, newTitle: string): KanbanData {
+  const existing = data.itemMap.get(id);
+  if (!existing) return data;
+
+  const updatedItem: InFlightItem = { ...existing, title: newTitle };
+  const col = statusColumn(existing.status);
+
+  const newItemMap = new Map(data.itemMap);
+  newItemMap.set(id, updatedItem);
+
+  return {
+    inFlight: col === 'inFlight' ? replaceInArray(data.inFlight, id, updatedItem) : data.inFlight,
+    backlog: col === 'backlog' ? replaceInGroups(data.backlog, id, updatedItem) : data.backlog,
+    done: col === 'done' ? replaceInGroups(data.done, id, updatedItem) : data.done,
+    itemMap: newItemMap,
+    statusMap: data.statusMap,
+  };
+}
+
+/** Apply a display order change optimistically. */
+export function applyOrderChange(data: KanbanData, id: number, newOrder: number): KanbanData {
+  const existing = data.itemMap.get(id);
+  if (!existing) return data;
+
+  const updatedItem: InFlightItem = { ...existing, display_order: newOrder };
+  const col = statusColumn(existing.status);
+
+  const newItemMap = new Map(data.itemMap);
+  newItemMap.set(id, updatedItem);
+
+  if (col === 'inFlight') {
+    return {
+      ...data,
+      inFlight: replaceInArray(data.inFlight, id, updatedItem).sort((a, b) => (a.display_order ?? a.id * 10) - (b.display_order ?? b.id * 10)),
+      itemMap: newItemMap,
+    };
+  }
+
+  const groups = col === 'backlog' ? data.backlog : data.done;
+  const newGroups = new Map<string, KanbanGroup>();
+  for (const [key, group] of groups) {
+    if (group.items.some(i => i.id === id)) {
+      const items = group.items.map(i => i.id === id ? updatedItem : i).sort((a, b) => (a.display_order ?? a.id * 10) - (b.display_order ?? b.id * 10));
+      newGroups.set(key, { ...group, items });
+    } else {
+      newGroups.set(key, group);
+    }
+  }
+
+  return {
+    ...data,
+    backlog: col === 'backlog' ? newGroups : data.backlog,
+    done: col === 'done' ? newGroups : data.done,
+    itemMap: newItemMap,
+  };
+}
+
+/** Apply an epic assignment optimistically. Moves item between epic groups. */
+export function applyEpicAssign(data: KanbanData, id: number, epicId: number | null): KanbanData {
+  const existing = data.itemMap.get(id);
+  if (!existing) return data;
+
+  // Look up epic title from existing groups
+  let epicTitle: string | null = null;
+  if (epicId !== null) {
+    const key = String(epicId);
+    const group = data.backlog.get(key) || data.done.get(key);
+    if (group) {
+      epicTitle = group.epicTitle;
+    } else {
+      const sibling = data.inFlight.find(i => i.parent_id === epicId);
+      epicTitle = sibling?.parent_title ?? null;
+    }
+  }
+
+  const updatedItem: InFlightItem = {
+    ...existing,
+    parent_id: epicId,
+    parent_title: epicTitle,
+    epic_id: epicId,
+    epicTitle: epicTitle,
+  };
+
+  const col = statusColumn(existing.status);
+  const newItemMap = new Map(data.itemMap);
+  newItemMap.set(id, updatedItem);
+
+  if (col === 'inFlight') {
+    return {
+      ...data,
+      inFlight: replaceInArray(data.inFlight, id, updatedItem),
+      itemMap: newItemMap,
+    };
+  }
+
+  // Remove from current group, add to new group
+  const groups = col === 'backlog' ? data.backlog : data.done;
+  const sortMode = col === 'done' ? 'completed_at_desc' as const : 'display_order' as const;
+  const newGroups = addToGroups(removeFromGroups(groups, id), updatedItem, sortMode);
+
+  return {
+    ...data,
+    backlog: col === 'backlog' ? newGroups : data.backlog,
+    done: col === 'done' ? newGroups : data.done,
+    itemMap: newItemMap,
+  };
+}
+
+// Build a mode map from kanban data (feature id -> mode) for detecting mode transitions
+export function buildModeMap(kanbanData: KanbanData): Map<number, string | null> {
+  const map = new Map<number, string | null>();
+  const collectFeatures = (items: WorkItem[]) => {
+    for (const item of items) {
+      if (item.type === 'feature') {
+        map.set(item.id, item.mode);
+      }
+    }
+  };
+  collectFeatures(kanbanData.inFlight);
+  for (const group of kanbanData.backlog.values()) collectFeatures(group.items);
+  for (const group of kanbanData.done.values()) collectFeatures(group.items);
+  return map;
+}