@seflless/ghosttown 1.6.2 → 2.0.0

package/src/cli.js

@@ -50,6 +50,24 @@ import pty from '@lydell/node-pty';
 import { WebSocketServer } from 'ws';
 // ASCII art generator
 import { asciiArt } from '../bin/ascii.js';
+// Session name utilities
+import { displayNameExists, findSession, validateSessionName } from './session-utils.js';
+// Session management - custom PTY session manager (replaces tmux)
+import { SessionManager } from './session/session-manager.js';
+
+// Global SessionManager instance (lazy-initialized)
+let sessionManager = null;
+
+/**
+ * Get or create the SessionManager instance
+ */
+async function getSessionManager() {
+  if (!sessionManager) {
+    sessionManager = new SessionManager();
+    await sessionManager.init();
+  }
+  return sessionManager;
+}
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -422,40 +440,43 @@ function isInsideGhosttownSession() {
   return sessionName && sessionName.startsWith('gt-');
 }
 
+// Note: validateSessionName and displayNameExists are imported from session-utils.js
+// CLI uses getTmuxSessionsForValidation() to adapt tmux sessions to the expected format
+// Web server uses SessionManager directly
+
 /**
- * Validate a session name
- * Returns { valid: true } or { valid: false, error: string }
+ * Parse a ghosttown tmux session name into its components.
+ * Format: gt-<stable-id>-<display-name>
+ * DEPRECATED: Only used by legacy CLI commands that still use tmux
+ *
+ * @param {string} fullName - The full tmux session name
+ * @returns {{ stableId: string|null, displayName: string, fullName: string }|null}
  */
