@burdenoff/vibe-agent 1.3.2 → 2.1.0

package/dist/routes/tmux.js

@@ -1,1287 +0,0 @@
-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