mstro-app 0.4.51 → 0.5.0

package/server/cli/retry/retry-recovery-strategies.ts

@@ -0,0 +1,247 @@
+// Copyright (c) 2025-present Mstro, Inc. All rights reserved.
+// Licensed under the MIT License. See LICENSE file for details.
+
+/**
+ * Recovery strategies: context-loss (inter-movement / native-timeout),
+ * tool-timeout checkpoint retry, and signal-crash retry. Each `shouldRetry*`
+ * or `apply*Retry` function returns true when the retry loop should loop.
+ */
+
+import { AnalyticsEvents, trackEvent } from '../../services/analytics.js';
+import type { ExecutionCheckpoint } from '../headless/types.js';
+import type { HeadlessRunResult, MovementRecord, RetryLoopState } from '../improvisation-types.js';
+import {
+  buildContextRecoveryPrompt,
+  buildFreshRecoveryPrompt,
+  buildInterMovementRecoveryPrompt,
+  buildResumeRetryPrompt,
+  buildRetryPrompt,
+  buildSignalCrashRecoveryPrompt,
+  extractHistoricalToolResults,
+} from '../prompt-builders.js';
+import { accumulateToolResults } from './retry-tool-results.js';
+import type { RetryCallbacks, RetrySessionState } from './retry-types.js';
+
+// ── Context-loss recovery ────────────────────────────────────
+
+/** Handle inter-movement context loss recovery (resume session expired) */
+export function applyInterMovementRecovery(
+  state: RetryLoopState,
+  promptWithAttachments: string,
+  history: MovementRecord[],
+  callbacks: RetryCallbacks,
+): void {
+  const historicalResults = extractHistoricalToolResults(history);
+  const allResults = [...historicalResults, ...state.accumulatedToolResults];
+
+  callbacks.emit('onAutoRetry', {
+    retryNumber: state.retryNumber,
+    maxRetries: 3,
+    toolName: 'InterMovementRecovery',
+    completedCount: allResults.length,
+  });
+  callbacks.queueOutput(
+    `\n[[MSTRO_CONTEXT_RECOVERY]] Session context expired — continuing with ${allResults.length} preserved results from prior work (retry ${state.retryNumber}/3).\n`
+  );
+  callbacks.flushOutputQueue();
+
+  state.freshRecoveryMode = true;
+  state.currentPrompt = buildInterMovementRecoveryPrompt(promptWithAttachments, allResults, history);
+}
+
+/** Handle native-timeout context loss recovery (tool timeouts caused confusion) */
+export function applyNativeTimeoutRecovery(
+  result: HeadlessRunResult,
+  state: RetryLoopState,
+  promptWithAttachments: string,
+  session: RetrySessionState,
+  callbacks: RetryCallbacks,
+): void {
+  const completedCount = state.accumulatedToolResults.length;
+
+  callbacks.emit('onAutoRetry', {
+    retryNumber: state.retryNumber,
+    maxRetries: 3,
+    toolName: 'ContextRecovery',
+    completedCount,
+  });
+
+  if (result.claudeSessionId && state.retryNumber === 1) {
+    callbacks.queueOutput(
+      `\n[[MSTRO_CONTEXT_RECOVERY]] Context loss detected — resuming session with ${completedCount} preserved results (retry ${state.retryNumber}/3).\n`
+    );
+    callbacks.flushOutputQueue();
+    state.contextRecoverySessionId = result.claudeSessionId;
+    session.claudeSessionId = result.claudeSessionId;
+    state.currentPrompt = buildContextRecoveryPrompt(promptWithAttachments);
+  } else {
+    callbacks.queueOutput(
+      `\n[[MSTRO_CONTEXT_RECOVERY]] Continuing with fresh context — ${completedCount} preserved results injected (retry ${state.retryNumber}/3).\n`
+    );
+    callbacks.flushOutputQueue();
+    state.freshRecoveryMode = true;
+    state.currentPrompt = buildFreshRecoveryPrompt(promptWithAttachments, state.accumulatedToolResults, state.timedOutTools);
+  }
+}
+
+/** Check if context loss recovery should trigger. Returns true if loop should continue. */
+export function shouldRetryContextLoss(
+  result: HeadlessRunResult,
+  state: RetryLoopState,
+  session: RetrySessionState,
+  useResume: boolean,
+  nativeTimeouts: number,
+  maxRetries: number,
+  promptWithAttachments: string,
+  callbacks: RetryCallbacks,
+): boolean {
+  if (state.checkpointRef.value || state.retryNumber >= maxRetries || !state.contextLost) {
+    return false;
+  }
+  accumulateToolResults(result, state);
+  state.retryNumber++;
+  const path = (useResume && nativeTimeouts === 0) ? 'InterMovementRecovery' : 'NativeTimeoutRecovery';
+  state.retryLog.push({
+    retryNumber: state.retryNumber,
+    path,
+    reason: `Context lost (${nativeTimeouts} timeouts, ${state.accumulatedToolResults.length} tools preserved)`,
+    timestamp: Date.now(),
+  });
+  if (useResume && nativeTimeouts === 0) {
+    applyInterMovementRecovery(state, promptWithAttachments, session.history.movements, callbacks);
+  } else {
+    applyNativeTimeoutRecovery(result, state, promptWithAttachments, session, callbacks);
+  }
+  return true;
+}
+
+// ── Tool-timeout retry ───────────────────────────────────────
+
+/** Handle tool timeout checkpoint. Returns true if loop should continue. */
+export function applyToolTimeoutRetry(
+  state: RetryLoopState,
+  maxRetries: number,
+  promptWithAttachments: string,
+  callbacks: RetryCallbacks,
+  model: string | undefined,
+  effortLevel: string | undefined,
+): boolean {
+  if (!state.checkpointRef.value || state.retryNumber >= maxRetries) {
+    return false;
+  }
+
+  const cp: ExecutionCheckpoint = state.checkpointRef.value;
+  state.retryNumber++;
+
+  state.timedOutTools.push({
+    toolName: cp.hungTool.toolName,
+    input: cp.hungTool.input ?? {},
+    timeoutMs: cp.hungTool.timeoutMs,
+  });
+
+  const canResumeSession = cp.inProgressTools.length === 0 && !!cp.claudeSessionId;
+  state.retryLog.push({
+    retryNumber: state.retryNumber,
+    path: 'ToolTimeout',
+    reason: `${cp.hungTool.toolName} timed out after ${cp.hungTool.timeoutMs}ms, ${cp.completedTools.length} tools completed, ${canResumeSession ? 'resuming' : 'fresh start'}`,
+    timestamp: Date.now(),
+  });
+  callbacks.emit('onAutoRetry', {
+    retryNumber: state.retryNumber,
+    maxRetries,
+    toolName: cp.hungTool.toolName,
+    url: cp.hungTool.url,
+    completedCount: cp.completedTools.length,
+  });
+
+  trackEvent(AnalyticsEvents.IMPROVISE_AUTO_RETRY, {
+    retry_number: state.retryNumber,
+    hung_tool: cp.hungTool.toolName,
+    hung_url: cp.hungTool.url?.slice(0, 200),
+    completed_tools: cp.completedTools.length,
+    elapsed_ms: cp.elapsedMs,
+    resume_attempted: canResumeSession,
+    model: model || 'default',
+    effort_level: effortLevel || 'auto',
+  });
+
+  state.currentPrompt = canResumeSession
+    ? buildResumeRetryPrompt(cp, state.timedOutTools)
+    : buildRetryPrompt(cp, promptWithAttachments, state.timedOutTools);
+
+  callbacks.queueOutput(
+    `\n[[MSTRO_AUTO_RETRY]] Auto-retry ${state.retryNumber}/${maxRetries}: ${canResumeSession ? 'Resuming session' : 'Continuing'} with ${cp.completedTools.length} successful results, skipping failed ${cp.hungTool.toolName}.\n`
+  );
+  callbacks.flushOutputQueue();
+
+  return true;
+}
+
+// ── Signal-crash retry ───────────────────────────────────────
+
+/** Detect and retry after a signal crash. Returns true if loop should continue. */
+export function shouldRetrySignalCrash(
+  result: HeadlessRunResult,
+  state: RetryLoopState,
+  session: RetrySessionState,
+  maxRetries: number,
+  promptWithAttachments: string,
+  callbacks: RetryCallbacks,
+): boolean {
+  const isSignalCrash = !!result.signalName;
+  const exitCodeSignal = !result.completed && !result.signalName && result.error?.match(/exited with code (1[2-9]\d|[2-9]\d{2})/);
+  if ((!isSignalCrash && !exitCodeSignal) || state.retryNumber >= maxRetries) {
+    return false;
+  }
+  if (state.checkpointRef.value) {
+    return false;
+  }
+
+  accumulateToolResults(result, state);
+  state.retryNumber++;
+
+  const completedCount = state.accumulatedToolResults.length;
+  const signalInfo = result.signalName || 'unknown signal';
+  const useResume = !!result.claudeSessionId && state.retryNumber === 1;
+
+  state.retryLog.push({
+    retryNumber: state.retryNumber,
+    path: 'SignalCrash',
+    reason: `Process killed (${signalInfo}), ${completedCount} tools preserved, ${useResume ? 'resuming' : 'fresh start'}`,
+    timestamp: Date.now(),
+  });
+
+  callbacks.emit('onAutoRetry', {
+    retryNumber: state.retryNumber,
+    maxRetries,
+    toolName: `SignalCrash(${signalInfo})`,
+    completedCount,
+  });
+
+  trackEvent(AnalyticsEvents.IMPROVISE_AUTO_RETRY, {
+    retry_number: state.retryNumber,
+    hung_tool: `signal_crash:${signalInfo}`,
+    completed_tools: completedCount,
+    resume_attempted: useResume,
+  });
+
+  if (useResume) {
+    callbacks.queueOutput(
+      `\n[[MSTRO_SIGNAL_RECOVERY]] Process killed (${signalInfo}) — resuming session with ${completedCount} preserved results (retry ${state.retryNumber}/${maxRetries}).\n`
+    );
+    callbacks.flushOutputQueue();
+    state.contextRecoverySessionId = result.claudeSessionId;
+    session.claudeSessionId = result.claudeSessionId;
+    state.currentPrompt = buildSignalCrashRecoveryPrompt(promptWithAttachments, true);
+  } else {
+    callbacks.queueOutput(
+      `\n[[MSTRO_SIGNAL_RECOVERY]] Process killed (${signalInfo}) — restarting with ${completedCount} preserved results (retry ${state.retryNumber}/${maxRetries}).\n`
+    );
+    callbacks.flushOutputQueue();
+    state.freshRecoveryMode = true;
+    const allResults = [...extractHistoricalToolResults(session.history.movements), ...state.accumulatedToolResults];
+    state.currentPrompt = buildSignalCrashRecoveryPrompt(promptWithAttachments, false, allResults);
+  }
+
+  return true;
+}

