4runr-os 1.3.21 → 1.3.23

package/dist/ui/v3/commands/commandEngine.js

@@ -15,7 +15,7 @@
  * - Side-effect free
  * - Deterministic
  */
-import { available, unavailable, loading, isLoading } from '../state/value.js';
+import { available, unavailable } from '../state/value.js';
 import { listAgents, getAgent, createAgent as v1CreateAgent } from '../v1Adapters/agents.js';
 import { connect as v1Connect, getConnectionState } from '../v1Adapters/connect.js';
 import { startRun, listRuns } from '../v1Adapters/runs.js';
@@ -241,7 +241,7 @@ function handleUnknown(cmd) {
  * Network connection attempt ID tracker
  * Prevents stale updates from overlapping connection attempts
  */
-let networkAttemptId = 0;
+// networkAttemptId removed - using gatewayConnectionStore instead
 /**
  * Command registration map
  *
@@ -255,6 +255,7 @@ const commands = {
     // Section 6: Real commands (V1-backed)
     'agents': handleAgents,
     'connect': handleConnect,
+    'verify': handleVerify,
     'start': handleStart,
     'runs': handleRuns,
     'system': handleSystem,
@@ -339,6 +340,13 @@ function handleHelp(ctx, args) {
                 level: 'INFO',
                 msg: ' connect — connect to Gateway',
             },
+            {
+                id: `help-verify-${Date.now()}`,
+                ts: Date.now(),
+                tag: 'SYS',
+                level: 'INFO',
+                msg: ' verify          - Test connection with real API calls',
+            },
             {
                 id: `help-10-${Date.now()}`,
                 ts: Date.now(),
@@ -739,14 +747,12 @@ async function handleAgentsInspect(ctx, args) {
  * - Guarantees reset in finally block
  */
 async function handleConnect(ctx, args) {
-    // Increment attempt ID for this connection attempt
-    networkAttemptId++;
-    const currentAttemptId = networkAttemptId;
-    // Section 6.2: Ignore any arguments (parser may still accept them, but they are ignored)
-    // Always use canonical Gateway URL
+    // Import store and gateway config
+    const { gatewayConnectionStore } = await import('../state/gatewayConnectionStore.js');
     const gatewayConfig = await import('../config/gateway.js');
-    const resolvedTarget = gatewayConfig.resolveGatewayUrl();
-    // Step 1: Emit [CMD] connect
+    // Step 1: Resolve target with source tracking
+    const { url: inputTarget, source } = gatewayConfig.resolveGatewayUrlWithSource();
+    // Step 2: Emit [CMD] connect
     const cmdEvent = {
         id: `cmd-${Date.now()}`,
         ts: Date.now(),
@@ -754,109 +760,34 @@ async function handleConnect(ctx, args) {
         level: 'INFO',
         msg: 'connect',
     };
-    // Step 2: Parse URL and emit target info
-    let parsedHost = 'unknown';
-    let parsedPort = 'unknown';
-    try {
-        const url = new URL(resolvedTarget);
-        parsedHost = url.hostname;
-        parsedPort = url.port || (url.protocol === 'https:' ? '443' : '80');
-    }
-    catch {
-        // URL parse failed - use as-is
-    }
-    const targetEvent = {
-        id: `sys-target-${Date.now()}`,
+    const events = [cmdEvent];
+    // Step 3: Log target source
+    events.push({
+        id: `sys-source-${Date.now()}`,
         ts: Date.now(),
         tag: 'SYS',
         level: 'INFO',
-        msg: `connect: target=${resolvedTarget} host=${parsedHost} port=${parsedPort}`,
-    };
-    // Step 3: Run connection probes (TCP + HTTP) - but only show if they succeed
-    // If localhost fails, we'll auto-fallback and show probes for the successful endpoint
-    const events = [cmdEvent, targetEvent];
-    // Only run probes if we're not on Windows/Mac (where auto-fallback will handle it)
-    // Or if we're on Windows/Mac but not using localhost
-    const isLocalhost = resolvedTarget.includes('127.0.0.1') || resolvedTarget.includes('localhost');
-    const isWindowsOrMac = process.platform === 'win32' || process.platform === 'darwin';
-    const shouldSkipProbes = isLocalhost && isWindowsOrMac; // Skip localhost probes on Windows/Mac (auto-fallback will handle)
-    if (!shouldSkipProbes) {
-        try {
-            const { runConnectionProbes } = await import('../v1Adapters/connect.js');
-            const probeResults = await runConnectionProbes(resolvedTarget);
-            // Only show successful probes (cleaner UI)
-            for (const probe of probeResults) {
-                if (probe.success) {
-                    if (probe.type === 'tcp') {
-                        events.push({
-                            id: `sys-tcp-${Date.now()}`,
-                            ts: Date.now(),
-                            tag: 'SYS',
-                            level: 'INFO',
-                            msg: `tcp: ${probe.details}`,
-                        });
-                    }
-                    else if (probe.type === 'http') {
-                        events.push({
-                            id: `sys-http-${Date.now()}`,
-                            ts: Date.now(),
-                            tag: 'SYS',
-                            level: 'INFO',
-                            msg: `http: ${probe.details || 'ok'}`,
-                        });
-                    }
-                }
-            }
-        }
-        catch (probeError) {
-            // Probe errors are silent - connection attempt will show the real result
-        }
-    }
-    // Step 4: Emit [SYS] CONNECTING...
-    const connectingEvent = {
+        msg: `gateway target source: ${source}`,
+    });
+    // Step 4: Set connecting state in store
+    gatewayConnectionStore.setConnecting(inputTarget, 5000);
+    // Step 5: Emit connecting event
+    events.push({
         id: `sys-connecting-${Date.now()}`,
         ts: Date.now(),
         tag: 'SYS',
         level: 'INFO',
         msg: 'CONNECTING...',
-    };
-    events.push(connectingEvent);
-    // Step 4: Update UiState.network → LOADING (with attemptId in meta)
-    const loadingStateUpdate = (prev) => ({
-        ...prev,
-        network: loading('Connecting to Gateway...', {
-            attemptId: currentAttemptId,
-            target: resolvedTarget,
-            timeout: 5,
-        }),
-        statusStrip: available({
-            left: 'NET: CONNECTING...',
-            right: 'GATEWAY: CONNECTING',
-        }),
     });
-    // Step 5: Await connectAdapter with timeout (always uses canonical URL)
+    // Step 6: Attempt connection
     try {
         const result = await v1Connect();
-        // Step 6: Check if this attempt is still current (prevent stale updates)
-        if (currentAttemptId !== networkAttemptId) {
-            // Stale completion - ignore it
-            return {
-                events: [cmdEvent], // Only emit [CMD], no state update
-            };
-        }
         if (!result.ok) {
-            // Failure: network → UNAVAILABLE
-            // Section 6.2: Map to clear error message
+            // Failure: Update store with error
             const errorCode = result.error.code || 'UNKNOWN';
-            let errorMsg = 'Gateway unreachable';
-            // Map specific error codes to clear messages
-            if (errorCode === 'ECONNREFUSED' || errorCode === 'ETIMEDOUT' || errorCode === 'ECONNABORTED' ||
-                errorCode === 'GATEWAY_TIMEOUT' || errorCode === 'GATEWAY_UNREACHABLE') {
-                errorMsg = 'Gateway unreachable (ECONNREFUSED | ETIMEDOUT | ECONNABORTED)';
-            }
-            else {
-                errorMsg = result.error.message || 'Gateway unreachable';
-            }
+            const errorMsg = result.error.message || 'Gateway unreachable';
+            const nextAction = result.error.nextAction || 'Retry "connect"';
+            gatewayConnectionStore.setError(inputTarget, errorCode, errorMsg, nextAction);
             events.push({
                 id: `err-${Date.now()}`,
                 ts: Date.now(),
@@ -864,34 +795,43 @@ async function handleConnect(ctx, args) {
                 level: 'ERROR',
                 msg: errorMsg,
             });
-            return {
-                events,
-                uiStateUpdate: (prev) => {
-                    // Section 6.2: Always update to UNAVAILABLE on failure
-                    // Check attemptId to prevent stale updates, but don't require LOADING state
-                    // (LOADING state might not have been applied if connection failed very quickly)
-                    const prevAttemptId = isLoading(prev.network) ? prev.network.meta?.attemptId : undefined;
-                    if (prevAttemptId === currentAttemptId || prevAttemptId === undefined) {
-                        return {
-                            ...prev,
-                            network: unavailable('Gateway unreachable', 'Start Gateway service and run "connect"'),
-                            statusStrip: available({
-                                left: 'OFFLINE',
-                                right: 'GATEWAY: UNAVAILABLE',
-                            }),
-                        };
-                    }
-                    return prev; // Stale attempt, don't update
-                },
-            };
+            // Emit store state for debugging
+            const storeState = gatewayConnectionStore.getState();
+            events.push({
+                id: `sys-network-state-${Date.now()}`,
+                ts: Date.now(),
+                tag: 'SYS',
+                level: 'INFO',
+                msg: `network_state=${storeState.status}`,
+            });
+            return { events };
         }
-        // Success: network → AVAILABLE
-        // Verify connection by showing gateway info
-        const connectedEndpoint = result.data.endpoint;
+        // Success: Update store with connection info
+        const effectiveTarget = result.data.endpoint; // The endpoint that actually worked (might be different from input)
         const healthData = result.data.healthData;
         const latency = result.data.latency;
+        gatewayConnectionStore.setConnected(inputTarget, effectiveTarget, healthData, latency);
+        // Show input vs effective target if different
+        if (effectiveTarget !== inputTarget) {
+            events.push({
+                id: `sys-targets-${Date.now()}`,
+                ts: Date.now(),
+                tag: 'SYS',
+                level: 'INFO',
+                msg: `connect: input=${inputTarget} effective=${effectiveTarget}`,
+            });
+        }
+        else {
+            events.push({
+                id: `sys-target-${Date.now()}`,
+                ts: Date.now(),
+                tag: 'SYS',
+                level: 'INFO',
+                msg: `connect: target=${inputTarget}`,
+            });
+        }
         // Show clean connection message
-        const endpointUrl = new URL(connectedEndpoint);
+        const endpointUrl = new URL(effectiveTarget);
         const displayHost = endpointUrl.hostname === '127.0.0.1' ? 'localhost' : endpointUrl.hostname;
         const displayPort = endpointUrl.port || (endpointUrl.protocol === 'https:' ? '443' : '80');
         events.push({
@@ -913,96 +853,213 @@ async function handleConnect(ctx, args) {
                 msg: `Gateway: ${status} | Persistence: ${persistence}${latency ? ` | Latency: ${latency}ms` : ''}`,
             });
         }
-        return {
-            events,
-            uiStateUpdate: (prev) => {
-                // Section 6.2: Always update to AVAILABLE on success
-                // Check attemptId to prevent stale updates, but don't require LOADING state
-                const prevAttemptId = isLoading(prev.network) ? prev.network.meta?.attemptId : undefined;
-                if (prevAttemptId === currentAttemptId || prevAttemptId === undefined) {
-                    // Use the actual endpoint that connected (might be different due to auto-fallback)
-                    const actualEndpoint = result.data.endpoint;
-                    const healthData = result.data.healthData;
-                    const latency = result.data.latency;
-                    return {
-                        ...prev,
-                        network: available({
-                            gateway: 'CONNECTED',
-                            endpoint: actualEndpoint,
-                            status: healthData?.status || 'alive',
-                            latency: latency,
-                        }),
-                        capabilities: available({
-                            items: [], // Empty is allowed for now
-                        }),
-                        statusStrip: available({
-                            left: 'ONLINE',
-                            right: 'GATEWAY: CONNECTED',
-                        }),
-                    };
-                }
-                return prev; // Stale attempt, don't update
-            },
-        };
+        // Emit store state for debugging
+        const storeState = gatewayConnectionStore.getState();
+        events.push({
+            id: `sys-network-state-${Date.now()}`,
+            ts: Date.now(),
+            tag: 'SYS',
+            level: 'INFO',
+            msg: `network_state=${storeState.status}`,
+        });
+        return { events };
     }
     catch (error) {
         // Step 7: Catch-all error handler
-        // Check if this attempt is still current
-        if (currentAttemptId !== networkAttemptId) {
-            // Stale error - ignore it
-            return {
-                events: [cmdEvent],
-            };
-        }
-        // Section 6.2: Map errors to clear error codes
+        const errorMsg = error?.message || 'Connection failed';
         const errorCode = error?.code || 'UNKNOWN';
-        let errorMessage = 'Gateway unreachable';
-        if (errorCode === 'ECONNREFUSED' || errorCode === 'ETIMEDOUT' || errorCode === 'ECONNABORTED') {
-            errorMessage = 'Gateway unreachable (ECONNREFUSED | ETIMEDOUT | ECONNABORTED)';
-        }
-        else if (error?.message) {
-            errorMessage = String(error.message).substring(0, 50).trim();
+        gatewayConnectionStore.setError(inputTarget, errorCode, errorMsg, 'Retry "connect"');
+        events.push({
+            id: `err-${Date.now()}`,
+            ts: Date.now(),
+            tag: 'ERR',
+            level: 'ERROR',
+            msg: errorMsg,
+        });
+        // Emit store state for debugging
+        const storeState = gatewayConnectionStore.getState();
+        events.push({
+            id: `sys-network-state-${Date.now()}`,
+            ts: Date.now(),
+            tag: 'SYS',
+            level: 'INFO',
+            msg: `network_state=${storeState.status}`,
+        });
+        return { events };
+    }
+}
+/**
+ * 4.5️⃣ verify
+ *
+ * Makes real API calls to prove the connection works
+ * Tests: /health, /ready, /api/runs, /metrics
+ */
+async function handleVerify(ctx, args) {
+    const { gatewayConnectionStore } = await import('../state/gatewayConnectionStore.js');
+    const gatewayConfig = await import('../config/gateway.js');
+    const { GatewayClient } = await import('../../../gateway-client.js');
+    const cmdEvent = {
+        id: `cmd-${Date.now()}`,
+        ts: Date.now(),
+        tag: 'CMD',
+        level: 'INFO',
+        msg: 'verify',
+    };
+    const events = [cmdEvent];
+    // Check store state first
+    const storeState = gatewayConnectionStore.getState();
+    if (storeState.status !== 'connected') {
+        events.push({
+            id: `err-${Date.now()}`,
+            ts: Date.now(),
+            tag: 'ERR',
+            level: 'ERROR',
+            msg: `Not connected (status: ${storeState.status}). Run "connect" first.`,
+        });
+        return { events };
+    }
+    const gatewayUrl = gatewayConfig.resolveGatewayUrl();
+    const client = new GatewayClient({ gatewayUrl });
+    events.push({
+        id: `sys-verify-start-${Date.now()}`,
+        ts: Date.now(),
+        tag: 'SYS',
+        level: 'INFO',
+        msg: `Verifying connection to ${storeState.resolvedTo}...`,
+    });
+    // Test 1: Health check
+    try {
+        const startTime = Date.now();
+        const healthResponse = await client.health();
+        const latency = Date.now() - startTime;
+        events.push({
+            id: `ok-health-${Date.now()}`,
+            ts: Date.now(),
+            tag: 'OK',
+            level: 'INFO',
+            msg: `✓ /health: ${healthResponse.status || 'ok'} (${latency}ms)`,
+        });
+        if (healthResponse.persistence) {
+            events.push({
+                id: `sys-persistence-${Date.now()}`,
+                ts: Date.now(),
+                tag: 'SYS',
+                level: 'INFO',
+                msg: `  Persistence: ${healthResponse.persistence}`,
+            });
         }
-        else if (typeof error === 'string') {
-            errorMessage = error.substring(0, 50).trim();
+    }
+    catch (error) {
+        events.push({
+            id: `err-health-${Date.now()}`,
+            ts: Date.now(),
+            tag: 'ERR',
+            level: 'ERROR',
+            msg: `✗ /health failed: ${error.message || 'Unknown error'}`,
+        });
+    }
+    // Test 2: Ready check
+    try {
+        const startTime = Date.now();
+        const readyResponse = await fetch(`${gatewayUrl}/ready`, {
+            method: 'GET',
+            signal: AbortSignal.timeout(5000),
+        });
+        const latency = Date.now() - startTime;
+        const data = await readyResponse.json();
+        events.push({
+            id: `ok-ready-${Date.now()}`,
+            ts: Date.now(),
+            tag: 'OK',
+            level: 'INFO',
+            msg: `✓ /ready: ${data.status || readyResponse.status} (${latency}ms)`,
+        });
+    }
+    catch (error) {
+        events.push({
+            id: `err-ready-${Date.now()}`,
+            ts: Date.now(),
+            tag: 'ERR',
+            level: 'ERROR',
+            msg: `✗ /ready failed: ${error.message || 'Unknown error'}`,
+        });
+    }
+    // Test 3: List runs (requires auth, but tests API endpoint)
+    try {
+        const startTime = Date.now();
+        const runsResponse = await fetch(`${gatewayUrl}/api/runs?limit=1`, {
+            method: 'GET',
+            headers: {
+                'Authorization': `Bearer ${process.env.GATEWAY_TOKEN || ''}`,
+            },
+            signal: AbortSignal.timeout(5000),
+        });
+        const latency = Date.now() - startTime;
+        if (runsResponse.ok) {
+            const data = await runsResponse.json();
+            events.push({
+                id: `ok-runs-${Date.now()}`,
+                ts: Date.now(),
+                tag: 'OK',
+                level: 'INFO',
+                msg: `✓ /api/runs: ${runsResponse.status} (${latency}ms) - ${data.runs?.length || 0} runs`,
+            });
         }
-        if (!errorMessage || errorMessage === 'Error' || errorMessage.trim() === '') {
-            errorMessage = 'Gateway unreachable';
+        else {
+            events.push({
+                id: `warn-runs-${Date.now()}`,
+                ts: Date.now(),
+                tag: 'SYS',
+                level: 'WARN',
+                msg: `⚠ /api/runs: ${runsResponse.status} (${latency}ms) - ${runsResponse.status === 401 ? 'Auth required' : 'Error'}`,
+            });
         }
+    }
+    catch (error) {
         events.push({
-            id: `err-${Date.now()}`,
+            id: `err-runs-${Date.now()}`,
             ts: Date.now(),
             tag: 'ERR',
             level: 'ERROR',
-            msg: errorMessage,
+            msg: `✗ /api/runs failed: ${error.message || 'Unknown error'}`,
+        });
+    }
+    // Test 4: Metrics endpoint
+    try {
+        const startTime = Date.now();
+        const metricsResponse = await fetch(`${gatewayUrl}/metrics`, {
+            method: 'GET',
+            signal: AbortSignal.timeout(5000),
+        });
+        const latency = Date.now() - startTime;
+        const text = await metricsResponse.text();
+        const lines = text.split('\n').filter(l => l.trim() && !l.startsWith('#')).length;
+        events.push({
+            id: `ok-metrics-${Date.now()}`,
+            ts: Date.now(),
+            tag: 'OK',
+            level: 'INFO',
+            msg: `✓ /metrics: ${metricsResponse.status} (${latency}ms) - ${lines} metrics`,
         });
-        return {
-            events,
-            uiStateUpdate: (prev) => {
-                // Section 6.2: Always update to UNAVAILABLE on error
-                // Check attemptId to prevent stale updates, but don't require LOADING state
-                const prevAttemptId = isLoading(prev.network) ? prev.network.meta?.attemptId : undefined;
-                if (prevAttemptId === currentAttemptId || prevAttemptId === undefined) {
-                    return {
-                        ...prev,
-                        network: unavailable('Gateway unreachable', 'Start Gateway service and run "connect"'),
-                        statusStrip: available({
-                            left: 'OFFLINE',
-                            right: 'GATEWAY: UNAVAILABLE',
-                        }),
-                    };
-                }
-                return prev; // Stale attempt, don't update
-            },
-        };
     }
-    finally {
-        // Step 8: Finally block - guarantee network is not LOADING for this attemptId
-        // This is a safety net - if catch already set UNAVAILABLE, this does nothing
-        // But if something went wrong, we ensure LOADING doesn't persist
-        // Note: We can't update state here directly, but we've already handled it above
-        // This is just documentation that LOADING must not survive past command completion
+    catch (error) {
+        events.push({
+            id: `err-metrics-${Date.now()}`,
+            ts: Date.now(),
+            tag: 'ERR',
+            level: 'ERROR',
+            msg: `✗ /metrics failed: ${error.message || 'Unknown error'}`,
+        });
     }
+    // Summary
+    events.push({
+        id: `sys-verify-done-${Date.now()}`,
+        ts: Date.now(),
+        tag: 'SYS',
+        level: 'INFO',
+        msg: 'Verification complete. Connection is working.',
+    });
+    return { events };
 }
 /**
  * 5️⃣ start <agentId>