@burdenoff/vibe-agent 1.0.0

package/dist/routes/tmux.js

@@ -0,0 +1,1191 @@
+import { spawn } from 'child_process';
+import { getAgentTunnelUrl } from './tunnel.js';
+export const tmuxRoutes = async (fastify) => {
+    // Get all tmux sessions
+    fastify.get('/', async (_request, _reply) => {
+        const sessions = fastify.db.getAllTmuxSessions();
+        return { sessions };
+    });
+    // Get all system tmux sessions (including unmanaged ones)
+    fastify.get('/system', async (_request, reply) => {
+        try {
+            const systemSessions = await getSystemTmuxSessions();
+            const managedSessions = fastify.db.getAllTmuxSessions();
+            // Combine system sessions with managed session metadata
+            const enrichedSessions = systemSessions.map(systemSession => {
+                const managedSession = managedSessions.find(ms => ms.sessionName === systemSession.name);
+                return {
+                    ...systemSession,
+                    isManaged: !!managedSession,
+                    managedSessionId: managedSession?.id,
+                    projectId: managedSession?.projectId,
+                    ttydPort: managedSession?.ttydPort,
+                    ttydPid: managedSession?.ttydPid,
+                    createdAt: managedSession?.createdAt || systemSession.created,
+                };
+            });
+            return { sessions: enrichedSessions };
+        }
+        catch (error) {
+            return reply.code(500).send({
+                error: 'Failed to get system tmux sessions',
+                details: error instanceof Error ? error.message : 'Unknown error'
+            });
+        }
+    });
+    // Get all system ttyd processes
+    fastify.get('/system/ttyd', async (_request, reply) => {
+        try {
+            const ttydProcesses = await getSystemTtydProcesses();
+            return { processes: ttydProcesses };
+        }
+        catch (error) {
+            return reply.code(500).send({
+                error: 'Failed to get system ttyd processes',
+                details: error instanceof Error ? error.message : 'Unknown error'
+            });
+        }
+    });
+    // Kill system tmux sessions (bulk)
+    fastify.post('/system/kill', async (request, reply) => {
+        const { sessionNames, force } = request.body;
+        if (!sessionNames || !Array.isArray(sessionNames)) {
+            return reply.code(400).send({ error: 'sessionNames array is required' });
+        }
+        try {
+            const results = await killSystemTmuxSessions(sessionNames, force);
+            return { results };
+        }
+        catch (error) {
+            return reply.code(500).send({
+                error: 'Failed to kill system tmux sessions',
+                details: error instanceof Error ? error.message : 'Unknown error'
+            });
+        }
+    });
+    // Kill system ttyd processes (bulk)
+    fastify.post('/system/ttyd/kill', async (request, reply) => {
+        const { pids, force } = request.body;
+        if (!pids || !Array.isArray(pids)) {
+            return reply.code(400).send({ error: 'pids array is required' });
+        }
+        try {
+            const results = await killSystemTtydProcesses(pids, force);
+            return { results };
+        }
+        catch (error) {
+            return reply.code(500).send({
+                error: 'Failed to kill system ttyd processes',
+                details: error instanceof Error ? error.message : 'Unknown error'
+            });
+        }
+    });
+    // Get session by ID
+    fastify.get('/:id', async (request, reply) => {
+        const { id } = request.params;
+        const session = fastify.db.getTmuxSession(id);
+        if (!session) {
+            return reply.code(404).send({ error: 'Session not found' });
+        }
+        return { session };
+    });
+    // ── Bulk session health check ──────────────────────────────────────
+    // POST /health-check — accepts an array of session IDs and returns their
+    // actual status by checking if the tmux session and ttyd process are alive.
+    // Called periodically by the backend to reconcile DB state.
+    fastify.post('/health-check', async (request, _reply) => {
+        const { sessionIds } = request.body;
+        if (!sessionIds || !Array.isArray(sessionIds)) {
+            return { results: [] };
+        }
+        const results = [];
+        for (const sessionId of sessionIds) {
+            const dbSession = fastify.db.getTmuxSession(sessionId);
+            if (!dbSession) {
+                results.push({ sessionId, tmuxAlive: false, ttydAlive: false, ttydPort: null, status: 'unknown' });
+                continue;
+            }
+            // Check if tmux session is alive
+            let tmuxAlive = false;
+            try {
+                const checkProc = spawn('tmux', ['has-session', '-t', dbSession.sessionName]);
+                tmuxAlive = await new Promise((resolve) => {
+                    checkProc.on('close', (code) => resolve(code === 0));
+                    checkProc.on('error', () => resolve(false));
+                });
+            }
+            catch {
+                tmuxAlive = false;
+            }
+            // Check if ttyd process is alive
+            let ttydAlive = false;
+            if (dbSession.ttydPid) {
+                try {
+                    process.kill(dbSession.ttydPid, 0);
+                    ttydAlive = true;
+                }
+                catch {
+                    ttydAlive = false;
+                }
+            }
+            const status = tmuxAlive ? 'running' : 'dead';
+            results.push({
+                sessionId,
+                tmuxAlive,
+                ttydAlive,
+                ttydPort: dbSession.ttydPort ?? null,
+                status,
+            });
+        }
+        return { results };
+    });
+    // Create new tmux session (idempotent — re-adopts existing tmux sessions)
+    fastify.post('/create', async (request, reply) => {
+        const { sessionId, projectId, sessionName, windowName, command, startDirectory } = request.body;
+        let finalSessionName = sessionName || `vibecontrols-${Date.now()}`;
+        const finalWindowName = windowName || 'main';
+        try {
+            // Check if we already have this sessionId in our DB (idempotent re-call)
+            const existingDbSession = fastify.db.getTmuxSession(sessionId);
+            if (existingDbSession) {
+                // Already tracked — verify the tmux session still exists
+                const checkProc = spawn('tmux', ['has-session', '-t', existingDbSession.sessionName]);
+                const checkOk = await new Promise((resolve) => {
+                    checkProc.on('close', (code) => resolve(code === 0));
+                    checkProc.on('error', () => resolve(false));
+                });
+                if (checkOk) {
+                    return { session: existingDbSession, reused: true };
+                }
+                // tmux session is gone — we'll re-create it below
+                finalSessionName = existingDbSession.sessionName;
+            }
+            // Check if tmux session with this name already exists in the system
+            // (e.g. from a previous agent run before DB was wiped)
+            const hasProc = spawn('tmux', ['has-session', '-t', finalSessionName]);
+            const tmuxExists = await new Promise((resolve) => {
+                hasProc.on('close', (code) => resolve(code === 0));
+                hasProc.on('error', () => resolve(false));
+            });
+            if (tmuxExists) {
+                // tmux session exists but NOT in our DB — adopt it
+                console.log(`[tmux/create] Adopting existing tmux session "${finalSessionName}" for sessionId ${sessionId}`);
+            }
+            else {
+                // Check if the name conflicts with another DB entry, make unique
+                const existingSessions = fastify.db.getAllTmuxSessions();
+                const existingNames = existingSessions.map(s => s.sessionName);
+                if (existingNames.includes(finalSessionName)) {
+                    finalSessionName = `${finalSessionName}-${Date.now()}`;
+                }
+                // Create new tmux session
+                const tmuxCmd = ['tmux', 'new-session', '-d', '-s', finalSessionName];
+                if (startDirectory)
+                    tmuxCmd.push('-c', startDirectory);
+                if (command)
+                    tmuxCmd.push(command);
+                const tmuxProcess = spawn(tmuxCmd[0], tmuxCmd.slice(1));
+                await new Promise((resolve, reject) => {
+                    tmuxProcess.on('close', (code) => {
+                        if (code === 0)
+                            resolve(undefined);
+                        else
+                            reject(new Error(`Tmux exited with code ${code}`));
+                    });
+                    tmuxProcess.on('error', reject);
+                });
+                // Wait for tmux to be ready
+                await new Promise(resolve => setTimeout(resolve, 100));
+                // Verify
+                const verifyProcess = spawn('tmux', ['has-session', '-t', finalSessionName]);
+                await new Promise((resolve, reject) => {
+                    verifyProcess.on('close', (code) => {
+                        if (code === 0)
+                            resolve(undefined);
+                        else
+                            reject(new Error(`Failed to verify tmux session ${finalSessionName}`));
+                    });
+                    verifyProcess.on('error', reject);
+                });
+            }
+            // Upsert database entry (handles both new creation and adoption)
+            let session;
+            if (existingDbSession) {
+                // Update existing record
+                fastify.db.updateTmuxSession(sessionId, {
+                    sessionName: finalSessionName,
+                    status: 'active',
+                });
+                session = fastify.db.getTmuxSession(sessionId);
+            }
+            else {
+                session = fastify.db.createTmuxSession({
+                    id: sessionId,
+                    sessionName: finalSessionName,
+                    projectId,
+                    windowName: finalWindowName,
+                    command,
+                    status: 'active',
+                    ttydPort: undefined,
+                    ttydPid: undefined,
+                });
+            }
+            // Emit session created event
+            fastify.io.emit('session:created', session);
+            return { session, reused: tmuxExists };
+        }
+        catch (error) {
+            return reply.code(500).send({
+                error: 'Failed to create tmux session',
+                details: error instanceof Error ? error.message : 'Unknown error'
+            });
+        }
+    });
+    // Execute command in session
+    fastify.post('/:sessionId/command', async (request, reply) => {
+        const { sessionId } = request.params;
+        const { command } = request.body;
+        try {
+            const session = fastify.db.getTmuxSession(sessionId);
+            if (!session) {
+                return reply.code(404).send({ error: 'Session not found' });
+            }
+            // Send command to tmux session
+            const tmuxProcess = spawn('tmux', ['send-keys', '-t', session.sessionName, command, 'Enter']);
+            await new Promise((resolve, reject) => {
+                tmuxProcess.on('close', (code) => {
+                    if (code === 0)
+                        resolve(undefined);
+                    else
+                        reject(new Error(`Tmux exited with code ${code}`));
+                });
+                tmuxProcess.on('error', reject);
+            });
+            // Emit command executed event
+            fastify.io.emit('session:command', { sessionId, command });
+            return { success: true };
+        }
+        catch (error) {
+            return reply.code(500).send({
+                error: 'Failed to execute command',
+                details: error instanceof Error ? error.message : 'Unknown error'
+            });
+        }
+    });
+    // Send keys to session
+    fastify.post('/:sessionId/keys', async (request, reply) => {
+        const { sessionId } = request.params;
+        const { keys } = request.body;
+        try {
+            const session = fastify.db.getTmuxSession(sessionId);
+            if (!session) {
+                return reply.code(404).send({ error: 'Session not found' });
+            }
+            // Send keys to tmux session
+            const tmuxProcess = spawn('tmux', ['send-keys', '-t', session.sessionName, keys]);
+            await new Promise((resolve, reject) => {
+                tmuxProcess.on('close', (code) => {
+                    if (code === 0)
+                        resolve(undefined);
+                    else
+                        reject(new Error(`Tmux exited with code ${code}`));
+                });
+                tmuxProcess.on('error', reject);
+            });
+            return { success: true };
+        }
+        catch (error) {
+            return reply.code(500).send({
+                error: 'Failed to send keys',
+                details: error instanceof Error ? error.message : 'Unknown error'
+            });
+        }
+    });
+    // Send interrupt (Ctrl+C) to session
+    fastify.post('/:sessionId/interrupt', async (request, reply) => {
+        const { sessionId } = request.params;
+        try {
+            const session = fastify.db.getTmuxSession(sessionId);
+            if (!session) {
+                return reply.code(404).send({ error: 'Session not found' });
+            }
+            // Send Ctrl+C to tmux session
+            const tmuxProcess = spawn('tmux', ['send-keys', '-t', session.sessionName, 'C-c']);
+            await new Promise((resolve, reject) => {
+                tmuxProcess.on('close', (code) => {
+                    if (code === 0)
+                        resolve(undefined);
+                    else
+                        reject(new Error(`Tmux exited with code ${code}`));
+                });
+                tmuxProcess.on('error', reject);
+            });
+            return { success: true };
+        }
+        catch (error) {
+            return reply.code(500).send({
+                error: 'Failed to send interrupt',
+                details: error instanceof Error ? error.message : 'Unknown error'
+            });
+        }
+    });
+    // Capture session output
+    fastify.get('/:sessionId/capture', async (request, reply) => {
+        const { sessionId } = request.params;
+        try {
+            const session = fastify.db.getTmuxSession(sessionId);
+            if (!session) {
+                return reply.code(404).send({ error: 'Session not found' });
+            }
+            // Capture tmux pane content
+            const captureProcess = spawn('tmux', ['capture-pane', '-t', session.sessionName, '-p']);
+            let output = '';
+            captureProcess.stdout.on('data', (data) => {
+                output += data.toString();
+            });
+            await new Promise((resolve, reject) => {
+                captureProcess.on('close', (code) => {
+                    if (code === 0)
+                        resolve(undefined);
+                    else
+                        reject(new Error(`Tmux exited with code ${code}`));
+                });
+                captureProcess.on('error', reject);
+            });
+            return { output };
+        }
+        catch (error) {
+            return reply.code(500).send({
+                error: 'Failed to capture output',
+                details: error instanceof Error ? error.message : 'Unknown error'
+            });
+        }
+    });
+    // Kill session
+    fastify.delete('/:sessionId', async (request, reply) => {
+        const { sessionId } = request.params;
+        const startTime = Date.now();
+        try {
+            const session = fastify.db.getTmuxSession(sessionId);
+            if (!session) {
+                console.warn(`[Session Termination] Session not found: ${sessionId}`);
+                return reply.code(404).send({ error: 'Session not found' });
+            }
+            console.log(`[Session Termination] Starting termination process for session ${session.sessionName} (ID: ${sessionId})`);
+            const cleanup = {
+                ttydKilled: false,
+                orphanedTtydCleaned: false,
+                tmuxKilled: false,
+                databaseUpdated: false
+            };
+            // Enhanced TTYd process cleanup with verification
+            if (session.ttydPid) {
+                console.log(`[Session Termination] Killing TTYd process ${session.ttydPid} for session ${session.sessionName}`);
+                try {
+                    // First try graceful termination
+                    process.kill(session.ttydPid, 'SIGTERM');
+                    // Wait a moment and verify process is killed
+                    await new Promise(resolve => setTimeout(resolve, 1000));
+                    try {
+                        process.kill(session.ttydPid, 0); // Check if process still exists
+                        console.warn(`[Session Termination] TTYd process ${session.ttydPid} still running after SIGTERM, using SIGKILL`);
+                        process.kill(session.ttydPid, 'SIGKILL');
+                    }
+                    catch (killError) {
+                        // Process doesn't exist anymore, which is what we want
+                        console.log(`[Session Termination] TTYd process ${session.ttydPid} successfully terminated`);
+                    }
+                    cleanup.ttydKilled = true;
+                }
+                catch (error) {
+                    console.error(`[Session Termination] Failed to kill TTYd process ${session.ttydPid}:`, error);
+                    // Continue with session cleanup even if ttyd kill fails
+                }
+            }
+            // Clean up any orphaned TTYd processes for this session
+            console.log(`[Session Termination] Cleaning up orphaned TTYd processes for session ${session.sessionName}`);
+            try {
+                await cleanupOrphanedTtydProcesses(session.sessionName);
+                cleanup.orphanedTtydCleaned = true;
+                console.log(`[Session Termination] Orphaned TTYd processes cleaned up for session ${session.sessionName}`);
+            }
+            catch (error) {
+                console.error(`[Session Termination] Failed to clean up orphaned TTYd processes:`, error);
+            }
+            // Kill tmux session with verification
+            console.log(`[Session Termination] Killing tmux session ${session.sessionName}`);
+            try {
+                const tmuxProcess = spawn('tmux', ['kill-session', '-t', session.sessionName]);
+                await new Promise((resolve, reject) => {
+                    let tmuxOutput = '';
+                    let tmuxError = '';
+                    tmuxProcess.stdout?.on('data', (data) => {
+                        tmuxOutput += data.toString();
+                    });
+                    tmuxProcess.stderr?.on('data', (data) => {
+                        tmuxError += data.toString();
+                    });
+                    tmuxProcess.on('close', (code) => {
+                        if (code === 0) {
+                            console.log(`[Session Termination] Tmux session ${session.sessionName} successfully killed`);
+                            resolve(undefined);
+                        }
+                        else {
+                            console.error(`[Session Termination] Tmux kill failed with code ${code}. Output: ${tmuxOutput}. Error: ${tmuxError}`);
+                            reject(new Error(`Tmux exited with code ${code}. Error: ${tmuxError}`));
+                        }
+                    });
+                    tmuxProcess.on('error', (error) => {
+                        console.error(`[Session Termination] Tmux process error:`, error);
+                        reject(error);
+                    });
+                });
+                cleanup.tmuxKilled = true;
+                // Verify tmux session is actually gone
+                await new Promise(resolve => setTimeout(resolve, 500));
+                try {
+                    const verifyProcess = spawn('tmux', ['has-session', '-t', session.sessionName]);
+                    await new Promise((resolve, reject) => {
+                        verifyProcess.on('close', (code) => {
+                            if (code === 0) {
+                                console.warn(`[Session Termination] WARNING: Tmux session ${session.sessionName} still exists after kill command`);
+                            }
+                            else {
+                                console.log(`[Session Termination] Verified: Tmux session ${session.sessionName} has been successfully terminated`);
+                            }
+                            resolve(undefined);
+                        });
+                        verifyProcess.on('error', () => resolve(undefined));
+                    });
+                }
+                catch (verifyError) {
+                    console.warn(`[Session Termination] Could not verify tmux session termination:`, verifyError);
+                }
+            }
+            catch (error) {
+                console.error(`[Session Termination] Failed to kill tmux session ${session.sessionName}:`, error);
+                throw error;
+            }
+            // Update database - clear ttyd info and set status to terminated
+            console.log(`[Session Termination] Updating database status for session ${session.sessionName}`);
+            try {
+                fastify.db.updateTmuxSession(session.id, {
+                    status: 'terminated',
+                    ttydPort: undefined,
+                    ttydPid: undefined
+                });
+                cleanup.databaseUpdated = true;
+                console.log(`[Session Termination] Database updated for session ${session.sessionName}`);
+            }
+            catch (error) {
+                console.error(`[Session Termination] Failed to update database for session ${session.sessionName}:`, error);
+                throw error;
+            }
+            // Emit session terminated event
+            fastify.io.emit('session:terminated', { sessionId, sessionName: session.sessionName });
+            // Final verification that everything is cleaned up
+            const verification = await verifySessionTermination(sessionId, session.sessionName, session.ttydPid);
+            const executionTime = Date.now() - startTime;
+            console.log(`[Session Termination] Successfully terminated session ${session.sessionName} in ${executionTime}ms. Cleanup status:`, cleanup);
+            if (!verification.allCleaned) {
+                console.warn(`[Session Termination] WARNING: Session ${session.sessionName} termination may be incomplete. Verification:`, verification);
+            }
+            return {
+                success: true,
+                cleanup,
+                verification,
+                executionTime,
+                sessionName: session.sessionName
+            };
+        }
+        catch (error) {
+            const executionTime = Date.now() - startTime;
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            console.error(`[Session Termination] Failed to terminate session ${sessionId} after ${executionTime}ms:`, errorMessage);
+            return reply.code(500).send({
+                error: 'Failed to kill session',
+                details: errorMessage,
+                executionTime
+            });
+        }
+    });
+    // Rename session by ID
+    fastify.put('/:sessionId/rename', async (request, reply) => {
+        const { sessionId } = request.params;
+        const { newName } = request.body;
+        try {
+            const session = fastify.db.getTmuxSession(sessionId);
+            if (!session) {
+                return reply.code(404).send({ error: 'Session not found' });
+            }
+            // Rename tmux session using current sessionName
+            const tmuxProcess = spawn('tmux', ['rename-session', '-t', session.sessionName, newName]);
+            await new Promise((resolve, reject) => {
+                tmuxProcess.on('close', (code) => {
+                    if (code === 0)
+                        resolve(undefined);
+                    else
+                        reject(new Error(`Tmux exited with code ${code}`));
+                });
+                tmuxProcess.on('error', reject);
+            });
+            // Update database
+            fastify.db.updateTmuxSession(session.id, { sessionName: newName });
+            return { success: true };
+        }
+        catch (error) {
+            return reply.code(500).send({
+                error: 'Failed to rename session',
+                details: error instanceof Error ? error.message : 'Unknown error'
+            });
+        }
+    });
+    // Toggle mouse mode in tmux session
+    fastify.post('/:sessionId/toggle-mouse', async (request, reply) => {
+        const { sessionId } = request.params;
+        try {
+            const session = fastify.db.getTmuxSession(sessionId);
+            if (!session) {
+                return reply.code(404).send({ error: 'Session not found' });
+            }
+            // Toggle mouse mode
+            const tmuxProcess = spawn('tmux', ['set-option', '-t', session.sessionName, 'mouse']);
+            await new Promise((resolve, reject) => {
+                tmuxProcess.on('close', (code) => {
+                    if (code === 0)
+                        resolve(undefined);
+                    else
+                        reject(new Error(`Tmux exited with code ${code}`));
+                });
+                tmuxProcess.on('error', reject);
+            });
+            return { success: true };
+        }
+        catch (error) {
+            return reply.code(500).send({
+                error: 'Failed to toggle mouse mode',
+                details: error instanceof Error ? error.message : 'Unknown error'
+            });
+        }
+    });
+    // Get ttyd URL for session
+    fastify.get('/:sessionId/ttyd', async (request, reply) => {
+        const { sessionId } = request.params;
+        try {
+            const session = fastify.db.getTmuxSession(sessionId);
+            if (!session) {
+                return reply.code(404).send({ error: 'Session not found' });
+            }
+            if (!session.ttydPort || !session.ttydPid) {
+                return reply.code(404).send({ error: 'TTYd not running for this session' });
+            }
+            // Check if process is still running
+            try {
+                process.kill(session.ttydPid, 0);
+                return {
+                    port: session.ttydPort,
+                    url: `http://localhost:${session.ttydPort}`,
+                    pid: session.ttydPid
+                };
+            }
+            catch {
+                // Process is not running, clean up
+                fastify.db.updateTmuxSession(session.id, {
+                    ttydPort: undefined,
+                    ttydPid: undefined
+                });
+                return reply.code(404).send({ error: 'TTYd process is no longer running' });
+            }
+        }
+        catch (error) {
+            return reply.code(500).send({
+                error: 'Failed to get ttyd URL',
+                details: error instanceof Error ? error.message : 'Unknown error'
+            });
+        }
+    });
+    // Start ttyd for browser terminal access
+    fastify.post('/:sessionId/ttyd', async (request, reply) => {
+        const { sessionId } = request.params;
+        try {
+            const session = fastify.db.getTmuxSession(sessionId);
+            if (!session) {
+                return reply.code(404).send({ error: 'Session not found' });
+            }
+            // Check if ttyd is already running for this session
+            if (session.ttydPort && session.ttydPid) {
+                // Check if process is still running
+                try {
+                    process.kill(session.ttydPid, 0);
+                    return { port: session.ttydPort, url: `http://localhost:${session.ttydPort}` };
+                }
+                catch {
+                    // Process is not running, clean up database
+                    fastify.db.updateTmuxSession(session.id, {
+                        ttydPort: undefined,
+                        ttydPid: undefined
+                    });
+                }
+            }
+            // Clean up any orphaned TTYd processes for this session
+            await cleanupOrphanedTtydProcesses(session.sessionName);
+            // Find available port with retry logic
+            let port;
+            let ttydProcess;
+            let attempts = 0;
+            const maxAttempts = 5;
+            while (attempts < maxAttempts) {
+                try {
+                    port = await findAvailablePort(7700 + attempts, 7800);
+                    // Verify tmux session exists before starting TTYd
+                    const tmuxCheckProcess = spawn('tmux', ['has-session', '-t', session.sessionName]);
+                    await new Promise((resolve, reject) => {
+                        tmuxCheckProcess.on('close', (code) => {
+                            if (code === 0)
+                                resolve(undefined);
+                            else
+                                reject(new Error(`Tmux session ${session.sessionName} does not exist`));
+                        });
+                        tmuxCheckProcess.on('error', reject);
+                    });
+                    // Start ttyd with proper error capturing and safer theme parameter
+                    ttydProcess = spawn('ttyd', [
+                        '-p', port.toString(),
+                        '-t', 'fontSize=14',
+                        '-t', 'theme={"background":"#1e1e1e","foreground":"#cccccc"}',
+                        '--writable',
+                        'tmux', 'attach-session', '-t', session.sessionName
+                    ], {
+                        detached: true,
+                        stdio: ['ignore', 'pipe', 'pipe'],
+                        env: { ...process.env, PATH: process.env.PATH }, // Ensure proper environment
+                        cwd: process.cwd() // Ensure proper working directory
+                    });
+                    // Capture stderr for debugging
+                    let stderrData = '';
+                    if (ttydProcess.stderr) {
+                        ttydProcess.stderr.on('data', (data) => {
+                            stderrData += data.toString();
+                        });
+                    }
+                    // Wait a moment to see if the process starts successfully
+                    await new Promise((resolve, reject) => {
+                        let resolved = false;
+                        const timeout = setTimeout(() => {
+                            if (!resolved) {
+                                resolved = true;
+                                resolve(true); // Assume success if no immediate error
+                            }
+                        }, 2000); // Increased timeout to 2 seconds
+                        ttydProcess.on('error', (err) => {
+                            if (!resolved) {
+                                resolved = true;
+                                clearTimeout(timeout);
+                                reject(new Error(`TTYd process error: ${err.message}. Stderr: ${stderrData}`));
+                            }
+                        });
+                        ttydProcess.on('exit', (code) => {
+                            if (!resolved && code !== 0) {
+                                resolved = true;
+                                clearTimeout(timeout);
+                                reject(new Error(`TTYd exited with code ${code}. Stderr: ${stderrData}`));
+                            }
+                        });
+                    });
+                    ttydProcess.unref();
+                    // Update database with ttyd info
+                    fastify.db.updateTmuxSession(session.id, {
+                        ttydPort: port,
+                        ttydPid: ttydProcess.pid
+                    });
+                    // Emit ttyd started event
+                    fastify.io.emit('session:ttyd-started', { sessionId, port });
+                    // Build the proxy URL: the agent's single tunnel + /terminal/:sessionId/
+                    // This replaces per-session cloudflared tunnels — the agent proxies ttyd
+                    // through its own API at /terminal/:sessionId
+                    const agentTunnel = getAgentTunnelUrl();
+                    const terminalProxyUrl = agentTunnel
+                        ? `${agentTunnel}/terminal/${sessionId}/`
+                        : null;
+                    console.log(`[TTYd] Started on port ${port}, proxy URL: ${terminalProxyUrl || 'no tunnel (local only)'}`);
+                    return {
+                        port,
+                        pid: ttydProcess.pid,
+                        url: `http://localhost:${port}`,
+                        terminalUrl: terminalProxyUrl,
+                    };
+                }
+                catch (error) {
+                    console.log(`TTYd start attempt ${attempts + 1} failed:`, error);
+                    attempts++;
+                    if (ttydProcess && ttydProcess.pid) {
+                        try {
+                            process.kill(ttydProcess.pid, 'SIGTERM');
+                        }
+                        catch {
+                            // Ignore kill errors
+                        }
+                    }
+                    if (attempts >= maxAttempts) {
+                        throw error;
+                    }
+                    // Wait before retry
+                    await new Promise(resolve => setTimeout(resolve, 500));
+                }
+            }
+        }
+        catch (error) {
+            return reply.code(500).send({
+                error: 'Failed to start ttyd',
+                details: error instanceof Error ? error.message : 'Unknown error'
+            });
+        }
+    });
+    // Verify session termination status
+    fastify.get('/:sessionId/termination-status', async (request, reply) => {
+        const { sessionId } = request.params;
+        try {
+            const session = fastify.db.getTmuxSession(sessionId);
+            if (!session) {
+                return reply.code(404).send({ error: 'Session not found' });
+            }
+            const verification = await verifySessionTermination(sessionId, session.sessionName, session.ttydPid);
+            return {
+                sessionId,
+                sessionName: session.sessionName,
+                databaseStatus: session.status,
+                verification,
+                isFullyTerminated: verification.allCleaned && session.status === 'terminated'
+            };
+        }
+        catch (error) {
+            return reply.code(500).send({
+                error: 'Failed to verify session termination',
+                details: error instanceof Error ? error.message : 'Unknown error'
+            });
+        }
+    });
+    // Stop ttyd for session
+    fastify.post('/:sessionId/ttyd/stop', async (request, reply) => {
+        const { sessionId } = request.params;
+        try {
+            const session = fastify.db.getTmuxSession(sessionId);
+            if (!session) {
+                return reply.code(404).send({ error: 'Session not found' });
+            }
+            if (!session.ttydPid) {
+                return reply.code(400).send({ error: 'No ttyd process running for this session' });
+            }
+            // Kill ttyd process
+            try {
+                process.kill(session.ttydPid, 'SIGTERM');
+            }
+            catch {
+                // Process might already be dead
+            }
+            // Update database
+            fastify.db.updateTmuxSession(session.id, {
+                ttydPort: undefined,
+                ttydPid: undefined
+            });
+            // Emit ttyd stopped event
+            fastify.io.emit('session:ttyd-stopped', { sessionId });
+            return { success: true };
+        }
+        catch (error) {
+            return reply.code(500).send({
+                error: 'Failed to stop ttyd',
+                details: error instanceof Error ? error.message : 'Unknown error'
+            });
+        }
+    });
+};
+// Helper function to clean up orphaned TTYd processes
+async function cleanupOrphanedTtydProcesses(sessionName) {
+    const { spawn } = await import('child_process');
+    try {
+        console.log(`[TTYd Cleanup] Searching for orphaned TTYd processes for session ${sessionName}`);
+        // Find TTYd processes for this session
+        const findProcess = spawn('pgrep', ['-f', `ttyd.*${sessionName}`]);
+        let processIds = '';
+        findProcess.stdout.on('data', (data) => {
+            processIds += data.toString();
+        });
+        await new Promise((resolve) => {
+            findProcess.on('close', resolve);
+        });
+        if (processIds.trim()) {
+            const pids = processIds.trim().split('\n').filter(pid => pid);
+            console.log(`[TTYd Cleanup] Found ${pids.length} orphaned TTYd processes for session ${sessionName}, cleaning up...`);
+            for (const pid of pids) {
+                try {
+                    const pidNum = parseInt(pid);
+                    console.log(`[TTYd Cleanup] Killing orphaned TTYd process ${pidNum}`);
+                    // First try graceful termination
+                    process.kill(pidNum, 'SIGTERM');
+                    // Wait a moment and verify process is killed
+                    await new Promise(resolve => setTimeout(resolve, 1000));
+                    try {
+                        process.kill(pidNum, 0); // Check if process still exists
+                        console.warn(`[TTYd Cleanup] TTYd process ${pidNum} still running after SIGTERM, using SIGKILL`);
+                        process.kill(pidNum, 'SIGKILL');
+                    }
+                    catch (killError) {
+                        // Process doesn't exist anymore, which is what we want
+                        console.log(`[TTYd Cleanup] TTYd process ${pidNum} successfully terminated`);
+                    }
+                }
+                catch (error) {
+                    console.error(`[TTYd Cleanup] Failed to kill TTYd process ${pid}:`, error);
+                }
+            }
+            // Wait a moment for processes to terminate
+            await new Promise(resolve => setTimeout(resolve, 500));
+            // Verify all processes are gone
+            try {
+                const verifyProcess = spawn('pgrep', ['-f', `ttyd.*${sessionName}`]);
+                let remainingProcesses = '';
+                verifyProcess.stdout.on('data', (data) => {
+                    remainingProcesses += data.toString();
+                });
+                await new Promise((resolve) => {
+                    verifyProcess.on('close', resolve);
+                });
+                if (remainingProcesses.trim()) {
+                    const remainingPids = remainingProcesses.trim().split('\n').filter(pid => pid);
+                    console.warn(`[TTYd Cleanup] WARNING: ${remainingPids.length} TTYd processes still running after cleanup: ${remainingPids.join(', ')}`);
+                }
+                else {
+                    console.log(`[TTYd Cleanup] All orphaned TTYd processes for session ${sessionName} successfully cleaned up`);
+                }
+            }
+            catch (verifyError) {
+                console.warn(`[TTYd Cleanup] Could not verify TTYd cleanup:`, verifyError);
+            }
+        }
+        else {
+            console.log(`[TTYd Cleanup] No orphaned TTYd processes found for session ${sessionName}`);
+        }
+    }
+    catch (error) {
+        console.error(`[TTYd Cleanup] Error cleaning up orphaned TTYd processes for session ${sessionName}:`, error);
+        throw error;
+    }
+}
+// Helper function to check if a process is still running
+async function isProcessRunning(pid) {
+    try {
+        process.kill(pid, 0); // Signal 0 just checks if process exists
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+}
+// Helper function to check if a tmux session exists
+async function doesTmuxSessionExist(sessionName) {
+    const { spawn } = await import('child_process');
+    try {
+        const checkProcess = spawn('tmux', ['has-session', '-t', sessionName]);
+        return new Promise((resolve) => {
+            checkProcess.on('close', (code) => {
+                resolve(code === 0);
+            });
+            checkProcess.on('error', () => {
+                resolve(false);
+            });
+        });
+    }
+    catch (error) {
+        return false;
+    }
+}
+// Helper function to get all running TTYd processes for a session
+async function getRunningTtydProcesses(sessionName) {
+    const { spawn } = await import('child_process');
+    try {
+        const findProcess = spawn('pgrep', ['-f', `ttyd.*${sessionName}`]);
+        let processIds = '';
+        findProcess.stdout.on('data', (data) => {
+            processIds += data.toString();
+        });
+        await new Promise((resolve) => {
+            findProcess.on('close', resolve);
+        });
+        if (processIds.trim()) {
+            return processIds.trim().split('\n').filter(pid => pid).map(pid => parseInt(pid));
+        }
+        return [];
+    }
+    catch (error) {
+        console.error(`[Process Check] Error getting TTYd processes for session ${sessionName}:`, error);
+        return [];
+    }
+}
+// Enhanced health check endpoint for session termination verification
+async function verifySessionTermination(sessionId, sessionName, ttydPid) {
+    console.log(`[Session Verification] Verifying termination of session ${sessionName} (ID: ${sessionId})`);
+    const tmuxExists = await doesTmuxSessionExist(sessionName);
+    const ttydProcesses = await getRunningTtydProcesses(sessionName);
+    const targetTtydRunning = ttydPid ? await isProcessRunning(ttydPid) : false;
+    const allCleaned = !tmuxExists && ttydProcesses.length === 0 && !targetTtydRunning;
+    console.log(`[Session Verification] Session ${sessionName} verification result:`, {
+        tmuxExists,
+        ttydProcesses,
+        targetTtydRunning,
+        allCleaned
+    });
+    return {
+        tmuxExists,
+        ttydProcesses,
+        targetTtydRunning,
+        allCleaned
+    };
+}
+// Helper function to find available port with better detection
+async function findAvailablePort(startPort, endPort) {
+    const net = await import('net');
+    const { spawn } = await import('child_process');
+    for (let port = startPort; port <= endPort; port++) {
+        // First check if the port is bound using netstat/lsof
+        const isPortOccupied = await new Promise((resolve) => {
+            const checkProcess = spawn('lsof', ['-i', `:${port}`, '-t']);
+            let hasOutput = false;
+            checkProcess.stdout.on('data', (_data) => {
+                hasOutput = true;
+            });
+            checkProcess.on('close', (code) => {
+                // If lsof found processes using the port, it's occupied
+                resolve(hasOutput);
+            });
+            checkProcess.on('error', () => {
+                // If lsof fails, fall back to basic check
+                resolve(false);
+            });
+            // Timeout the check
+            setTimeout(() => {
+                checkProcess.kill();
+                resolve(false);
+            }, 1000);
+        });
+        if (isPortOccupied) {
+            continue;
+        }
+        // Double-check by trying to bind to the port
+        const available = await new Promise((resolve) => {
+            const server = net.createServer();
+            server.once('error', () => resolve(false));
+            server.once('listening', () => {
+                server.close();
+                resolve(true);
+            });
+            server.listen(port, 'localhost');
+        });
+        if (available) {
+            return port;
+        }
+    }
+    throw new Error(`No available ports between ${startPort} and ${endPort}`);
+}
+// Get all tmux sessions on the system
+async function getSystemTmuxSessions() {
+    const { spawn } = await import('child_process');
+    try {
+        console.log('[System Sessions] Discovering all tmux sessions on system');
+        const listProcess = spawn('tmux', ['list-sessions', '-F', '#{session_name}|#{session_attached}|#{session_windows}|#{session_created}|#{session_activity}|#{session_id}']);
+        let output = '';
+        let stderr = '';
+        listProcess.stdout.on('data', (data) => {
+            output += data.toString();
+        });
+        listProcess.stderr.on('data', (data) => {
+            stderr += data.toString();
+        });
+        await new Promise((resolve, reject) => {
+            listProcess.on('close', (code) => {
+                if (code === 0) {
+                    resolve(undefined);
+                }
+                else {
+                    // If no sessions exist, tmux returns exit code 1
+                    if (code === 1 && stderr.includes('no server running')) {
+                        resolve(undefined);
+                    }
+                    else {
+                        reject(new Error(`tmux list-sessions failed with code ${code}: ${stderr}`));
+                    }
+                }
+            });
+            listProcess.on('error', reject);
+        });
+        if (!output.trim()) {
+            console.log('[System Sessions] No tmux sessions found on system');
+            return [];
+        }
+        const sessions = output.trim().split('\n').map(line => {
+            const [name, attached, windows, created, lastActivity, sessionId] = line.split('|');
+            return {
+                name,
+                attached: attached === '1',
+                windows: parseInt(windows) || 0,
+                created: new Date(parseInt(created) * 1000).toISOString(),
+                lastActivity: new Date(parseInt(lastActivity) * 1000).toISOString(),
+                sessionId,
+            };
+        });
+        console.log(`[System Sessions] Found ${sessions.length} tmux sessions on system`);
+        return sessions;
+    }
+    catch (error) {
+        console.error('[System Sessions] Error getting system tmux sessions:', error);
+        // Return empty array instead of throwing - no sessions is not an error
+        return [];
+    }
+}
+// Get all ttyd processes on the system
+async function getSystemTtydProcesses() {
+    const { spawn } = await import('child_process');
+    try {
+        console.log('[System Processes] Discovering all ttyd processes on system');
+        // Use ps to find ttyd processes with detailed information
+        const psProcess = spawn('ps', ['aux']);
+        let output = '';
+        psProcess.stdout.on('data', (data) => {
+            output += data.toString();
+        });
+        await new Promise((resolve, reject) => {
+            psProcess.on('close', (code) => {
+                if (code === 0)
+                    resolve(undefined);
+                else
+                    reject(new Error(`ps command failed with code ${code}`));
+            });
+            psProcess.on('error', reject);
+        });
+        // Parse ps output to find ttyd processes
+        const lines = output.split('\n');
+        const ttydProcesses = [];
+        for (const line of lines) {
+            if (line.includes('ttyd') && !line.includes('grep')) {
+                const parts = line.trim().split(/\s+/);
+                if (parts.length >= 11) {
+                    const user = parts[0];
+                    const pid = parseInt(parts[1]);
+                    const startTime = parts[8];
+                    const command = parts.slice(10).join(' ');
+                    // Extract port from command line
+                    let port = 0;
+                    let sessionName = '';
+                    const portMatch = command.match(/-p\s+(\d+)/);
+                    if (portMatch) {
+                        port = parseInt(portMatch[1]);
+                    }
+                    // Extract session name from tmux attach command
+                    const sessionMatch = command.match(/tmux\s+attach-session\s+-t\s+(\S+)/);
+                    if (sessionMatch) {
+                        sessionName = sessionMatch[1];
+                    }
+                    ttydProcesses.push({
+                        pid,
+                        port,
+                        sessionName,
+                        command,
+                        startTime,
+                        user,
+                    });
+                }
+            }
+        }
+        console.log(`[System Processes] Found ${ttydProcesses.length} ttyd processes on system`);
+        return ttydProcesses;
+    }
+    catch (error) {
+        console.error('[System Processes] Error getting system ttyd processes:', error);
+        return [];
+    }
+}
+// Kill multiple tmux sessions
+async function killSystemTmuxSessions(sessionNames, force = false) {
+    const { spawn } = await import('child_process');
+    const results = [];
+    console.log(`[System Sessions] Killing ${sessionNames.length} tmux sessions, force: ${force}`);
+    for (const sessionName of sessionNames) {
+        try {
+            console.log(`[System Sessions] Killing tmux session: ${sessionName}`);
+            const killProcess = spawn('tmux', ['kill-session', '-t', sessionName]);
+            await new Promise((resolve, reject) => {
+                let stderr = '';
+                killProcess.stderr?.on('data', (data) => {
+                    stderr += data.toString();
+                });
+                killProcess.on('close', (code) => {
+                    if (code === 0) {
+                        resolve(undefined);
+                    }
+                    else {
+                        reject(new Error(`tmux kill-session failed with code ${code}: ${stderr}`));
+                    }
+                });
+                killProcess.on('error', reject);
+            });
+            results.push({
+                target: sessionName,
+                success: true,
+            });
+            console.log(`[System Sessions] Successfully killed tmux session: ${sessionName}`);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            console.error(`[System Sessions] Failed to kill tmux session ${sessionName}:`, errorMessage);
+            results.push({
+                target: sessionName,
+                success: false,
+                error: errorMessage,
+            });
+        }
+    }
+    return results;
+}
+// Kill multiple ttyd processes
+async function killSystemTtydProcesses(pids, force = false) {
+    const results = [];
+    console.log(`[System Processes] Killing ${pids.length} ttyd processes, force: ${force}`);
+    for (const pid of pids) {
+        try {
+            console.log(`[System Processes] Killing ttyd process: ${pid}`);
+            const signal = force ? 'SIGKILL' : 'SIGTERM';
+            process.kill(pid, signal);
+            // Wait a moment and verify process is killed
+            await new Promise(resolve => setTimeout(resolve, 1000));
+            try {
+                process.kill(pid, 0); // Check if process still exists
+                if (!force) {
+                    console.warn(`[System Processes] Process ${pid} still running after SIGTERM, using SIGKILL`);
+                    process.kill(pid, 'SIGKILL');
+                }
+                else {
+                    throw new Error(`Process ${pid} still running after SIGKILL`);
+                }
+            }
+            catch (killError) {
+                // Process doesn't exist anymore, which is what we want
+                console.log(`[System Processes] Successfully killed ttyd process: ${pid}`);
+            }
+            results.push({
+                target: pid.toString(),
+                success: true,
+            });
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            console.error(`[System Processes] Failed to kill ttyd process ${pid}:`, errorMessage);
+            results.push({
+                target: pid.toString(),
+                success: false,
+                error: errorMessage,
+            });
+        }
+    }
+    return results;
+}
+//# sourceMappingURL=tmux.js.map