package/server/cli/retry/retry-resume-strategy.ts

@@ -0,0 +1,33 @@
+// Copyright (c) 2025-present Mstro, Inc. All rights reserved.
+// Licensed under the MIT License. See LICENSE file for details.
+
+/**
+ * Picks how the next retry iteration should resume execution:
+ * whether to pass `--resume`, and which Claude session ID (if any) to use.
+ */
+
+import type { RetryLoopState } from '../improvisation-types.js';
+import type { RetrySessionState } from './retry-types.js';
+
+/** Determine whether to use --resume and which session ID */
+export function determineResumeStrategy(
+  state: RetryLoopState,
+  session: RetrySessionState,
+): { useResume: boolean; resumeSessionId: string | undefined } {
+  if (state.freshRecoveryMode) {
+    state.freshRecoveryMode = false;
+    return { useResume: false, resumeSessionId: undefined };
+  }
+  if (state.contextRecoverySessionId) {
+    const id = state.contextRecoverySessionId;
+    state.contextRecoverySessionId = undefined;
+    return { useResume: true, resumeSessionId: id };
+  }
+  if (state.retryNumber === 0) {
+    return { useResume: !session.isFirstPrompt, resumeSessionId: session.claudeSessionId };
+  }
+  if (state.lastWatchdogCheckpoint?.inProgressTools.length === 0 && state.lastWatchdogCheckpoint.claudeSessionId) {
+    return { useResume: true, resumeSessionId: state.lastWatchdogCheckpoint.claudeSessionId };
+  }
+  return { useResume: false, resumeSessionId: undefined };
+}

