@ripeseed/rs-tunnel 0.3.0 → 0.4.0

package/dist/commands/up.test.js

@@ -1,6 +1,6 @@
 import { EventEmitter } from 'node:events';
 import { PassThrough } from 'node:stream';
-import { describe, expect, it, vi } from 'vitest';
+import { afterEach, describe, expect, it, vi } from 'vitest';
 import { upCommand } from './up.js';
 import { ApiClientError } from '../lib/api-client.js';
 function createFakeChildProcess() {
@@ -12,6 +12,10 @@ function createFakeChildProcess() {
 }
 function createProcessRef() {
     const listeners = new Map();
+    const stdout = new PassThrough();
+    const stderr = new PassThrough();
+    vi.spyOn(stdout, 'write').mockImplementation(() => true);
+    vi.spyOn(stderr, 'write').mockImplementation(() => true);
     const processRef = {
         once: vi.fn((event, handler) => {
             listeners.set(event, handler);
@@ -24,27 +28,176 @@ function createProcessRef() {
             return processRef;
         }),
         exit: vi.fn(),
-        stderr: {
-            write: vi.fn(),
-        },
+        stderr,
+        stdout,
     };
     return {
         processRef,
         listeners,
     };
 }
+function createRuntimeControllerStub() {
+    const listeners = new Set();
+    const startupSteps = [
+        { id: 'authenticating', label: 'Authenticating...', status: 'pending' },
+        { id: 'reserving-subdomain', label: 'Reserving subdomain...', status: 'pending' },
+        { id: 'connecting-edge', label: 'Connecting edge...', status: 'pending' },
+        { id: 'verifying-local-target', label: 'Verifying local target...', status: 'pending' },
+        { id: 'tunnel-live', label: 'Tunnel live.', status: 'pending' },
+    ];
+    const snapshot = {
+        mode: 'startup',
+        phase: 'initializing',
+        startupSteps,
+        session: {
+            account: null,
+            clientEmail: null,
+            version: '0.3.0',
+            publicUrl: null,
+            localTarget: null,
+            protocol: 'HTTPS',
+            startedAtEpochMs: null,
+            tunnelId: null,
+            requestedSlug: null,
+            hostname: null,
+        },
+        health: {
+            statusLabel: 'Connecting',
+            region: null,
+            lastHeartbeatAtEpochMs: null,
+            cloudflaredConnected: false,
+            telemetryDisabled: false,
+            localTargetReachable: null,
+            lastLocalTargetCheckAtEpochMs: null,
+        },
+        metrics: {
+            ttl: 0,
+            opn: 0,
+            rt1Ms: null,
+            rt5Ms: null,
+            p50Ms: null,
+            p90Ms: null,
+            requestCountTotal: 0,
+        },
+        lastRequest: null,
+        requestLogs: [],
+        cloudflaredLogs: [],
+        notices: [],
+        verbose: false,
+    };
+    const emit = () => {
+        for (const listener of listeners) {
+            listener(snapshot);
+        }
+    };
+    const controller = {
+        setActions: vi.fn((actions) => {
+            controller.actions = actions;
+        }),
+        actions: null,
+        subscribe: vi.fn((listener) => {
+            listeners.add(listener);
+            listener(snapshot);
+            return () => {
+                listeners.delete(listener);
+            };
+        }),
+        getSnapshot: vi.fn(() => snapshot),
+        setStartupStep: vi.fn((stepId, status) => {
+            const step = snapshot.startupSteps.find((item) => item.id === stepId);
+            if (step) {
+                step.status = status;
+            }
+            emit();
+        }),
+        setAllStartupStepsPending: vi.fn(() => {
+            for (const step of snapshot.startupSteps) {
+                step.status = 'pending';
+            }
+            emit();
+        }),
+        setPhase: vi.fn((phase) => {
+            snapshot.phase = phase;
+            emit();
+        }),
+        setStatusLabel: vi.fn((label) => {
+            snapshot.health.statusLabel = label;
+            emit();
+        }),
+        setRegion: vi.fn((region) => {
+            snapshot.health.region = region;
+            emit();
+        }),
+        setCloudflaredConnected: vi.fn((connected) => {
+            snapshot.health.cloudflaredConnected = connected;
+            emit();
+        }),
+        setLocalTargetReachable: vi.fn((reachable, epochMs = Date.now()) => {
+            snapshot.health.localTargetReachable = reachable;
+            snapshot.health.lastLocalTargetCheckAtEpochMs = epochMs;
+            emit();
+        }),
+        setMetrics: vi.fn((metrics) => {
+            snapshot.metrics = {
+                ...metrics,
+                requestCountTotal: snapshot.metrics.requestCountTotal,
+            };
+            emit();
+        }),
+        addRequest: vi.fn((event) => {
+            snapshot.lastRequest = event;
+            snapshot.requestLogs.push(event);
+            snapshot.metrics.requestCountTotal += 1;
+            emit();
+        }),
+        addCloudflaredLine: vi.fn((line) => {
+            snapshot.cloudflaredLogs.push(line);
+            emit();
+        }),
+        setTelemetryDisabled: vi.fn((disabled) => {
+            snapshot.health.telemetryDisabled = disabled;
+            emit();
+        }),
+        recordHeartbeat: vi.fn((epochMs = Date.now()) => {
+            snapshot.health.lastHeartbeatAtEpochMs = epochMs;
+            emit();
+        }),
+        setSession: vi.fn((patch) => {
+            Object.assign(snapshot.session, patch);
+            emit();
+        }),
+        addNotice: vi.fn((level, message) => {
+            snapshot.notices.push({ kind: level, message });
+            emit();
+        }),
+        markLive: vi.fn((epochMs = Date.now()) => {
+            snapshot.phase = 'live';
+            snapshot.mode = snapshot.mode === 'logs' ? 'logs' : 'running';
+            snapshot.session.startedAtEpochMs ??= epochMs;
+            snapshot.health.statusLabel = 'Healthy';
+            emit();
+        }),
+        dispose: vi.fn(),
+    };
+    return controller;
+}
 describe('upCommand', () => {
-    it('ships telemetry with sanitized paths', async () => {
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('ships telemetry with sanitized paths and probes the local target before going live', async () => {
         const child = createFakeChildProcess();
         const proxyStop = vi.fn(async () => { });
-        const dashboard = {
-            setRegion: vi.fn(),
-            setMetrics: vi.fn(),
-            addRequest: vi.fn(),
-            addCloudflaredLine: vi.fn(),
-            addMessage: vi.fn(),
-            stop: vi.fn(),
-        };
+        const controller = createRuntimeControllerStub();
+        const { processRef } = createProcessRef();
+        let onRequest;
+        const startLocalProxy = vi.fn(async (input) => {
+            onRequest = input.onRequest;
+            return {
+                port: 4545,
+                stop: proxyStop,
+            };
+        });
         const apiClient = {
             refreshTokens: vi.fn(),
             createTunnel: vi.fn(async () => ({
@@ -59,22 +212,22 @@ describe('upCommand', () => {
             heartbeat: vi.fn(async () => ({ expiresAt: '2026-01-01T00:00:00.000Z' })),
             ingestTelemetry: vi.fn(async () => { }),
         };
-        const { processRef } = createProcessRef();
-        let proxyInput;
-        const startLocalProxy = vi.fn(async (input) => {
-            proxyInput = input;
-            return {
-                port: 4545,
-                stop: proxyStop,
-            };
-        });
         const intervalCallbacks = [];
         const setIntervalFn = vi.fn((fn, ms) => {
             intervalCallbacks.push({ fn, ms });
             return intervalCallbacks.length;
         });
+        const clearIntervalFn = vi.fn();
+        const openUrl = vi.fn(async () => { });
+        const copyTextToClipboard = vi.fn(async () => { });
+        const verifyLocalTarget = vi.fn(async () => ({
+            ok: true,
+            status: 200,
+            error: null,
+        }));
+        const createApiClient = vi.fn(() => apiClient);
         const runPromise = upCommand({ port: 3000, url: 'demo', verbose: false }, {
-            createApiClient: () => apiClient,
+            createApiClient: createApiClient,
             requireSession: vi.fn(async () => ({
                 accessToken: 'access',
                 refreshToken: 'refresh',
@@ -87,19 +240,41 @@ describe('upCommand', () => {
             })),
             saveSession: vi.fn(async () => { }),
             ensureCloudflaredInstalled: vi.fn(async () => '/usr/local/bin/cloudflared'),
-            startLocalProxy,
-            createUpDashboard: vi.fn(() => dashboard),
-            getCliVersion: vi.fn(() => '0.1.0'),
+            probeLocalTarget: verifyLocalTarget,
+            copyToClipboard: copyTextToClipboard,
+            openUrl,
+            startLocalProxy: startLocalProxy,
+            createUpRuntimeController: vi.fn(() => controller),
+            renderUpApp: vi.fn(() => ({ stop: vi.fn(async () => { }) })),
+            isInteractiveTerminal: vi.fn(() => false),
+            getCliVersion: vi.fn(() => '0.3.0'),
             spawn: vi.fn(() => child),
             processRef: processRef,
             setInterval: setIntervalFn,
-            clearInterval: vi.fn(),
+            clearInterval: clearIntervalFn,
         });
         await new Promise((resolve) => setImmediate(resolve));
-        if (!proxyInput?.onRequest) {
+        expect(startLocalProxy).toHaveBeenCalledWith(expect.objectContaining({
+            targetPort: 3000,
+        }));
+        expect(apiClient.createTunnel).toHaveBeenCalledWith('access', expect.objectContaining({
+            port: 4545,
+            requestedSlug: 'demo',
+        }));
+        expect(verifyLocalTarget).toHaveBeenCalledWith({
+            port: 3000,
+        });
+        expect(controller.setSession).toHaveBeenCalledWith(expect.objectContaining({
+            publicUrl: 'https://demo.tunnel.example.com',
+            localTarget: 'http://localhost:3000',
+            tunnelId: 'tunnel-id',
+            clientEmail: 'osama@example.com',
+        }));
+        const requestHandler = onRequest;
+        if (!requestHandler) {
             throw new Error('Expected onRequest callback to be registered.');
         }
-        proxyInput.onRequest({
+        requestHandler({
             startedAtEpochMs: 1700000000000,
             method: 'GET',
             path: '/foo/bar?token=secret',
@@ -110,7 +285,7 @@ describe('upCommand', () => {
             error: false,
             protocol: 'http',
         });
-        const telemetryInterval = intervalCallbacks.find((interval) => interval.ms === 2000);
+        const telemetryInterval = intervalCallbacks.find((interval) => interval.ms === 2_000);
         if (!telemetryInterval) {
             throw new Error('Expected telemetry interval to be registered.');
         }
@@ -118,23 +293,18 @@ describe('upCommand', () => {
         await new Promise((resolve) => setImmediate(resolve));
         expect(apiClient.ingestTelemetry).toHaveBeenCalledTimes(1);
         const payload = apiClient.ingestTelemetry.mock.calls[0]?.[2];
-        expect(payload.metrics.requests).toBe(1);
-        expect(payload.metrics.errors).toBe(0);
-        expect(payload.metrics.bytes).toBe(42);
         expect(payload.requests[0]?.path).toBe('/foo/bar');
+        expect(controller.addCloudflaredLine).not.toHaveBeenCalled();
         child.emit('exit', 0);
         await runPromise;
+        expect(proxyStop).toHaveBeenCalledTimes(1);
+        expect(apiClient.stopTunnel).toHaveBeenCalledWith('access', 'tunnel-id');
+        expect(clearIntervalFn).toHaveBeenCalled();
     });
-    it('disables telemetry when server does not support it', async () => {
+    it('disables telemetry when the portal rejects it and records a warning notice', async () => {
         const child = createFakeChildProcess();
-        const dashboard = {
-            setRegion: vi.fn(),
-            setMetrics: vi.fn(),
-            addRequest: vi.fn(),
-            addCloudflaredLine: vi.fn(),
-            addMessage: vi.fn(),
-            stop: vi.fn(),
-        };
+        const controller = createRuntimeControllerStub();
+        const { processRef } = createProcessRef();
         const apiClient = {
             refreshTokens: vi.fn(),
             createTunnel: vi.fn(async () => ({
@@ -151,7 +321,6 @@ describe('upCommand', () => {
                 throw new ApiClientError(404, 'NOT_FOUND', 'missing');
             }),
         };
-        const { processRef } = createProcessRef();
         const intervalCallbacks = [];
         const setIntervalFn = vi.fn((fn, ms) => {
             intervalCallbacks.push({ fn, ms });
@@ -159,7 +328,7 @@ describe('upCommand', () => {
         });
         const clearIntervalFn = vi.fn();
         const runPromise = upCommand({ port: 3000, url: 'demo', verbose: false }, {
-            createApiClient: () => apiClient,
+            createApiClient: vi.fn(() => apiClient),
             requireSession: vi.fn(async () => ({
                 accessToken: 'access',
                 refreshToken: 'refresh',
@@ -172,39 +341,48 @@ describe('upCommand', () => {
             })),
             saveSession: vi.fn(async () => { }),
             ensureCloudflaredInstalled: vi.fn(async () => '/usr/local/bin/cloudflared'),
+            probeLocalTarget: vi.fn(async () => ({ ok: true, status: 200, error: null })),
+            copyToClipboard: vi.fn(async () => { }),
+            openUrl: vi.fn(async () => { }),
             startLocalProxy: vi.fn(async () => ({
                 port: 4545,
                 stop: vi.fn(async () => { }),
             })),
-            createUpDashboard: vi.fn(() => dashboard),
-            getCliVersion: vi.fn(() => '0.1.0'),
+            createUpRuntimeController: vi.fn(() => controller),
+            renderUpApp: vi.fn(() => ({ stop: vi.fn(async () => { }) })),
+            isInteractiveTerminal: vi.fn(() => false),
+            getCliVersion: vi.fn(() => '0.3.0'),
             spawn: vi.fn(() => child),
             processRef: processRef,
             setInterval: setIntervalFn,
             clearInterval: clearIntervalFn,
         });
         await new Promise((resolve) => setImmediate(resolve));
-        const telemetryInterval = intervalCallbacks.find((interval) => interval.ms === 2000);
+        const telemetryInterval = intervalCallbacks.find((interval) => interval.ms === 2_000);
         if (!telemetryInterval) {
             throw new Error('Expected telemetry interval to be registered.');
         }
         telemetryInterval.fn();
         await new Promise((resolve) => setImmediate(resolve));
+        expect(controller.setTelemetryDisabled).toHaveBeenCalledWith(true);
+        expect(controller.addNotice).toHaveBeenCalledWith('warning', 'Portal telemetry disabled (server does not support it).');
         expect(clearIntervalFn).toHaveBeenCalled();
-        expect(dashboard.addMessage).toHaveBeenCalledWith(expect.stringMatching(/telemetry disabled/i));
         child.emit('exit', 0);
         await runPromise;
     });
-    it('prints heartbeat API status and code when heartbeat fails', async () => {
+    it('stops cloudflared before stopping the remote tunnel when local target verification fails', async () => {
         const child = createFakeChildProcess();
-        const dashboard = {
-            setRegion: vi.fn(),
-            setMetrics: vi.fn(),
-            addRequest: vi.fn(),
-            addCloudflaredLine: vi.fn(),
-            addMessage: vi.fn(),
-            stop: vi.fn(),
-        };
+        const controller = createRuntimeControllerStub();
+        const proxyStop = vi.fn(async () => { });
+        const { processRef } = createProcessRef();
+        child.kill = vi.fn((signal) => {
+            if (signal === 'SIGTERM' || signal === 'SIGKILL') {
+                setImmediate(() => {
+                    child.emit('exit', signal === 'SIGKILL' ? 137 : 0, signal ?? null);
+                });
+            }
+            return true;
+        });
         const apiClient = {
             refreshTokens: vi.fn(),
             createTunnel: vi.fn(async () => ({
@@ -216,20 +394,11 @@ describe('upCommand', () => {
                 leaseTimeoutSec: 60,
             })),
             stopTunnel: vi.fn(async () => { }),
-            heartbeat: vi.fn(async () => {
-                throw new ApiClientError(500, 'INTERNAL_ERROR', 'Unexpected server error');
-            }),
+            heartbeat: vi.fn(async () => ({ expiresAt: '2026-01-01T00:00:00.000Z' })),
             ingestTelemetry: vi.fn(async () => { }),
         };
-        const { processRef } = createProcessRef();
-        const intervalCallbacks = [];
-        const setIntervalFn = vi.fn((fn, ms) => {
-            intervalCallbacks.push({ fn, ms });
-            return intervalCallbacks.length;
-        });
-        const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
-        const runPromise = upCommand({ port: 3000, url: 'demo', verbose: false }, {
-            createApiClient: () => apiClient,
+        await expect(upCommand({ port: 3000, url: 'demo', verbose: false }, {
+            createApiClient: vi.fn(() => apiClient),
             requireSession: vi.fn(async () => ({
                 accessToken: 'access',
                 refreshToken: 'refresh',
@@ -242,41 +411,35 @@ describe('upCommand', () => {
             })),
             saveSession: vi.fn(async () => { }),
             ensureCloudflaredInstalled: vi.fn(async () => '/usr/local/bin/cloudflared'),
+            probeLocalTarget: vi.fn(async () => ({
+                ok: false,
+                status: null,
+                error: 'Local target did not respond within 5s.',
+            })),
+            copyToClipboard: vi.fn(async () => { }),
+            openUrl: vi.fn(async () => { }),
             startLocalProxy: vi.fn(async () => ({
                 port: 4545,
-                stop: vi.fn(async () => { }),
+                stop: proxyStop,
             })),
-            createUpDashboard: vi.fn(() => dashboard),
-            getCliVersion: vi.fn(() => '0.1.0'),
+            createUpRuntimeController: vi.fn(() => controller),
+            renderUpApp: vi.fn(() => ({ stop: vi.fn(async () => { }) })),
+            isInteractiveTerminal: vi.fn(() => false),
+            getCliVersion: vi.fn(() => '0.3.0'),
             spawn: vi.fn(() => child),
             processRef: processRef,
-            setInterval: setIntervalFn,
+            setInterval: vi.fn(() => 1),
             clearInterval: vi.fn(),
-        });
-        await new Promise((resolve) => setImmediate(resolve));
-        const heartbeatInterval = intervalCallbacks.find((interval) => interval.ms === 20_000);
-        if (!heartbeatInterval) {
-            throw new Error('Expected heartbeat interval to be registered.');
-        }
-        heartbeatInterval.fn();
-        await new Promise((resolve) => setImmediate(resolve));
-        expect(apiClient.heartbeat).toHaveBeenCalledWith('run-token', 'tunnel-id');
-        expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('Heartbeat failed (status=500, code=INTERNAL_ERROR): Unexpected server error'));
-        errorSpy.mockRestore();
-        child.emit('exit', 0);
-        await runPromise;
+        })).rejects.toThrow('Local target did not respond within 5s.');
+        expect(child.kill).toHaveBeenCalledWith('SIGTERM');
+        expect(apiClient.stopTunnel).toHaveBeenCalledWith('access', 'tunnel-id');
+        expect(proxyStop).toHaveBeenCalledTimes(1);
+        expect(child.kill.mock.invocationCallOrder[0]).toBeLessThan(apiClient.stopTunnel.mock.invocationCallOrder[0] ?? Number.POSITIVE_INFINITY);
     });
-    it('creates tunnel using local proxy port and initializes dashboard fields', async () => {
+    it('captures verbose cloudflared lines and derives the region from them', async () => {
         const child = createFakeChildProcess();
-        const proxyStop = vi.fn(async () => { });
-        const dashboard = {
-            setRegion: vi.fn(),
-            setMetrics: vi.fn(),
-            addRequest: vi.fn(),
-            addCloudflaredLine: vi.fn(),
-            addMessage: vi.fn(),
-            stop: vi.fn(),
-        };
+        const controller = createRuntimeControllerStub();
+        const { processRef } = createProcessRef();
         const apiClient = {
             refreshTokens: vi.fn(),
             createTunnel: vi.fn(async () => ({
@@ -289,21 +452,18 @@ describe('upCommand', () => {
             })),
             stopTunnel: vi.fn(async () => { }),
             heartbeat: vi.fn(async () => ({ expiresAt: '2026-01-01T00:00:00.000Z' })),
+            ingestTelemetry: vi.fn(async () => { }),
         };
-        const { processRef } = createProcessRef();
-        const startLocalProxy = vi.fn(async () => ({
-            port: 4545,
-            stop: proxyStop,
-        }));
-        const createUpDashboard = vi.fn(() => dashboard);
         const spawnFn = vi.fn(() => {
             setImmediate(() => {
+                child.stderr.write('location=iad\n');
+                child.stderr.end();
                 child.emit('exit', 0);
             });
             return child;
         });
-        await upCommand({ port: 3000, url: 'demo', verbose: false }, {
-            createApiClient: () => apiClient,
+        const runPromise = upCommand({ port: 3000, verbose: true }, {
+            createApiClient: vi.fn(() => apiClient),
             requireSession: vi.fn(async () => ({
                 accessToken: 'access',
                 refreshToken: 'refresh',
@@ -316,108 +476,30 @@ describe('upCommand', () => {
             })),
             saveSession: vi.fn(async () => { }),
             ensureCloudflaredInstalled: vi.fn(async () => '/usr/local/bin/cloudflared'),
-            startLocalProxy,
-            createUpDashboard,
-            getCliVersion: vi.fn(() => '0.1.0'),
+            probeLocalTarget: vi.fn(async () => ({ ok: true, status: 200, error: null })),
+            copyToClipboard: vi.fn(async () => { }),
+            openUrl: vi.fn(async () => { }),
+            startLocalProxy: vi.fn(async () => ({
+                port: 4545,
+                stop: vi.fn(async () => { }),
+            })),
+            createUpRuntimeController: vi.fn(() => controller),
+            renderUpApp: vi.fn(() => ({ stop: vi.fn(async () => { }) })),
+            isInteractiveTerminal: vi.fn(() => false),
+            getCliVersion: vi.fn(() => '0.3.0'),
             spawn: spawnFn,
             processRef: processRef,
             setInterval: vi.fn(() => 1),
             clearInterval: vi.fn(),
         });
-        expect(startLocalProxy).toHaveBeenCalledWith(expect.objectContaining({
-            targetPort: 3000,
-        }));
-        expect(apiClient.createTunnel).toHaveBeenCalledWith('access', expect.objectContaining({
-            port: 4545,
-            requestedSlug: 'demo',
-        }));
-        expect(createUpDashboard).toHaveBeenCalledWith({
-            account: 'osama@example.com',
-            version: '0.1.0',
-            forwarding: 'https://demo.tunnel.example.com -> http://localhost:3000',
-            verbose: false,
-        });
-        expect(dashboard.setMetrics).toHaveBeenCalled();
-        expect(processRef.exit.mock.calls[0]?.[0]).toBe(0);
-        expect(proxyStop).toHaveBeenCalledTimes(1);
-        expect(apiClient.stopTunnel).toHaveBeenCalledWith('access', 'tunnel-id');
-        expect(spawnFn).toHaveBeenCalled();
-    });
-    it('emits raw cloudflared lines only when verbose mode is enabled', async () => {
-        const runCase = async (verbose) => {
-            const child = createFakeChildProcess();
-            const dashboard = {
-                setRegion: vi.fn(),
-                setMetrics: vi.fn(),
-                addRequest: vi.fn(),
-                addCloudflaredLine: vi.fn(),
-                addMessage: vi.fn(),
-                stop: vi.fn(),
-            };
-            const apiClient = {
-                refreshTokens: vi.fn(),
-                createTunnel: vi.fn(async () => ({
-                    tunnelId: 'tunnel-id',
-                    hostname: 'demo.tunnel.example.com',
-                    cloudflaredToken: 'cf-token',
-                    tunnelRunToken: 'run-token',
-                    heartbeatIntervalSec: 20,
-                    leaseTimeoutSec: 60,
-                })),
-                stopTunnel: vi.fn(async () => { }),
-                heartbeat: vi.fn(async () => ({ expiresAt: '2026-01-01T00:00:00.000Z' })),
-            };
-            const { processRef } = createProcessRef();
-            const spawnFn = vi.fn(() => {
-                setImmediate(() => {
-                    child.stderr.write('location=iad\n');
-                    child.stderr.end();
-                    child.emit('exit', 0);
-                });
-                return child;
-            });
-            await upCommand({ port: 3000, verbose }, {
-                createApiClient: () => apiClient,
-                requireSession: vi.fn(async () => ({
-                    accessToken: 'access',
-                    refreshToken: 'refresh',
-                    expiresAtEpochSec: 1,
-                    profile: {
-                        email: 'osama@example.com',
-                        slackUserId: 'U1',
-                        slackTeamId: 'TRIPESEED',
-                    },
-                })),
-                saveSession: vi.fn(async () => { }),
-                ensureCloudflaredInstalled: vi.fn(async () => '/usr/local/bin/cloudflared'),
-                startLocalProxy: vi.fn(async () => ({
-                    port: 4545,
-                    stop: vi.fn(async () => { }),
-                })),
-                createUpDashboard: vi.fn(() => dashboard),
-                getCliVersion: vi.fn(() => '0.1.0'),
-                spawn: spawnFn,
-                processRef: processRef,
-                setInterval: vi.fn(() => 1),
-                clearInterval: vi.fn(),
-            });
-            expect(dashboard.setRegion).toHaveBeenCalledWith('IAD');
-            return dashboard.addCloudflaredLine.mock.calls.length;
-        };
-        expect(await runCase(false)).toBe(0);
-        expect(await runCase(true)).toBeGreaterThan(0);
+        await runPromise;
+        expect(controller.addCloudflaredLine).toHaveBeenCalledWith('location=iad');
+        expect(controller.setRegion).toHaveBeenCalledWith('IAD');
     });
-    it('cleans up resources and kills child process on SIGINT', async () => {
+    it('reports heartbeat errors', async () => {
         const child = createFakeChildProcess();
-        const proxyStop = vi.fn(async () => { });
-        const dashboard = {
-            setRegion: vi.fn(),
-            setMetrics: vi.fn(),
-            addRequest: vi.fn(),
-            addCloudflaredLine: vi.fn(),
-            addMessage: vi.fn(),
-            stop: vi.fn(),
-        };
+        const controller = createRuntimeControllerStub();
+        const { processRef } = createProcessRef();
         const apiClient = {
             refreshTokens: vi.fn(),
             createTunnel: vi.fn(async () => ({
@@ -429,17 +511,19 @@ describe('upCommand', () => {
                 leaseTimeoutSec: 60,
             })),
             stopTunnel: vi.fn(async () => { }),
-            heartbeat: vi.fn(async () => ({ expiresAt: '2026-01-01T00:00:00.000Z' })),
+            heartbeat: vi.fn(async () => {
+                throw new ApiClientError(500, 'INTERNAL_ERROR', 'Unexpected server error');
+            }),
+            ingestTelemetry: vi.fn(async () => { }),
         };
-        const { processRef, listeners } = createProcessRef();
-        child.kill = vi.fn((signal) => {
-            setImmediate(() => {
-                child.emit('exit', signal === 'SIGINT' ? 130 : 0);
-            });
-            return true;
+        const intervalCallbacks = [];
+        const setIntervalFn = vi.fn((fn, ms) => {
+            intervalCallbacks.push({ fn, ms });
+            return intervalCallbacks.length;
         });
+        const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
         const runPromise = upCommand({ port: 3000, verbose: false }, {
-            createApiClient: () => apiClient,
+            createApiClient: vi.fn(() => apiClient),
             requireSession: vi.fn(async () => ({
                 accessToken: 'access',
                 refreshToken: 'refresh',
@@ -452,41 +536,38 @@ describe('upCommand', () => {
             })),
             saveSession: vi.fn(async () => { }),
             ensureCloudflaredInstalled: vi.fn(async () => '/usr/local/bin/cloudflared'),
+            probeLocalTarget: vi.fn(async () => ({ ok: true, status: 200, error: null })),
+            copyToClipboard: vi.fn(async () => { }),
+            openUrl: vi.fn(async () => { }),
             startLocalProxy: vi.fn(async () => ({
                 port: 4545,
-                stop: proxyStop,
+                stop: vi.fn(async () => { }),
             })),
-            createUpDashboard: vi.fn(() => dashboard),
-            getCliVersion: vi.fn(() => '0.1.0'),
+            createUpRuntimeController: vi.fn(() => controller),
+            renderUpApp: vi.fn(() => ({ stop: vi.fn(async () => { }) })),
+            isInteractiveTerminal: vi.fn(() => false),
+            getCliVersion: vi.fn(() => '0.3.0'),
             spawn: vi.fn(() => child),
             processRef: processRef,
-            setInterval: vi.fn(() => 1),
+            setInterval: setIntervalFn,
             clearInterval: vi.fn(),
         });
         await new Promise((resolve) => setImmediate(resolve));
-        const sigintHandler = listeners.get('SIGINT');
-        if (!sigintHandler) {
-            throw new Error('Expected SIGINT handler to be registered.');
+        const heartbeatInterval = intervalCallbacks.find((interval) => interval.ms === 20_000);
+        if (!heartbeatInterval) {
+            throw new Error('Expected heartbeat interval to be registered.');
         }
-        sigintHandler();
+        heartbeatInterval.fn();
+        await new Promise((resolve) => setImmediate(resolve));
+        expect(apiClient.heartbeat).toHaveBeenCalledWith('run-token', 'tunnel-id');
+        expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('Heartbeat failed (status=500, code=INTERNAL_ERROR): Unexpected server error'));
+        child.emit('exit', 0);
         await runPromise;
-        expect(child.kill).toHaveBeenCalledWith('SIGINT');
-        expect(apiClient.stopTunnel).toHaveBeenCalledTimes(1);
-        expect(child.kill.mock.invocationCallOrder[0] ?? 0).toBeLessThan(apiClient.stopTunnel.mock.invocationCallOrder[0] ?? Number.MAX_SAFE_INTEGER);
-        expect(proxyStop).toHaveBeenCalledTimes(1);
-        expect(dashboard.stop).toHaveBeenCalledTimes(1);
-        expect(processRef.exit.mock.calls[0]?.[0]).toBe(130);
     });
     it('does not overlap heartbeats while one is still in flight', async () => {
         const child = createFakeChildProcess();
-        const dashboard = {
-            setRegion: vi.fn(),
-            setMetrics: vi.fn(),
-            addRequest: vi.fn(),
-            addCloudflaredLine: vi.fn(),
-            addMessage: vi.fn(),
-            stop: vi.fn(),
-        };
+        const controller = createRuntimeControllerStub();
+        const { processRef } = createProcessRef();
         let resolveHeartbeat;
         const heartbeatPromise = new Promise((resolve) => {
             resolveHeartbeat = () => resolve({ expiresAt: '2026-01-01T00:00:00.000Z' });
@@ -505,14 +586,13 @@ describe('upCommand', () => {
             heartbeat: vi.fn(() => heartbeatPromise),
             ingestTelemetry: vi.fn(async () => { }),
         };
-        const { processRef } = createProcessRef();
         const intervalCallbacks = [];
         const setIntervalFn = vi.fn((fn, ms) => {
             intervalCallbacks.push({ fn, ms });
             return intervalCallbacks.length;
         });
         const runPromise = upCommand({ port: 3000, verbose: false }, {
-            createApiClient: () => apiClient,
+            createApiClient: vi.fn(() => apiClient),
             requireSession: vi.fn(async () => ({
                 accessToken: 'access',
                 refreshToken: 'refresh',
@@ -525,12 +605,17 @@ describe('upCommand', () => {
             })),
             saveSession: vi.fn(async () => { }),
             ensureCloudflaredInstalled: vi.fn(async () => '/usr/local/bin/cloudflared'),
+            probeLocalTarget: vi.fn(async () => ({ ok: true, status: 200, error: null })),
+            copyToClipboard: vi.fn(async () => { }),
+            openUrl: vi.fn(async () => { }),
             startLocalProxy: vi.fn(async () => ({
                 port: 4545,
                 stop: vi.fn(async () => { }),
             })),
-            createUpDashboard: vi.fn(() => dashboard),
-            getCliVersion: vi.fn(() => '0.1.0'),
+            createUpRuntimeController: vi.fn(() => controller),
+            renderUpApp: vi.fn(() => ({ stop: vi.fn(async () => { }) })),
+            isInteractiveTerminal: vi.fn(() => false),
+            getCliVersion: vi.fn(() => '0.3.0'),
             spawn: vi.fn(() => child),
             processRef: processRef,
             setInterval: setIntervalFn,
@@ -555,5 +640,276 @@ describe('upCommand', () => {
         child.emit('exit', 0);
         await runPromise;
     });
+    it('routes shortcuts through controller actions and restarts only cloudflared', async () => {
+        const child1 = createFakeChildProcess();
+        const child2 = createFakeChildProcess();
+        const controller = createRuntimeControllerStub();
+        const { processRef } = createProcessRef();
+        const openUrl = vi.fn(async () => { });
+        const copyTextToClipboard = vi.fn(async () => { });
+        const proxyStop = vi.fn(async () => { });
+        child1.kill = vi.fn((signal) => {
+            setImmediate(() => {
+                child1.emit('exit', signal === 'SIGINT' ? 130 : 0);
+            });
+            return true;
+        });
+        child2.kill = vi.fn((signal) => {
+            setImmediate(() => {
+                child2.emit('exit', signal === 'SIGINT' ? 130 : 0);
+            });
+            return true;
+        });
+        const apiClient = {
+            refreshTokens: vi.fn(),
+            createTunnel: vi.fn(async () => ({
+                tunnelId: 'tunnel-id',
+                hostname: 'demo.tunnel.example.com',
+                cloudflaredToken: 'cf-token',
+                tunnelRunToken: 'run-token',
+                heartbeatIntervalSec: 20,
+                leaseTimeoutSec: 60,
+            })),
+            stopTunnel: vi.fn(async () => { }),
+            heartbeat: vi.fn(async () => ({ expiresAt: '2026-01-01T00:00:00.000Z' })),
+            ingestTelemetry: vi.fn(async () => { }),
+        };
+        const spawnFn = vi.fn()
+            .mockImplementationOnce(() => child1)
+            .mockImplementationOnce(() => child2);
+        const runPromise = upCommand({ port: 3000, url: 'demo', verbose: false }, {
+            createApiClient: vi.fn(() => apiClient),
+            requireSession: vi.fn(async () => ({
+                accessToken: 'access',
+                refreshToken: 'refresh',
+                expiresAtEpochSec: 1,
+                profile: {
+                    email: 'osama@example.com',
+                    slackUserId: 'U1',
+                    slackTeamId: 'TRIPESEED',
+                },
+            })),
+            saveSession: vi.fn(async () => { }),
+            ensureCloudflaredInstalled: vi.fn(async () => '/usr/local/bin/cloudflared'),
+            probeLocalTarget: vi.fn(async () => ({ ok: true, status: 200, error: null })),
+            copyToClipboard: copyTextToClipboard,
+            openUrl,
+            startLocalProxy: vi.fn(async () => ({
+                port: 4545,
+                stop: proxyStop,
+            })),
+            createUpRuntimeController: vi.fn(() => controller),
+            renderUpApp: vi.fn(() => ({ stop: vi.fn(async () => { }) })),
+            isInteractiveTerminal: vi.fn(() => false),
+            getCliVersion: vi.fn(() => '0.3.0'),
+            spawn: spawnFn,
+            processRef: processRef,
+            setInterval: vi.fn(() => 1),
+            clearInterval: vi.fn(),
+        });
+        await new Promise((resolve) => setImmediate(resolve));
+        if (!controller.actions) {
+            throw new Error('Expected controller actions to be registered.');
+        }
+        await controller.actions.openBrowser();
+        await controller.actions.copyUrl();
+        expect(openUrl).toHaveBeenCalledWith('https://demo.tunnel.example.com');
+        expect(copyTextToClipboard).toHaveBeenCalledWith('https://demo.tunnel.example.com');
+        const restartPromise = controller.actions.restartCloudflared();
+        await new Promise((resolve) => setImmediate(resolve));
+        await restartPromise;
+        await new Promise((resolve) => setImmediate(resolve));
+        expect(child1.kill).toHaveBeenCalledWith('SIGTERM');
+        expect(apiClient.createTunnel).toHaveBeenCalledTimes(1);
+        expect(spawnFn).toHaveBeenCalledTimes(2);
+        expect(spawnFn.mock.calls[0]?.[1]).toEqual(['tunnel', '--no-autoupdate', 'run', '--token', 'cf-token']);
+        expect(spawnFn.mock.calls[1]?.[1]).toEqual(['tunnel', '--no-autoupdate', 'run', '--token', 'cf-token']);
+        child2.emit('exit', 0);
+        await runPromise;
+        expect(proxyStop).toHaveBeenCalledTimes(1);
+    });
+    it('cleans up resources and exits on SIGINT', async () => {
+        const child = createFakeChildProcess();
+        const controller = createRuntimeControllerStub();
+        const proxyStop = vi.fn(async () => { });
+        const { processRef, listeners } = createProcessRef();
+        child.kill = vi.fn((signal) => {
+            setImmediate(() => {
+                child.emit('exit', signal === 'SIGINT' ? 130 : 0);
+            });
+            return true;
+        });
+        const apiClient = {
+            refreshTokens: vi.fn(),
+            createTunnel: vi.fn(async () => ({
+                tunnelId: 'tunnel-id',
+                hostname: 'demo.tunnel.example.com',
+                cloudflaredToken: 'cf-token',
+                tunnelRunToken: 'run-token',
+                heartbeatIntervalSec: 20,
+                leaseTimeoutSec: 60,
+            })),
+            stopTunnel: vi.fn(async () => { }),
+            heartbeat: vi.fn(async () => ({ expiresAt: '2026-01-01T00:00:00.000Z' })),
+            ingestTelemetry: vi.fn(async () => { }),
+        };
+        const runPromise = upCommand({ port: 3000, verbose: false }, {
+            createApiClient: vi.fn(() => apiClient),
+            requireSession: vi.fn(async () => ({
+                accessToken: 'access',
+                refreshToken: 'refresh',
+                expiresAtEpochSec: 1,
+                profile: {
+                    email: 'osama@example.com',
+                    slackUserId: 'U1',
+                    slackTeamId: 'TRIPESEED',
+                },
+            })),
+            saveSession: vi.fn(async () => { }),
+            ensureCloudflaredInstalled: vi.fn(async () => '/usr/local/bin/cloudflared'),
+            probeLocalTarget: vi.fn(async () => ({ ok: true, status: 200, error: null })),
+            copyToClipboard: vi.fn(async () => { }),
+            openUrl: vi.fn(async () => { }),
+            startLocalProxy: vi.fn(async () => ({
+                port: 4545,
+                stop: proxyStop,
+            })),
+            createUpRuntimeController: vi.fn(() => controller),
+            renderUpApp: vi.fn(() => ({ stop: vi.fn(async () => { }) })),
+            isInteractiveTerminal: vi.fn(() => false),
+            getCliVersion: vi.fn(() => '0.3.0'),
+            spawn: vi.fn(() => child),
+            processRef: processRef,
+            setInterval: vi.fn(() => 1),
+            clearInterval: vi.fn(),
+        });
+        await new Promise((resolve) => setImmediate(resolve));
+        const sigintHandler = listeners.get('SIGINT');
+        if (!sigintHandler) {
+            throw new Error('Expected SIGINT handler to be registered.');
+        }
+        sigintHandler();
+        await runPromise;
+        expect(child.kill).toHaveBeenCalledWith('SIGINT');
+        expect(apiClient.stopTunnel).toHaveBeenCalledWith('access', 'tunnel-id');
+        expect(proxyStop).toHaveBeenCalledTimes(1);
+        expect(processRef.exit.mock.calls[0]?.[0]).toBe(130);
+    });
+    it('treats quit as a shutdown request before cloudflared starts', async () => {
+        let resolveProxyStart;
+        const proxyStop = vi.fn(async () => { });
+        const controller = createRuntimeControllerStub();
+        const { processRef } = createProcessRef();
+        const runPromise = upCommand({ port: 3000, verbose: false }, {
+            createApiClient: vi.fn(() => ({
+                refreshTokens: vi.fn(),
+                createTunnel: vi.fn(async () => ({
+                    tunnelId: 'tunnel-id',
+                    hostname: 'demo.tunnel.example.com',
+                    cloudflaredToken: 'cf-token',
+                    tunnelRunToken: 'run-token',
+                    heartbeatIntervalSec: 20,
+                    leaseTimeoutSec: 60,
+                })),
+                stopTunnel: vi.fn(async () => { }),
+                heartbeat: vi.fn(async () => ({ expiresAt: '2026-01-01T00:00:00.000Z' })),
+                ingestTelemetry: vi.fn(async () => { }),
+            })),
+            requireSession: vi.fn(async () => ({
+                accessToken: 'access',
+                refreshToken: 'refresh',
+                expiresAtEpochSec: 1,
+                profile: {
+                    email: 'osama@example.com',
+                    slackUserId: 'U1',
+                    slackTeamId: 'TRIPESEED',
+                },
+            })),
+            saveSession: vi.fn(async () => { }),
+            ensureCloudflaredInstalled: vi.fn(async () => '/usr/local/bin/cloudflared'),
+            probeLocalTarget: vi.fn(async () => ({ ok: true, status: 200, error: null })),
+            copyToClipboard: vi.fn(async () => { }),
+            openUrl: vi.fn(async () => { }),
+            startLocalProxy: vi.fn(() => new Promise((resolve) => {
+                resolveProxyStart = resolve;
+            })),
+            createUpRuntimeController: vi.fn(() => controller),
+            renderUpApp: vi.fn(() => ({ stop: vi.fn(async () => { }) })),
+            isInteractiveTerminal: vi.fn(() => false),
+            getCliVersion: vi.fn(() => '0.3.0'),
+            spawn: vi.fn(),
+            processRef: processRef,
+            setInterval: vi.fn(() => 1),
+            clearInterval: vi.fn(),
+        });
+        await new Promise((resolve) => setImmediate(resolve));
+        if (!controller.actions) {
+            throw new Error('Expected controller actions to be registered.');
+        }
+        expect(() => controller.actions?.quit()).not.toThrow();
+        if (!resolveProxyStart) {
+            throw new Error('Expected local proxy startup to be pending.');
+        }
+        resolveProxyStart({
+            port: 4545,
+            stop: proxyStop,
+        });
+        await runPromise;
+        expect(proxyStop).toHaveBeenCalledTimes(1);
+        expect(processRef.exit.mock.calls[0]?.[0]).toBe(130);
+    });
+    it('bypasses Ink rendering in non-interactive terminals', async () => {
+        const child = createFakeChildProcess();
+        const controller = createRuntimeControllerStub();
+        const renderUpApp = vi.fn(() => ({ stop: vi.fn(async () => { }) }));
+        const proxyStop = vi.fn(async () => { });
+        const runPromise = upCommand({ port: 3000, verbose: false }, {
+            createApiClient: vi.fn(() => ({
+                refreshTokens: vi.fn(),
+                createTunnel: vi.fn(async () => ({
+                    tunnelId: 'tunnel-id',
+                    hostname: 'demo.tunnel.example.com',
+                    cloudflaredToken: 'cf-token',
+                    tunnelRunToken: 'run-token',
+                    heartbeatIntervalSec: 20,
+                    leaseTimeoutSec: 60,
+                })),
+                stopTunnel: vi.fn(async () => { }),
+                heartbeat: vi.fn(async () => ({ expiresAt: '2026-01-01T00:00:00.000Z' })),
+                ingestTelemetry: vi.fn(async () => { }),
+            })),
+            requireSession: vi.fn(async () => ({
+                accessToken: 'access',
+                refreshToken: 'refresh',
+                expiresAtEpochSec: 1,
+                profile: {
+                    email: 'osama@example.com',
+                    slackUserId: 'U1',
+                    slackTeamId: 'TRIPESEED',
+                },
+            })),
+            saveSession: vi.fn(async () => { }),
+            ensureCloudflaredInstalled: vi.fn(async () => '/usr/local/bin/cloudflared'),
+            probeLocalTarget: vi.fn(async () => ({ ok: true, status: 200, error: null })),
+            copyToClipboard: vi.fn(async () => { }),
+            openUrl: vi.fn(async () => { }),
+            startLocalProxy: vi.fn(async () => ({
+                port: 4545,
+                stop: proxyStop,
+            })),
+            createUpRuntimeController: vi.fn(() => controller),
+            renderUpApp,
+            isInteractiveTerminal: vi.fn(() => false),
+            getCliVersion: vi.fn(() => '0.3.0'),
+            spawn: vi.fn(() => child),
+            processRef: createProcessRef().processRef,
+            setInterval: vi.fn(() => 1),
+            clearInterval: vi.fn(),
+        });
+        await new Promise((resolve) => setImmediate(resolve));
+        expect(renderUpApp).not.toHaveBeenCalled();
+        child.emit('exit', 0);
+        await runPromise;
+    });
 });
 //# sourceMappingURL=up.test.js.map