-function validateSessionName(name) {
-  if (!name || name.length === 0) {
-    return { valid: false, error: 'Session name cannot be empty' };
-  }
-  if (name.length > 50) {
-    return { valid: false, error: 'Session name too long (max 50 chars)' };
-  }
-  if (/^[0-9]+$/.test(name)) {
-    return {
-      valid: false,
-      error: 'Session name cannot be purely numeric (conflicts with auto-generated IDs)',
-    };
-  }
-  // Reserved name for background server
-  if (name === 'ghosttown-host') {
-    return { valid: false, error: "'ghosttown-host' is a reserved name" };
+function parseSessionName(fullName) {
+  if (!fullName || !fullName.startsWith('gt-')) {
+    return null;
   }
-  // tmux session names cannot contain: colon, period
-  // We also disallow spaces and special chars for URL safety
-  if (!/^[a-zA-Z0-9_-]+$/.test(name)) {
+  // Format: gt-<stable-id>-<display-name>
+  const match = fullName.match(/^gt-(\d+)-(.+)$/);
+  if (match) {
     return {
-      valid: false,
-      error: 'Session name can only contain letters, numbers, hyphens, and underscores',
+      stableId: match[1],
+      displayName: match[2],
+      fullName: fullName,
     };
   }
-  return { valid: true };
+  // Legacy format: gt-<name> (no stable ID)
+  const legacyName = fullName.slice(3);
+  return {
+    stableId: null,
+    displayName: legacyName,
+    fullName: fullName,
+  };
 }
 
 /**
  * Check if a tmux session with the given name exists
+ * DEPRECATED: Only used by legacy CLI commands that still use tmux
  */
 function sessionExists(sessionName) {
   try {
@@ -473,10 +494,11 @@ function sessionExists(sessionName) {
 }
 
 /**
- * Check if a display name is already used by a ghosttown session
- * Display name is the user-facing part after gt-<id>-
+ * Get tmux sessions in a format compatible with displayNameExists().
+ * Returns array of objects with displayName property.
+ * DEPRECATED: Only used by legacy CLI commands that still use tmux
  */
-function displayNameExists(displayName) {
+function getTmuxSessionsForValidation() {
   try {
     const output = execSync('tmux list-sessions -F "#{session_name}"', {
       encoding: 'utf8',
@@ -484,61 +506,54 @@ function displayNameExists(displayName) {
     });
     return output
       .split('\n')
-      .filter((s) => s.trim())
-      .some((name) => {
+      .filter((name) => name.startsWith('gt-'))
+      .map((name) => {
         const parsed = parseSessionName(name);
-        return parsed && parsed.displayName === displayName;
+        return { displayName: parsed ? parsed.displayName : name.replace('gt-', '') };
       });
   } catch (err) {
-    return false;
+    return [];
   }
 }
 
 /**
- * Parse a ghosttown session name into its components
- * Format: gt-<stable-id>-<display-name>
- * Returns { stableId, displayName, fullName } or null if not a valid gt session
- */
-function parseSessionName(fullName) {
-  if (!fullName || !fullName.startsWith('gt-')) {
-    return null;
-  }
-  // Format: gt-<stable-id>-<display-name>
-  const match = fullName.match(/^gt-(\d+)-(.+)$/);
-  if (match) {
-    return {
-      stableId: match[1],
-      displayName: match[2],
-      fullName: fullName,
-    };
-  }
-  // Legacy format: gt-<name> (no stable ID)
-  // Treat the whole thing after gt- as the display name, no stable ID
-  const legacyName = fullName.slice(3);
-  return {
-    stableId: null,
-    displayName: legacyName,
-    fullName: fullName,
-  };
-}
-
-/**
- * Find a ghosttown session by its stable ID
- * Returns the full session name or null if not found
+ * Find a tmux session by display name or stableId.
+ * Used by CLI commands (attach, rename, kill) that interact with tmux sessions.
+ *
+ * @param {string} identifier - Display name or stableId to search for
+ * @returns {{ displayName: string, stableId: string|null, fullName: string }|null}
  */
-function findSessionByStableId(stableId) {
+function findSessionByDisplayName(identifier) {
   try {
     const output = execSync('tmux list-sessions -F "#{session_name}"', {
       encoding: 'utf8',
       stdio: ['pipe', 'pipe', 'pipe'],
     });
-    const sessions = output.split('\n').filter((s) => s.trim() && s.startsWith('gt-'));
-    for (const name of sessions) {
-      const parsed = parseSessionName(name);
-      if (parsed && parsed.stableId === stableId) {
-        return name;
-      }
+
+    const sessions = output
+      .split('\n')
+      .filter((name) => name.startsWith('gt-') && name !== SERVER_SESSION_NAME)
+      .map((fullName) => {
+        const parsed = parseSessionName(fullName);
+        return {
+          displayName: parsed ? parsed.displayName : fullName.replace('gt-', ''),
+          stableId: parsed ? parsed.stableId : null,
+          fullName,
+        };
+      });
+
+    // Try exact display name match first
+    const byName = sessions.find((s) => s.displayName === identifier);
+    if (byName) {
+      return byName;
+    }
+
+    // Try stableId match (for backwards compatibility)
+    const byId = sessions.find((s) => s.stableId === identifier);
+    if (byId) {
+      return byId;
     }
+
     return null;
   } catch (err) {
     return null;
@@ -766,7 +781,7 @@ function createTmuxSession(command, customName = null) {
       process.exit(1);
     }
     // Check if display name already exists
-    if (displayNameExists(customName)) {
+    if (displayNameExists(getTmuxSessionsForValidation(), customName)) {
       console.log('');
       console.log(`   ${RED}Error:${RESET} Session '${customName}' already exists.`);
       console.log('');
@@ -937,32 +952,13 @@ function attachToSession(sessionName) {
   const RED = '\x1b[31m';
   const BEIGE = '\x1b[38;2;255;220;150m';
 
-  // Add gt- prefix if not present
-  if (!sessionName.startsWith('gt-')) {
-    sessionName = `gt-${sessionName}`;
-  }
-
-  // Check if session exists
-  try {
-    const output = execSync('tmux list-sessions -F "#{session_name}"', {
-      encoding: 'utf8',
-      stdio: ['pipe', 'pipe', 'pipe'],
-    });
-
-    const sessions = output.split('\n').filter((s) => s.trim());
-    if (!sessions.includes(sessionName)) {
-      console.log('');
-      console.log(`   ${RED}Error:${RESET} Session '${sessionName}' not found.`);
-      console.log('');
-      console.log(`   ${BEIGE}No ghosttown sessions are currently running.${RESET}`);
-      console.log('');
-      process.exit(1);
-    }
-  } catch (err) {
+  // Look up session by display name
+  const found = findSessionByDisplayName(sessionName);
+  if (!found) {
     console.log('');
-    console.log(`   ${RED}Error:${RESET} No tmux sessions found.`);
+    console.log(`   ${RED}Error:${RESET} Session '${sessionName}' not found.`);
     console.log('');
-    console.log(`   ${BEIGE}No ghosttown sessions are currently running.${RESET}`);
+    listSessionsInline();
     console.log('');
     process.exit(1);
   }
@@ -971,7 +967,7 @@ function attachToSession(sessionName) {
   // Use the same pattern as detachFromTmux which works
   const result = spawnSync(
     process.env.SHELL || '/bin/sh',
-    ['-c', `tmux attach-session -t ${sessionName}`],
+    ['-c', `tmux attach-session -t ${found.fullName}`],
     {
       stdio: 'inherit',
     }
@@ -1087,57 +1083,57 @@ function killSession(sessionName) {
     }
 
     sessionName = getCurrentTmuxSessionName();
-  }
-
-  // Add gt- prefix if not present
-  if (!sessionName.startsWith('gt-')) {
-    sessionName = `gt-${sessionName}`;
-  }
+    // sessionName is now the full tmux name (e.g., gt-12-13)
+    const parsed = parseSessionName(sessionName);
 
-  // Check if session exists
-  try {
-    const output = execSync('tmux list-sessions -F "#{session_name}"', {
-      encoding: 'utf8',
-      stdio: ['pipe', 'pipe', 'pipe'],
-    });
+    // Kill the session
+    try {
+      execSync(`tmux kill-session -t ${sessionName}`, {
+        stdio: 'pipe',
+      });
 
-    const sessions = output.split('\n').filter((s) => s.trim());
-    if (!sessions.includes(sessionName)) {
+      const displayName = parsed ? parsed.displayName : sessionName.replace('gt-', '');
       console.log('');
-      console.log(`   ${RED}Error:${RESET} Session '${sessionName}' not found.`);
+      console.log(`   ${BOLD_YELLOW}Session ${displayName} has been killed.${RESET}`);
       console.log('');
-      console.log(`   ${BEIGE}No ghosttown sessions are currently running.${RESET}`);
+      console.log(`   ${CYAN}To list remaining:${RESET}  ${BEIGE}gt list${RESET}`);
+      console.log('');
+      process.exit(0);
+    } catch (err) {
+      const displayName = parsed ? parsed.displayName : sessionName.replace('gt-', '');
+      console.log('');
+      console.log(`   ${RED}Error:${RESET} Failed to kill session '${displayName}'.`);
       console.log('');
       process.exit(1);
     }
-  } catch (err) {
+  }
+
+  // User provided a session name - look it up by display name
+  const found = findSessionByDisplayName(sessionName);
+  if (!found) {
     console.log('');
-    console.log(`   ${RED}Error:${RESET} No tmux sessions found.`);
+    console.log(`   ${RED}Error:${RESET} Session '${sessionName}' not found.`);
     console.log('');
-    console.log(`   ${BEIGE}No ghosttown sessions are currently running.${RESET}`);
+    listSessionsInline();
     console.log('');
     process.exit(1);
   }
 
   // Kill the session
   try {
-    execSync(`tmux kill-session -t ${sessionName}`, {
+    execSync(`tmux kill-session -t ${found.fullName}`, {
       stdio: 'pipe',
     });
 
-    // Extract display name from session name
-    const parsed = parseSessionName(sessionName);
-    const displayName = parsed ? parsed.displayName : sessionName.replace('gt-', '');
-
     console.log('');
-    console.log(`   ${BOLD_YELLOW}Session ${displayName} has been killed.${RESET}`);
+    console.log(`   ${BOLD_YELLOW}Session ${found.displayName} has been killed.${RESET}`);
     console.log('');
     console.log(`   ${CYAN}To list remaining:${RESET}  ${BEIGE}gt list${RESET}`);
     console.log('');
     process.exit(0);
   } catch (err) {
     console.log('');
-    console.log(`   ${RED}Error:${RESET} Failed to kill session '${sessionName}'.`);
+    console.log(`   ${RED}Error:${RESET} Failed to kill session '${found.displayName}'.`);
     console.log('');
     process.exit(1);
   }
@@ -1442,29 +1438,6 @@ function listSessionsInline() {
   }
 }
 
-/**
- * Find a ghosttown session by display name
- * Returns the parsed session info or null if not found
- */
-function findSessionByDisplayName(displayName) {
-  try {
-    const output = execSync('tmux list-sessions -F "#{session_name}"', {
-      encoding: 'utf8',
-      stdio: ['pipe', 'pipe', 'pipe'],
-    });
-    const sessions = output.split('\n').filter((s) => s.trim() && s.startsWith('gt-'));
-    for (const fullName of sessions) {
-      const parsed = parseSessionName(fullName);
-      if (parsed && parsed.displayName === displayName) {
-        return parsed;
-      }
-    }
-    return null;
-  } catch (err) {
-    return null;
-  }
-}
-
 /**
  * Rename a ghosttown session
  * Usage:
@@ -1540,7 +1513,7 @@ function renameSession(renameArgs) {
   }
 
   // Check new display name doesn't conflict
-  if (displayNameExists(newDisplayName)) {
+  if (displayNameExists(getTmuxSessionsForValidation(), newDisplayName)) {
     console.log('');
     console.log(`   ${RED}Error:${RESET} Session '${newDisplayName}' already exists.`);
     console.log('');
@@ -1672,8 +1645,7 @@ Aliases:
       if (!sessionArg) {
         console.error('Error: attach requires a session name or ID');
         console.error('Usage: gt attach <name|id>');
-        handled = true;
-        break;
+        process.exit(1);
       }
       handled = true;
       attachToSession(sessionArg);
@@ -1978,7 +1950,15 @@ function startWebServer(cliArgs) {
         color: #e5e5e5;
         font-size: 22px;
         font-weight: 600;
-        margin-bottom: 12px;
+        margin-bottom: 4px;
+        text-align: center;
+      }
+
+      .session-card .subtitle {
+        color: #888;
+        font-size: 13px;
+        font-weight: 400;
+        margin-bottom: 16px;
         text-align: center;
       }
 
@@ -2382,6 +2362,7 @@ function startWebServer(cliArgs) {
     <div class="session-list-view" id="session-list-view">
       <div class="session-card">
         <h1>Ghost Town</h1>
+        <p class="subtitle">Choose a terminal to connect to</p>
         <div class="error-message" id="error-message"></div>
         <div class="session-table-header" id="session-table-header" style="display: none;">
           <span class="header-name">Name</span>
@@ -2454,13 +2435,15 @@ function startWebServer(cliArgs) {
       }
 
       // Get session info from URL query parameters
-      // Returns { name, stableId } or null
+      // Returns { sessionId, name, stableId } or null
+      // Supports both new (?sessionId=uuid) and legacy (?session=name&id=stableId) formats
       function getSessionFromUrl() {
         const params = new URLSearchParams(window.location.search);
+        const sessionId = params.get('sessionId');
         const name = params.get('session');
         const stableId = params.get('id');
-        if (name || stableId) {
-          return { name, stableId };
+        if (sessionId || name || stableId) {
+          return { sessionId, name, stableId };
         }
         return null;
       }
@@ -2469,9 +2452,13 @@ function startWebServer(cliArgs) {
       async function initApp() {
         const sessionInfo = getSessionFromUrl();
 
-        if (sessionInfo && sessionInfo.stableId) {
-          // Show terminal view using stable ID
-          requestedSessionName = sessionInfo.name; // Store for error messages
+        if (sessionInfo && sessionInfo.sessionId) {
+          // New format: use UUID sessionId
+          requestedSessionName = sessionInfo.name || sessionInfo.sessionId;
+          showTerminalView(sessionInfo.sessionId);
+        } else if (sessionInfo && sessionInfo.stableId) {
+          // Legacy format: use stable ID
+          requestedSessionName = sessionInfo.name;
           showTerminalView(sessionInfo.stableId);
         } else if (sessionInfo && sessionInfo.name) {
           // Legacy URL with just name - show terminal view
@@ -3356,15 +3343,22 @@ function startWebServer(cliArgs) {
         res.end();
         return;
       }
-      try {
-        const { displayNumber, stableId } = createWebSession();
-        res.writeHead(302, { Location: `/?session=${displayNumber}&id=${stableId}` });
-        res.end();
-      } catch (err) {
-        console.error('Failed to create session:', err);
-        res.writeHead(500, { 'Content-Type': 'text/plain' });
-        res.end('Failed to create session');
-      }
+      (async () => {
+        try {
+          const manager = await getSessionManager();
+          // Create session without starting PTY - it will start on first WebSocket connect
+          const newSession = await manager.createSession({ startProcess: false });
+          // Use sessionId for new format, keep session param for backward compat
+          res.writeHead(302, {
+            Location: `/?sessionId=${newSession.id}&session=${encodeURIComponent(newSession.displayName)}`,
+          });
+          res.end();
+        } catch (err) {
+          console.error('Failed to create session:', err);
+          res.writeHead(500, { 'Content-Type': 'text/plain' });
+          res.end('Failed to create session');
+        }
+      })();
       return;
     }
 
@@ -3403,7 +3397,7 @@ function startWebServer(cliArgs) {
       return;
     }
 
-    // API: List sessions (from tmux) - requires authentication
+    // API: List sessions - requires authentication
     if (pathname === '/api/sessions' && req.method === 'GET') {
       if (!session) {
         res.writeHead(401, { 'Content-Type': 'application/json' });
@@ -3411,40 +3405,31 @@ function startWebServer(cliArgs) {
         return;
       }
       try {
-        const output = execSync(
-          'tmux list-sessions -F "#{session_name}|#{session_activity}|#{session_attached}|#{session_windows}"',
-          { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }
-        );
-
-        const sessionList = output
-          .split('\n')
-          .filter((line) => line.startsWith('gt-'))
-          .map((line) => {
-            const [fullName, activity, attached, windows] = line.split('|');
-            const parsed = parseSessionName(fullName);
-            return {
-              name: parsed ? parsed.displayName : fullName.replace('gt-', ''),
-              stableId: parsed ? parsed.stableId : null,
-              fullName: fullName,
-              lastActivity: Number.parseInt(activity, 10) * 1000,
-              attached: attached === '1',
-              windows: Number.parseInt(windows, 10),
-            };
-          });
+        const manager = await getSessionManager();
+        const sessionList = await manager.listSessions();
+
+        // Map to API response format with backward-compatible fields
+        const response = sessionList.map((s) => ({
+          name: s.displayName,
+          stableId: s.id.slice(0, 8), // Short ID for backward compat
+          id: s.id, // Full UUID (new)
+          lastActivity: s.lastActivity,
+          attached: s.connectionCount > 0, // Backward compat: attached means has connections
+          isRunning: s.isRunning,
+          connectionCount: s.connectionCount,
+        }));
 
-        // Sort by recent activity
-        sessionList.sort((a, b) => b.lastActivity - a.lastActivity);
         res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ sessions: sessionList }));
+        res.end(JSON.stringify({ sessions: response }));
       } catch (err) {
-        // No tmux sessions or tmux not running
+        console.error('Error listing sessions:', err);
         res.writeHead(200, { 'Content-Type': 'application/json' });
         res.end(JSON.stringify({ sessions: [] }));
       }
       return;
     }
 
-    // API: Create session (tmux session) - requires authentication
+    // API: Create session - requires authentication
     if (pathname === '/api/sessions/create' && req.method === 'POST') {
       if (!session) {
         res.writeHead(401, { 'Content-Type': 'application/json' });
@@ -3452,10 +3437,18 @@ function startWebServer(cliArgs) {
         return;
       }
       try {
-        const { displayNumber, stableId } = createWebSession();
+        const manager = await getSessionManager();
+        const newSession = await manager.createSession();
         res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ name: String(displayNumber), stableId: stableId }));
+        res.end(
+          JSON.stringify({
+            name: newSession.displayName,
+            stableId: newSession.id.slice(0, 8), // Short ID for backward compat
+            id: newSession.id, // Full UUID (new)
+          })
+        );
       } catch (err) {
+        console.error('Error creating session:', err);
         res.writeHead(500, { 'Content-Type': 'application/json' });
         res.end(JSON.stringify({ error: 'Failed to create session' }));
       }
@@ -3472,85 +3465,123 @@ function startWebServer(cliArgs) {
 
       const cols = Number.parseInt(url.searchParams.get('cols') || '80');
       const rows = Number.parseInt(url.searchParams.get('rows') || '24');
-      const requestedSession = url.searchParams.get('session');
-      const requestedName = url.searchParams.get('name'); // Original name from URL (if different from session)
+      // Support both new (sessionId) and legacy (session) parameters
+      const sessionIdParam = url.searchParams.get('sessionId');
+      const legacySession = url.searchParams.get('session');
+      const requestedName = url.searchParams.get('name');
+      const identifier = sessionIdParam || legacySession;
 
-      if (!requestedSession) {
+      if (!identifier) {
         res.writeHead(400, { 'Content-Type': 'application/json' });
         res.end(JSON.stringify({ error: 'Session parameter required' }));
         return;
       }
 
-      // Look up session by stable ID first, then by display name
-      let sessionInfo = findSessionByStableIdWeb(requestedSession);
-      if (!sessionInfo) {
-        sessionInfo = findSessionByDisplayName(requestedSession);
-      }
-      if (!sessionInfo) {
-        // Build error message with both name and id if available
-        let errorMsg;
-        if (requestedName && requestedName !== requestedSession) {
-          errorMsg = `No session found named ${requestedName}, or with id ${requestedSession}`;
-        } else {
-          errorMsg = `No session found named ${requestedSession} or with id ${requestedSession}`;
+      try {
+        const manager = await getSessionManager();
+
+        // Look up session by UUID, short ID, or display name
+        const sessionObj = await findSessionForWeb(identifier);
+        if (!sessionObj) {
+          let errorMsg;
+          if (requestedName && requestedName !== identifier) {
+            errorMsg = `No session found named ${requestedName}, or with id ${identifier}`;
+          } else {
+            errorMsg = `No session found named ${identifier} or with id ${identifier}`;
+          }
+          res.writeHead(404, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: errorMsg }));
+          return;
         }
-        res.writeHead(404, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ error: errorMsg }));
-        return;
-      }
 
-      // Generate unique connection ID
-      const connectionId = `sse-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+        // Generate unique connection ID
+        const connectionId = `sse-${Date.now()}-${Math.random().toString(36).slice(2)}`;
 
-      // Set up SSE headers
-      res.writeHead(200, {
-        'Content-Type': 'text/event-stream',
-        'Cache-Control': 'no-cache',
-        Connection: 'keep-alive',
-        'X-SSE-Connection-Id': connectionId,
-      });
+        // Set up SSE headers first
+        res.writeHead(200, {
+          'Content-Type': 'text/event-stream',
+          'Cache-Control': 'no-cache',
+          Connection: 'keep-alive',
+          'X-SSE-Connection-Id': connectionId,
+        });
 
-      // Send session info as first event
-      res.write(
-        `data: ${JSON.stringify({ type: 'session_info', name: sessionInfo.displayName, stableId: sessionInfo.stableId, connectionId })}\n\n`
-      );
+        // Send session info as first event
+        res.write(
+          `data: ${JSON.stringify({ type: 'session_info', name: sessionObj.displayName, stableId: sessionObj.id.slice(0, 8), id: sessionObj.id, connectionId })}\n\n`
+        );
 
-      // Create PTY attached to tmux session
-      const ptyProcess = createTmuxAttachPty(sessionInfo.fullName, cols, rows);
+        // Timeout for closing connection after session exit (30 seconds)
+        const SSE_EXIT_TIMEOUT_MS = 30000;
+        let exitTimeout = null;
+
+        // Set up event handlers BEFORE connecting (to catch early output like shell prompt)
+        const outputHandler = (sid, data) => {
+          if (sid === sessionObj.id && !res.writableEnded) {
+            // Clear exit timeout if session produces output (it restarted)
+            if (exitTimeout) {
+              clearTimeout(exitTimeout);
+              exitTimeout = null;
+            }
+            const encoded = Buffer.from(data).toString('base64');
+            res.write(`data: ${JSON.stringify({ type: 'output', data: encoded })}\n\n`);
+          }
+        };
 
-      // Store connection
-      sseConnections.set(connectionId, {
-        res,
-        pty: ptyProcess,
-        stableId: requestedSession,
-        sessionInfo,
-      });
+        const exitHandler = (sid) => {
+          if (sid === sessionObj.id && !res.writableEnded) {
+            res.write(`data: ${JSON.stringify({ type: 'exit' })}\n\n`);
+            // Set timeout to close connection if session doesn't restart
+            exitTimeout = setTimeout(() => {
+              if (!res.writableEnded) {
+                res.write(
+                  `data: ${JSON.stringify({ type: 'timeout', message: 'Session exited and did not restart' })}\n\n`
+                );
+                res.end();
+                const conn = sseConnections.get(connectionId);
+                if (conn) {
+                  manager.off('session:output', conn.outputHandler);
+                  manager.off('session:exit', conn.exitHandler);
+                  sseConnections.delete(connectionId);
+                }
+              }
+            }, SSE_EXIT_TIMEOUT_MS);
+          }
+        };
 
-      // Stream terminal output as SSE events
-      ptyProcess.onData((data) => {
-        if (!res.writableEnded) {
-          // Base64 encode to handle binary data safely
-          const encoded = Buffer.from(data).toString('base64');
-          res.write(`data: ${JSON.stringify({ type: 'output', data: encoded })}\n\n`);
-        }
-      });
+        manager.on('session:output', outputHandler);
+        manager.on('session:exit', exitHandler);
 
-      ptyProcess.onExit(() => {
-        if (!res.writableEnded) {
-          res.write(`data: ${JSON.stringify({ type: 'exit' })}\n\n`);
-          res.end();
-        }
-        sseConnections.delete(connectionId);
-      });
+        // Store connection
+        sseConnections.set(connectionId, {
+          res,
+          sessionId: sessionObj.id,
+          outputHandler,
+          exitHandler,
+          exitTimeout: () => exitTimeout, // Getter for cleanup
+        });
 
-      // Handle client disconnect
-      req.on('close', () => {
-        const conn = sseConnections.get(connectionId);
-        if (conn) {
-          conn.pty.kill();
-          sseConnections.delete(connectionId);
-        }
-      });
+        // Connect to session (respawns PTY if needed) - after handlers are set up
+        await manager.connectToSession(sessionObj.id);
+        await manager.resizeSession(sessionObj.id, cols, rows);
+
+        // Handle client disconnect
+        req.on('close', () => {
+          const conn = sseConnections.get(connectionId);
+          if (conn) {
+            // Clear any pending exit timeout
+            const timeout = conn.exitTimeout?.();
+            if (timeout) clearTimeout(timeout);
+            manager.off('session:output', conn.outputHandler);
+            manager.off('session:exit', conn.exitHandler);
+            sseConnections.delete(connectionId);
+            // Note: We do NOT kill the PTY - session persists for reconnection
+          }
+        });
+      } catch (err) {
+        console.error('SSE connection error:', err);
+        res.writeHead(500, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: err.message }));
+      }
 
       return;
     }
@@ -3567,7 +3598,7 @@ function startWebServer(cliArgs) {
       req.on('data', (chunk) => {
         body += chunk;
       });
-      req.on('end', () => {
+      req.on('end', async () => {
         try {
           const { connectionId, data, type, cols, rows } = JSON.parse(body);
 
@@ -3578,12 +3609,14 @@ function startWebServer(cliArgs) {
             return;
           }
 
+          const manager = await getSessionManager();
+
           if (type === 'resize' && cols && rows) {
-            conn.pty.resize(cols, rows);
+            await manager.resizeSession(conn.sessionId, cols, rows);
           } else if (data) {
             // Decode base64 input
             const decoded = Buffer.from(data, 'base64').toString('utf8');
-            conn.pty.write(decoded);
+            manager.write(conn.sessionId, decoded);
           }
 
           res.writeHead(200, { 'Content-Type': 'application/json' });
@@ -3620,56 +3653,35 @@ function startWebServer(cliArgs) {
   // WebSocket Server
   // ============================================================================
 
-  // Track active WebSocket connections to tmux sessions
-  // ws -> { pty, sessionName }
+  // Track active WebSocket connections to sessions
+  // ws -> { sessionId, outputHandler, exitHandler }
   const wsConnections = new Map();
 
   // Track active SSE connections (fallback for mobile)
-  // connectionId -> { res, pty, stableId, sessionInfo }
+  // connectionId -> { res, sessionId, outputHandler, exitHandler }
   const sseConnections = new Map();
 
   /**
-   * Find a ghosttown session by stable ID (for web connections)
-   * Returns { fullName, displayName, stableId } or null if not found
+   * Find a session by various identifiers (UUID, short ID, or display name)
+   * Returns session object or null if not found
    */
-  function findSessionByStableIdWeb(stableId) {
-    try {
-      const output = execSync('tmux list-sessions -F "#{session_name}"', {
-        encoding: 'utf8',
-        stdio: ['pipe', 'pipe', 'pipe'],
-      });
-      const sessions = output.split('\n').filter((s) => s.trim() && s.startsWith('gt-'));
-      for (const fullName of sessions) {
-        const parsed = parseSessionName(fullName);
-        if (parsed && parsed.stableId === stableId) {
-          return parsed;
-        }
-      }
-      return null;
-    } catch (err) {
-      return null;
-    }
-  }
+  async function findSessionForWeb(identifier) {
+    const manager = await getSessionManager();
+    const sessions = await manager.listSessions();
 
-  /**
-   * Create a PTY that attaches to a tmux session
-   */
-  function createTmuxAttachPty(fullSessionName, cols, rows) {
-    const ptyProcess = pty.spawn('tmux', ['attach-session', '-t', fullSessionName], {
-      name: 'xterm-256color',
-      cols: cols,
-      rows: rows,
-      cwd: homedir(),
-      env: {
-        ...process.env,
-        TERM: 'xterm-256color',
-        COLORTERM: 'truecolor',
-        LANG: 'en_US.UTF-8',
-        LC_ALL: 'en_US.UTF-8',
-      },
-    });
+    // Try exact UUID match first
+    let session = sessions.find((s) => s.id === identifier);
+    if (session) return manager.getSession(session.id);
 
-    return ptyProcess;
+    // Try short ID prefix match
+    session = sessions.find((s) => s.id.startsWith(identifier));
+    if (session) return manager.getSession(session.id);
+
+    // Try display name match
+    session = sessions.find((s) => s.displayName === identifier);
+    if (session) return manager.getSession(session.id);
+
+    return null;
   }
 
   const wss = new WebSocketServer({ noServer: true });
@@ -3700,99 +3712,130 @@ function startWebServer(cliArgs) {
     }
   });
 
-  wss.on('connection', (ws, req) => {
+  wss.on('connection', async (ws, req) => {
     const url = new URL(req.url, `http://${req.headers.host}`);
     const cols = Number.parseInt(url.searchParams.get('cols') || '80');
     const rows = Number.parseInt(url.searchParams.get('rows') || '24');
-    const requestedSession = url.searchParams.get('session');
+
+    // Support both new (sessionId) and legacy (session) parameters
+    const sessionId = url.searchParams.get('sessionId');
+    const legacySession = url.searchParams.get('session');
     const requestedName = url.searchParams.get('name'); // Original name from URL (if different from session)
+    const identifier = sessionId || legacySession;
 
-    // Session parameter is required (should be stable ID)
-    if (!requestedSession) {
+    // Session parameter is required
+    if (!identifier) {
       ws.send(JSON.stringify({ type: 'error', message: 'Session parameter required' }));
       ws.close();
       return;
     }
 
-    // Look up session by stable ID first, then by display name (for legacy URLs)
-    let sessionInfo = findSessionByStableIdWeb(requestedSession);
-    if (!sessionInfo) {
-      // Try looking up by display name
-      sessionInfo = findSessionByDisplayName(requestedSession);
-    }
-    if (!sessionInfo) {
-      // Build error message with both name and id if available
-      let errorMsg;
-      if (requestedName && requestedName !== requestedSession) {
-        errorMsg = `No session found named ${requestedName}, or with id ${requestedSession}`;
-      } else {
-        errorMsg = `No session found named ${requestedSession} or with id ${requestedSession}`;
+    try {
+      const manager = await getSessionManager();
+
+      // Look up session by UUID, short ID, or display name
+      const session = await findSessionForWeb(identifier);
+
+      if (!session) {
+        // Build error message with both name and id if available
+        let errorMsg;
+        if (requestedName && requestedName !== identifier) {
+          errorMsg = `No session found named ${requestedName}, or with id ${identifier}`;
+        } else {
+          errorMsg = `No session found named ${identifier} or with id ${identifier}`;
+        }
+        ws.send(JSON.stringify({ type: 'error', message: errorMsg }));
+        ws.close();
+        return;
       }
-      ws.send(JSON.stringify({ type: 'error', message: errorMsg }));
-      ws.close();
-      return;
-    }
 
-    // Create a PTY that attaches to the tmux session
-    const ptyProcess = createTmuxAttachPty(sessionInfo.fullName, cols, rows);
+      // Set up event handlers BEFORE connecting (to catch early output like shell prompt)
+      const outputHandler = (sid, data) => {
+        if (sid === session.id && ws.readyState === ws.OPEN) {
+          ws.send(data);
+        }
+      };
 
-    wsConnections.set(ws, { pty: ptyProcess, stableId: requestedSession, sessionInfo });
+      const exitHandler = (sid) => {
+        if (sid === session.id && ws.readyState === ws.OPEN) {
+          ws.send(JSON.stringify({ type: 'session_exit' }));
+          // Don't close - allow reconnect
+        }
+      };
 
-    // Send session info with current display name (may have been renamed)
-    ws.send(
-      JSON.stringify({
-        type: 'session_info',
-        name: sessionInfo.displayName,
-        stableId: sessionInfo.stableId,
-      })
-    );
+      manager.on('session:output', outputHandler);
+      manager.on('session:exit', exitHandler);
 
-    ptyProcess.onData((data) => {
-      if (ws.readyState === ws.OPEN) {
-        ws.send(data);
-      }
-    });
+      wsConnections.set(ws, { sessionId: session.id, outputHandler, exitHandler });
 
-    ptyProcess.onExit(() => {
-      if (ws.readyState === ws.OPEN) {
-        ws.close();
+      // Connect to session (respawns PTY if needed after server restart)
+      await manager.connectToSession(session.id);
+
+      // Resize to requested dimensions
+      await manager.resizeSession(session.id, cols, rows);
+
+      // Send session info with current display name
+      ws.send(
+        JSON.stringify({
+          type: 'session_info',
+          name: session.displayName,
+          stableId: session.id.slice(0, 8), // Backward compat
+          id: session.id, // Full UUID (new)
+        })
+      );
+
+      // Replay scrollback buffer for reconnecting clients
+      const scrollback = await manager.getScrollback(session.id);
+      if (scrollback) {
+        ws.send(scrollback);
       }
-      wsConnections.delete(ws);
-    });
 
-    ws.on('message', (data) => {
-      const message = data.toString('utf8');
+      ws.on('message', (data) => {
+        const message = data.toString('utf8');
 
-      if (message.startsWith('{')) {
-        try {
-          const msg = JSON.parse(message);
-          if (msg.type === 'resize') {
-            ptyProcess.resize(msg.cols, msg.rows);
-            return;
+        if (message.startsWith('{')) {
+          try {
+            const msg = JSON.parse(message);
+            if (msg.type === 'resize') {
+              manager.resizeSession(session.id, msg.cols, msg.rows);
+              return;
+            }
+          } catch (e) {
+            // Not JSON, treat as input
           }
-        } catch (e) {
-          // Not JSON, treat as input
         }
-      }
 
-      ptyProcess.write(message);
-    });
+        // Write to PTY
+        try {
+          manager.write(session.id, message);
+        } catch {
+          // PTY may have exited, that's ok
+        }
+      });
 
-    ws.on('close', () => {
-      const conn = wsConnections.get(ws);
-      if (conn) {
-        conn.pty.kill();
-        wsConnections.delete(ws);
-      }
-    });
+      ws.on('close', () => {
+        const conn = wsConnections.get(ws);
+        if (conn) {
+          manager.off('session:output', conn.outputHandler);
+          manager.off('session:exit', conn.exitHandler);
+          wsConnections.delete(ws);
+          // Note: We do NOT kill the PTY - session persists for reconnection
+        }
+      });
 
-    ws.on('error', () => {
-      const conn = wsConnections.get(ws);
-      if (conn) {
-        conn.pty.kill();
-        wsConnections.delete(ws);
-      }
-    });
+      ws.on('error', () => {
+        const conn = wsConnections.get(ws);
+        if (conn) {
+          manager.off('session:output', conn.outputHandler);
+          manager.off('session:exit', conn.exitHandler);
+          wsConnections.delete(ws);
+        }
+      });
+    } catch (err) {
+      console.error('WebSocket connection error:', err);
+      ws.send(JSON.stringify({ type: 'error', message: err.message }));
+      ws.close();
+    }
   });
 
   // ============================================================================