package/server/cli/retry/retry-runner-factory.ts

@@ -0,0 +1,70 @@
+// Copyright (c) 2025-present Mstro, Inc. All rights reserved.
+// Licensed under the MIT License. See LICENSE file for details.
+
+/**
+ * Factory for the HeadlessRunner used in a single retry iteration.
+ * Wires session options into HeadlessRunner callbacks that respect the
+ * shared cancel flag and forward streaming events via `callbacks`.
+ */
+
+import { HeadlessRunner } from '../headless/index.js';
+import type { ExecutionCheckpoint } from '../headless/types.js';
+import type { FileAttachment, RetryLoopState } from '../improvisation-types.js';
+import { buildHistoricalContext } from '../prompt-builders.js';
+import type { RetryCallbacks, RetrySessionState } from './retry-types.js';
+
+/** Create HeadlessRunner for one retry iteration */
+export function createExecutionRunner(
+  state: RetryLoopState,
+  session: RetrySessionState,
+  callbacks: RetryCallbacks,
+  sequenceNumber: number,
+  useResume: boolean,
+  resumeSessionId: string | undefined,
+  imageAttachments: FileAttachment[] | undefined,
+  workingDirOverride?: string,
+): HeadlessRunner {
+  return new HeadlessRunner({
+    workingDir: workingDirOverride || session.options.workingDir,
+    tokenBudgetThreshold: session.options.tokenBudgetThreshold,
+    maxSessions: session.options.maxSessions,
+    verbose: session.options.verbose,
+    noColor: session.options.noColor,
+    model: session.options.model,
+    effortLevel: session.options.effortLevel,
+    improvisationMode: true,
+    movementNumber: sequenceNumber,
+    continueSession: useResume,
+    claudeSessionId: resumeSessionId,
+    outputCallback: (text: string) => {
+      if (callbacks.isCancelled()) return;
+      callbacks.addEventLog({ type: 'output', data: { text, timestamp: Date.now() }, timestamp: Date.now() });
+      callbacks.queueOutput(text);
+      callbacks.flushOutputQueue();
+    },
+    thinkingCallback: (text: string) => {
+      if (callbacks.isCancelled()) return;
+      callbacks.addEventLog({ type: 'thinking', data: { text }, timestamp: Date.now() });
+      callbacks.emit('onThinking', text);
+      callbacks.flushOutputQueue();
+    },
+    toolUseCallback: (event) => {
+      if (callbacks.isCancelled()) return;
+      callbacks.addEventLog({ type: 'toolUse', data: { ...event, timestamp: Date.now() }, timestamp: Date.now() });
+      callbacks.emit('onToolUse', event);
+      callbacks.flushOutputQueue();
+    },
+    tokenUsageCallback: (usage) => {
+      if (callbacks.isCancelled()) return;
+      callbacks.emit('onTokenUsage', usage);
+    },
+    directPrompt: state.currentPrompt,
+    imageAttachments,
+    promptContext: (state.retryNumber === 0 && session.isResumedSession && session.isFirstPrompt)
+      ? { accumulatedKnowledge: buildHistoricalContext(session.history.movements), filesModified: [] }
+      : undefined,
+    onToolTimeout: (checkpoint: ExecutionCheckpoint) => {
+      state.checkpointRef.value = checkpoint;
+    },
+  });
+}

package/server/cli/retry/retry-tool-results.ts

@@ -0,0 +1,31 @@
+// Copyright (c) 2025-present Mstro, Inc. All rights reserved.
+// Licensed under the MIT License. See LICENSE file for details.
+
+/**
+ * Running buffer of tool results preserved across retries so recovery
+ * prompts can re-inject completed work instead of redoing it.
+ */
+
+import type { HeadlessRunResult, RetryLoopState } from '../improvisation-types.js';
+
+export const MAX_ACCUMULATED_RESULTS = 50;
+
+/** Accumulate completed tool results from a run into the retry state */
+export function accumulateToolResults(result: HeadlessRunResult, state: RetryLoopState): void {
+  if (!result.toolUseHistory) return;
+  for (const t of result.toolUseHistory) {
+    if (t.result !== undefined) {
+      state.accumulatedToolResults.push({
+        toolName: t.toolName,
+        toolId: t.toolId,
+        toolInput: t.toolInput,
+        result: t.result,
+        isError: t.isError,
+        duration: t.duration,
+      });
+    }
+  }
+  if (state.accumulatedToolResults.length > MAX_ACCUMULATED_RESULTS) {
+    state.accumulatedToolResults = state.accumulatedToolResults.slice(-MAX_ACCUMULATED_RESULTS);
+  }
+}

package/server/cli/retry/retry-types.ts

@@ -0,0 +1,32 @@
+// Copyright (c) 2025-present Mstro, Inc. All rights reserved.
+// Licensed under the MIT License. See LICENSE file for details.
+
+/**
+ * Shared types used across the retry modules. Defined separately so each
+ * strategy file can import them without creating circular dependencies.
+ */
+
+import type { HeadlessRunner } from '../headless/index.js';
+import type { ImprovisationOptions, SessionHistory } from '../improvisation-types.js';
+
+/** Callbacks the retry logic needs from the session manager */
+export interface RetryCallbacks {
+  isCancelled: () => boolean;
+  queueOutput: (text: string) => void;
+  flushOutputQueue: () => void;
+  emit: (event: string, ...args: unknown[]) => void;
+  addEventLog: (entry: { type: string; data: unknown; timestamp: number }) => void;
+  setRunner: (runner: HeadlessRunner | null) => void;
+}
+
+/** Session state the retry logic reads/writes */
+export interface RetrySessionState {
+  options: ImprovisationOptions;
+  claudeSessionId: string | undefined;
+  isFirstPrompt: boolean;
+  isResumedSession: boolean;
+  history: SessionHistory;
+  executionStartTimestamp: number | undefined;
+}
+
+export const MAX_RETRIES = 3;

package/server/index.ts

@@ -9,14 +9,14 @@
 
 import { randomBytes } from 'node:crypto'
 import { readFileSync } from 'node:fs'
-import type { IncomingMessage, Server } from 'node:http'
+import type { Server } from 'node:http'
 import { homedir } from 'node:os'
 import { basename, join } from 'node:path'
 import { serve } from '@hono/node-server'
 import { type Context, Hono, type Next } from 'hono'
 import { cors } from 'hono/cors'
 import { logger } from 'hono/logger'
-import { type WebSocket as NodeWebSocket, WebSocketServer } from 'ws'
+import { WebSocketServer } from 'ws'
 import {
   createFileRoutes,
   createImproviseRoutes,
@@ -24,16 +24,20 @@ import {
   createNotificationRoutes,
   createShutdownRoute
 } from './routes/index.js'
-import { createPlatformRelayContext, ensureClaudeSettings, setTerminalTitle, wrapWebSocket } from './server-setup.js'
+import {
+  attachLocalWebSocketRouting,
+  createPlatformRelay,
+  ensureClaudeSettings,
+  registerProcessErrorHandlers,
+  setTerminalTitle
+} from './server-setup.js'
 import { AnalyticsEvents, initAnalytics, shutdownAnalytics, trackEvent } from './services/analytics.js'
 import { AuthService } from './services/auth.js'
 import { FileService } from './services/files.js'
 import { InstanceRegistry, type MstroInstance } from './services/instances.js'
-import { PlatformConnection } from './services/platform.js'
 import { captureException, flushSentry, initSentry } from './services/sentry.js'
 import { getPTYManager, reloadPty } from './services/terminal/pty-manager.js'
 import { WebSocketImproviseHandler } from './services/websocket/index.js'
-import type { WSContext } from './services/websocket/types.js'
 import { findAvailablePort } from './utils/port.js'
 
 // Configuration
@@ -129,136 +133,46 @@ app.onError((err, c) => {
 
 // ── Server Startup ────────────────────────────────────────────
 
-async function startServer() {
-  initSentry()
-  await initAnalytics()
-
-  const PORT = await findAvailablePort(REQUESTED_PORT, 20)
-  _currentInstance = instanceRegistry.register(PORT, WORKING_DIR)
-
-  const server = serve({ fetch: app.fetch, port: PORT })
-  const wss = new WebSocketServer({ server: server as Server })
-
-  wss.on('connection', (ws: NodeWebSocket, req: IncomingMessage) => {
-    const url = new URL(req.url || '/', `http://localhost:${PORT}`)
-    if (url.pathname !== '/ws') {
-      ws.close(1008, 'Invalid WebSocket path')
-      return
-    }
-
-    const wsToken = url.searchParams.get('token')
-    if (!wsToken || !authService.validateLocalToken(wsToken)) {
-      ws.close(4001, 'Unauthorized')
-      return
-    }
-
-    const workingDir = WORKING_DIR
-    const wrappedWs = wrapWebSocket(ws, workingDir)
-    wsHandler.handleConnection(wrappedWs, workingDir)
-
-    ws.on('message', (data: Buffer | string) => {
-      let message = typeof data === 'string' ? data : data.toString('utf-8')
-      // Strip _permission from local WebSocket messages — only the platform relay
-      // should inject permission metadata. Local connections are always the machine owner.
-      if (message.includes('_permission')) {
-        try {
-          const parsed = JSON.parse(message)
-          if ('_permission' in parsed) {
-            delete parsed._permission
-            message = JSON.stringify(parsed)
-          }
-        } catch { /* not JSON — pass through */ }
-      }
-      wsHandler.handleMessage(wrappedWs, message, workingDir)
-    })
-    ws.on('close', () => wsHandler.handleClose(wrappedWs))
-    ws.on('error', (error: Error) => {
-      console.error('[WebSocket] Error:', error)
-      captureException(error, { context: 'websocket.connection' })
-    })
-  })
-
+function logStartupBanner(port: number): void {
   const home = homedir()
   const displayDir = WORKING_DIR.startsWith(home) ? `~${WORKING_DIR.slice(home.length)}` : WORKING_DIR
   console.log(`App: ${displayDir}`)
-  trackEvent(AnalyticsEvents.SERVER_STARTED, { port: PORT, working_dir_basename: basename(WORKING_DIR) })
-
-  // Platform relay
-  let platformRelayContext: WSContext | null = null
-  let pendingRelayMessages: unknown[] = []
-
-  const platformConnection = new PlatformConnection(WORKING_DIR, {
-    onConnected: () => {
-      console.log(`Connected: https://mstro.app`)
-      wsHandler.setUsageReporter((report) => {
-        platformConnection.send({ type: 'reportUsage', data: report })
-      })
-    },
-    onDisconnected: () => {
-      if (platformRelayContext) {
-        wsHandler.handleClose(platformRelayContext)
-        platformRelayContext = null
-      }
-      pendingRelayMessages = []
-    },
-    onWebConnected: () => {
-      // Clean up previous relay context to prevent duplicate broadcasts
-      if (platformRelayContext) {
-        wsHandler.handleClose(platformRelayContext)
-      }
-      platformRelayContext = createPlatformRelayContext(
-        (message) => platformConnection.send(message),
-        WORKING_DIR
-      )
-      wsHandler.handleConnection(platformRelayContext, WORKING_DIR)
-      if (pendingRelayMessages.length > 0) {
-        for (const message of pendingRelayMessages) {
-          wsHandler.handleMessage(platformRelayContext, JSON.stringify(message), WORKING_DIR)
-        }
-        pendingRelayMessages = []
-      }
-    },
-    onWebDisconnected: () => {
-      if (platformRelayContext) {
-        wsHandler.handleClose(platformRelayContext)
-        platformRelayContext = null
-      }
-      pendingRelayMessages = []
-    },
-    onRelayedMessage: (message) => {
-      if (platformRelayContext) {
-        wsHandler.handleMessage(platformRelayContext, JSON.stringify(message), WORKING_DIR)
-      } else {
-        // Cap pending messages to prevent unbounded memory growth while disconnected
-        if (pendingRelayMessages.length < 100) {
-          pendingRelayMessages.push(message)
-        }
-      }
-    }
-  })
-  platformConnection.connect()
-
-  // Process-level error handling
-  process.on('uncaughtException', (err) => {
-    console.error('[Server] Uncaught exception:', err)
-    captureException(err, { context: 'uncaughtException' })
-  })
-  process.on('unhandledRejection', (reason) => {
-    console.error('[Server] Unhandled rejection:', reason)
-    captureException(reason instanceof Error ? reason : new Error(String(reason)), { context: 'unhandledRejection' })
-  })
+  trackEvent(AnalyticsEvents.SERVER_STARTED, { port, working_dir_basename: basename(WORKING_DIR) })
+}
 
-  const gracefulShutdown = async () => {
+function makeGracefulShutdown(deps: {
+  platformConnection: { disconnect: () => void }
+  wss: WebSocketServer
+}) {
+  return async () => {
     trackEvent(AnalyticsEvents.SERVER_STOPPED)
     await Promise.all([shutdownAnalytics(), flushSentry()])
-    platformConnection.disconnect()
+    deps.platformConnection.disconnect()
     instanceRegistry.unregister()
     getPTYManager().closeAll()
-    wss.close()
+    deps.wss.close()
     console.log('\n\n👋 Shutting down gracefully...\n')
     process.exit(0)
   }
+}
+
+async function startServer() {
+  initSentry()
+  await initAnalytics()
+
+  const port = await findAvailablePort(REQUESTED_PORT, 20)
+  _currentInstance = instanceRegistry.register(port, WORKING_DIR)
+
+  const server = serve({ fetch: app.fetch, port })
+  const wss = new WebSocketServer({ server: server as Server })
+
+  attachLocalWebSocketRouting({ wss, port, workingDir: WORKING_DIR, authService, wsHandler })
+  logStartupBanner(port)
+
+  const platformConnection = createPlatformRelay(WORKING_DIR, wsHandler)
+  registerProcessErrorHandlers()
 
+  const gracefulShutdown = makeGracefulShutdown({ platformConnection, wss })
   process.on('SIGINT', gracefulShutdown)
   process.on('SIGTERM', gracefulShutdown)
 }