@burdenoff/vibe-agent 1.0.0 → 1.0.2

package/dist/routes/tmux.js

@@ -1,19 +1,19 @@
-import { spawn } from 'child_process';
-import { getAgentTunnelUrl } from './tunnel.js';
+import { spawn } from "child_process";
+import { getAgentTunnelUrl } from "./tunnel.js";
 export const tmuxRoutes = async (fastify) => {
     // Get all tmux sessions
-    fastify.get('/', async (_request, _reply) => {
+    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) => {
+    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);
+            const enrichedSessions = systemSessions.map((systemSession) => {
+                const managedSession = managedSessions.find((ms) => ms.sessionName === systemSession.name);
                 return {
                     ...systemSession,
                     isManaged: !!managedSession,
@@ -28,29 +28,29 @@ export const tmuxRoutes = async (fastify) => {
         }
         catch (error) {
             return reply.code(500).send({
-                error: 'Failed to get system tmux sessions',
-                details: error instanceof Error ? error.message : 'Unknown error'
+                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) => {
+    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'
+                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) => {
+    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' });
+            return reply.code(400).send({ error: "sessionNames array is required" });
         }
         try {
             const results = await killSystemTmuxSessions(sessionNames, force);
@@ -58,16 +58,16 @@ export const tmuxRoutes = async (fastify) => {
         }
         catch (error) {
             return reply.code(500).send({
-                error: 'Failed to kill system tmux sessions',
-                details: error instanceof Error ? error.message : 'Unknown error'
+                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) => {
+    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' });
+            return reply.code(400).send({ error: "pids array is required" });
         }
         try {
             const results = await killSystemTtydProcesses(pids, force);
@@ -75,17 +75,17 @@ export const tmuxRoutes = async (fastify) => {
         }
         catch (error) {
             return reply.code(500).send({
-                error: 'Failed to kill system ttyd processes',
-                details: error instanceof Error ? error.message : 'Unknown error'
+                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) => {
+    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 reply.code(404).send({ error: "Session not found" });
         }
         return { session };
     });
@@ -93,7 +93,7 @@ export const tmuxRoutes = async (fastify) => {
     // 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) => {
+    fastify.post("/health-check", async (request, _reply) => {
         const { sessionIds } = request.body;
         if (!sessionIds || !Array.isArray(sessionIds)) {
             return { results: [] };
@@ -102,16 +102,26 @@ export const tmuxRoutes = async (fastify) => {
         for (const sessionId of sessionIds) {
             const dbSession = fastify.db.getTmuxSession(sessionId);
             if (!dbSession) {
-                results.push({ sessionId, tmuxAlive: false, ttydAlive: false, ttydPort: null, status: 'unknown' });
+                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]);
+                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));
+                    checkProc.on("close", (code) => resolve(code === 0));
+                    checkProc.on("error", () => resolve(false));
                 });
             }
             catch {
@@ -128,7 +138,7 @@ export const tmuxRoutes = async (fastify) => {
                     ttydAlive = false;
                 }
             }
-            const status = tmuxAlive ? 'running' : 'dead';
+            const status = tmuxAlive ? "running" : "dead";
             results.push({
                 sessionId,
                 tmuxAlive,
@@ -140,19 +150,23 @@ export const tmuxRoutes = async (fastify) => {
         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;
+    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';
+        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 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));
+                    checkProc.on("close", (code) => resolve(code === 0));
+                    checkProc.on("error", () => resolve(false));
                 });
                 if (checkOk) {
                     return { session: existingDbSession, reused: true };
@@ -162,10 +176,10 @@ export const tmuxRoutes = async (fastify) => {
             }
             // 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 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));
+                hasProc.on("close", (code) => resolve(code === 0));
+                hasProc.on("error", () => resolve(false));
             });
             if (tmuxExists) {
                 // tmux session exists but NOT in our DB — adopt it
@@ -174,38 +188,42 @@ export const tmuxRoutes = async (fastify) => {
             else {
                 // Check if the name conflicts with another DB entry, make unique
                 const existingSessions = fastify.db.getAllTmuxSessions();
-                const existingNames = existingSessions.map(s => s.sessionName);
+                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];
+                const tmuxCmd = ["tmux", "new-session", "-d", "-s", finalSessionName];
                 if (startDirectory)
-                    tmuxCmd.push('-c', 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) => {
+                    tmuxProcess.on("close", (code) => {
                         if (code === 0)
                             resolve(undefined);
                         else
                             reject(new Error(`Tmux exited with code ${code}`));
                     });
-                    tmuxProcess.on('error', reject);
+                    tmuxProcess.on("error", reject);
                 });
                 // Wait for tmux to be ready
-                await new Promise(resolve => setTimeout(resolve, 100));
+                await new Promise((resolve) => setTimeout(resolve, 100));
                 // Verify
-                const verifyProcess = spawn('tmux', ['has-session', '-t', finalSessionName]);
+                const verifyProcess = spawn("tmux", [
+                    "has-session",
+                    "-t",
+                    finalSessionName,
+                ]);
                 await new Promise((resolve, reject) => {
-                    verifyProcess.on('close', (code) => {
+                    verifyProcess.on("close", (code) => {
                         if (code === 0)
                             resolve(undefined);
                         else
                             reject(new Error(`Failed to verify tmux session ${finalSessionName}`));
                     });
-                    verifyProcess.on('error', reject);
+                    verifyProcess.on("error", reject);
                 });
             }
             // Upsert database entry (handles both new creation and adoption)
@@ -214,7 +232,7 @@ export const tmuxRoutes = async (fastify) => {
                 // Update existing record
                 fastify.db.updateTmuxSession(sessionId, {
                     sessionName: finalSessionName,
-                    status: 'active',
+                    status: "active",
                 });
                 session = fastify.db.getTmuxSession(sessionId);
             }
@@ -225,171 +243,192 @@ export const tmuxRoutes = async (fastify) => {
                     projectId,
                     windowName: finalWindowName,
                     command,
-                    status: 'active',
+                    status: "active",
                     ttydPort: undefined,
                     ttydPid: undefined,
                 });
             }
             // Emit session created event
-            fastify.io.emit('session:created', session);
+            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'
+                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) => {
+    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' });
+                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']);
+            const tmuxProcess = spawn("tmux", [
+                "send-keys",
+                "-t",
+                session.sessionName,
+                command,
+                "Enter",
+            ]);
             await new Promise((resolve, reject) => {
-                tmuxProcess.on('close', (code) => {
+                tmuxProcess.on("close", (code) => {
                     if (code === 0)
                         resolve(undefined);
                     else
                         reject(new Error(`Tmux exited with code ${code}`));
                 });
-                tmuxProcess.on('error', reject);
+                tmuxProcess.on("error", reject);
             });
             // Emit command executed event
-            fastify.io.emit('session:command', { sessionId, command });
+            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'
+                error: "Failed to execute command",
+                details: error instanceof Error ? error.message : "Unknown error",
             });
         }
     });
     // Send keys to session
-    fastify.post('/:sessionId/keys', async (request, reply) => {
+    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' });
+                return reply.code(404).send({ error: "Session not found" });
             }
             // Send keys to tmux session
-            const tmuxProcess = spawn('tmux', ['send-keys', '-t', session.sessionName, keys]);
+            const tmuxProcess = spawn("tmux", [
+                "send-keys",
+                "-t",
+                session.sessionName,
+                keys,
+            ]);
             await new Promise((resolve, reject) => {
-                tmuxProcess.on('close', (code) => {
+                tmuxProcess.on("close", (code) => {
                     if (code === 0)
                         resolve(undefined);
                     else
                         reject(new Error(`Tmux exited with code ${code}`));
                 });
-                tmuxProcess.on('error', reject);
+                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'
+                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) => {
+    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' });
+                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']);
+            const tmuxProcess = spawn("tmux", [
+                "send-keys",
+                "-t",
+                session.sessionName,
+                "C-c",
+            ]);
             await new Promise((resolve, reject) => {
-                tmuxProcess.on('close', (code) => {
+                tmuxProcess.on("close", (code) => {
                     if (code === 0)
                         resolve(undefined);
                     else
                         reject(new Error(`Tmux exited with code ${code}`));
                 });
-                tmuxProcess.on('error', reject);
+                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'
+                error: "Failed to send interrupt",
+                details: error instanceof Error ? error.message : "Unknown error",
             });
         }
     });
     // Capture session output
-    fastify.get('/:sessionId/capture', async (request, reply) => {
+    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' });
+                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) => {
+            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) => {
+                captureProcess.on("close", (code) => {
                     if (code === 0)
                         resolve(undefined);
                     else
                         reject(new Error(`Tmux exited with code ${code}`));
                 });
-                captureProcess.on('error', reject);
+                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'
+                error: "Failed to capture output",
+                details: error instanceof Error ? error.message : "Unknown error",
             });
         }
     });
     // Kill session
-    fastify.delete('/:sessionId', async (request, reply) => {
+    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' });
+                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
+                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');
+                    process.kill(session.ttydPid, "SIGTERM");
                     // Wait a moment and verify process is killed
-                    await new Promise(resolve => setTimeout(resolve, 1000));
+                    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');
+                        process.kill(session.ttydPid, "SIGKILL");
                     }
                     catch (killError) {
                         // Process doesn't exist anymore, which is what we want
@@ -415,17 +454,21 @@ export const tmuxRoutes = async (fastify) => {
             // Kill tmux session with verification
             console.log(`[Session Termination] Killing tmux session ${session.sessionName}`);
             try {
-                const tmuxProcess = spawn('tmux', ['kill-session', '-t', session.sessionName]);
+                const tmuxProcess = spawn("tmux", [
+                    "kill-session",
+                    "-t",
+                    session.sessionName,
+                ]);
                 await new Promise((resolve, reject) => {
-                    let tmuxOutput = '';
-                    let tmuxError = '';
-                    tmuxProcess.stdout?.on('data', (data) => {
+                    let tmuxOutput = "";
+                    let tmuxError = "";
+                    tmuxProcess.stdout?.on("data", (data) => {
                         tmuxOutput += data.toString();
                     });
-                    tmuxProcess.stderr?.on('data', (data) => {
+                    tmuxProcess.stderr?.on("data", (data) => {
                         tmuxError += data.toString();
                     });
-                    tmuxProcess.on('close', (code) => {
+                    tmuxProcess.on("close", (code) => {
                         if (code === 0) {
                             console.log(`[Session Termination] Tmux session ${session.sessionName} successfully killed`);
                             resolve(undefined);
@@ -435,18 +478,22 @@ export const tmuxRoutes = async (fastify) => {
                             reject(new Error(`Tmux exited with code ${code}. Error: ${tmuxError}`));
                         }
                     });
-                    tmuxProcess.on('error', (error) => {
+                    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));
+                await new Promise((resolve) => setTimeout(resolve, 500));
                 try {
-                    const verifyProcess = spawn('tmux', ['has-session', '-t', session.sessionName]);
+                    const verifyProcess = spawn("tmux", [
+                        "has-session",
+                        "-t",
+                        session.sessionName,
+                    ]);
                     await new Promise((resolve, reject) => {
-                        verifyProcess.on('close', (code) => {
+                        verifyProcess.on("close", (code) => {
                             if (code === 0) {
                                 console.warn(`[Session Termination] WARNING: Tmux session ${session.sessionName} still exists after kill command`);
                             }
@@ -455,7 +502,7 @@ export const tmuxRoutes = async (fastify) => {
                             }
                             resolve(undefined);
                         });
-                        verifyProcess.on('error', () => resolve(undefined));
+                        verifyProcess.on("error", () => resolve(undefined));
                     });
                 }
                 catch (verifyError) {
@@ -470,9 +517,9 @@ export const tmuxRoutes = async (fastify) => {
             console.log(`[Session Termination] Updating database status for session ${session.sessionName}`);
             try {
                 fastify.db.updateTmuxSession(session.id, {
-                    status: 'terminated',
+                    status: "terminated",
                     ttydPort: undefined,
-                    ttydPid: undefined
+                    ttydPid: undefined,
                 });
                 cleanup.databaseUpdated = true;
                 console.log(`[Session Termination] Database updated for session ${session.sessionName}`);
@@ -482,7 +529,10 @@ export const tmuxRoutes = async (fastify) => {
                 throw error;
             }
             // Emit session terminated event
-            fastify.io.emit('session:terminated', { sessionId, sessionName: session.sessionName });
+            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;
@@ -495,39 +545,44 @@ export const tmuxRoutes = async (fastify) => {
                 cleanup,
                 verification,
                 executionTime,
-                sessionName: session.sessionName
+                sessionName: session.sessionName,
             };
         }
         catch (error) {
             const executionTime = Date.now() - startTime;
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            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',
+                error: "Failed to kill session",
                 details: errorMessage,
-                executionTime
+                executionTime,
             });
         }
     });
     // Rename session by ID
-    fastify.put('/:sessionId/rename', async (request, reply) => {
+    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' });
+                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]);
+            const tmuxProcess = spawn("tmux", [
+                "rename-session",
+                "-t",
+                session.sessionName,
+                newName,
+            ]);
             await new Promise((resolve, reject) => {
-                tmuxProcess.on('close', (code) => {
+                tmuxProcess.on("close", (code) => {
                     if (code === 0)
                         resolve(undefined);
                     else
                         reject(new Error(`Tmux exited with code ${code}`));
                 });
-                tmuxProcess.on('error', reject);
+                tmuxProcess.on("error", reject);
             });
             // Update database
             fastify.db.updateTmuxSession(session.id, { sessionName: newName });
@@ -535,49 +590,56 @@ export const tmuxRoutes = async (fastify) => {
         }
         catch (error) {
             return reply.code(500).send({
-                error: 'Failed to rename session',
-                details: error instanceof Error ? error.message : 'Unknown error'
+                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) => {
+    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' });
+                return reply.code(404).send({ error: "Session not found" });
             }
             // Toggle mouse mode
-            const tmuxProcess = spawn('tmux', ['set-option', '-t', session.sessionName, 'mouse']);
+            const tmuxProcess = spawn("tmux", [
+                "set-option",
+                "-t",
+                session.sessionName,
+                "mouse",
+            ]);
             await new Promise((resolve, reject) => {
-                tmuxProcess.on('close', (code) => {
+                tmuxProcess.on("close", (code) => {
                     if (code === 0)
                         resolve(undefined);
                     else
                         reject(new Error(`Tmux exited with code ${code}`));
                 });
-                tmuxProcess.on('error', reject);
+                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'
+                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) => {
+    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' });
+                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' });
+                return reply
+                    .code(404)
+                    .send({ error: "TTYd not running for this session" });
             }
             // Check if process is still running
             try {
@@ -585,45 +647,50 @@ export const tmuxRoutes = async (fastify) => {
                 return {
                     port: session.ttydPort,
                     url: `http://localhost:${session.ttydPort}`,
-                    pid: session.ttydPid
+                    pid: session.ttydPid,
                 };
             }
             catch {
                 // Process is not running, clean up
                 fastify.db.updateTmuxSession(session.id, {
                     ttydPort: undefined,
-                    ttydPid: undefined
+                    ttydPid: undefined,
                 });
-                return reply.code(404).send({ error: 'TTYd process is no longer running' });
+                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'
+                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) => {
+    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' });
+                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}` };
+                    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
+                        ttydPid: undefined,
                     });
                 }
             }
@@ -638,33 +705,43 @@ export const tmuxRoutes = async (fastify) => {
                 try {
                     port = await findAvailablePort(7700 + attempts, 7800);
                     // Verify tmux session exists before starting TTYd
-                    const tmuxCheckProcess = spawn('tmux', ['has-session', '-t', session.sessionName]);
+                    const tmuxCheckProcess = spawn("tmux", [
+                        "has-session",
+                        "-t",
+                        session.sessionName,
+                    ]);
                     await new Promise((resolve, reject) => {
-                        tmuxCheckProcess.on('close', (code) => {
+                        tmuxCheckProcess.on("close", (code) => {
                             if (code === 0)
                                 resolve(undefined);
                             else
                                 reject(new Error(`Tmux session ${session.sessionName} does not exist`));
                         });
-                        tmuxCheckProcess.on('error', reject);
+                        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
+                    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'],
+                        stdio: ["ignore", "pipe", "pipe"],
                         env: { ...process.env, PATH: process.env.PATH }, // Ensure proper environment
-                        cwd: process.cwd() // Ensure proper working directory
+                        cwd: process.cwd(), // Ensure proper working directory
                     });
                     // Capture stderr for debugging
-                    let stderrData = '';
+                    let stderrData = "";
                     if (ttydProcess.stderr) {
-                        ttydProcess.stderr.on('data', (data) => {
+                        ttydProcess.stderr.on("data", (data) => {
                             stderrData += data.toString();
                         });
                     }
@@ -677,14 +754,14 @@ export const tmuxRoutes = async (fastify) => {
                                 resolve(true); // Assume success if no immediate error
                             }
                         }, 2000); // Increased timeout to 2 seconds
-                        ttydProcess.on('error', (err) => {
+                        ttydProcess.on("error", (err) => {
                             if (!resolved) {
                                 resolved = true;
                                 clearTimeout(timeout);
                                 reject(new Error(`TTYd process error: ${err.message}. Stderr: ${stderrData}`));
                             }
                         });
-                        ttydProcess.on('exit', (code) => {
+                        ttydProcess.on("exit", (code) => {
                             if (!resolved && code !== 0) {
                                 resolved = true;
                                 clearTimeout(timeout);
@@ -696,10 +773,10 @@ export const tmuxRoutes = async (fastify) => {
                     // Update database with ttyd info
                     fastify.db.updateTmuxSession(session.id, {
                         ttydPort: port,
-                        ttydPid: ttydProcess.pid
+                        ttydPid: ttydProcess.pid,
                     });
                     // Emit ttyd started event
-                    fastify.io.emit('session:ttyd-started', { sessionId, port });
+                    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
@@ -707,7 +784,7 @@ export const tmuxRoutes = async (fastify) => {
                     const terminalProxyUrl = agentTunnel
                         ? `${agentTunnel}/terminal/${sessionId}/`
                         : null;
-                    console.log(`[TTYd] Started on port ${port}, proxy URL: ${terminalProxyUrl || 'no tunnel (local only)'}`);
+                    console.log(`[TTYd] Started on port ${port}, proxy URL: ${terminalProxyUrl || "no tunnel (local only)"}`);
                     return {
                         port,
                         pid: ttydProcess.pid,
@@ -720,7 +797,7 @@ export const tmuxRoutes = async (fastify) => {
                     attempts++;
                     if (ttydProcess && ttydProcess.pid) {
                         try {
-                            process.kill(ttydProcess.pid, 'SIGTERM');
+                            process.kill(ttydProcess.pid, "SIGTERM");
                         }
                         catch {
                             // Ignore kill errors
@@ -730,24 +807,24 @@ export const tmuxRoutes = async (fastify) => {
                         throw error;
                     }
                     // Wait before retry
-                    await new Promise(resolve => setTimeout(resolve, 500));
+                    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'
+                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) => {
+    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' });
+                return reply.code(404).send({ error: "Session not found" });
             }
             const verification = await verifySessionTermination(sessionId, session.sessionName, session.ttydPid);
             return {
@@ -755,30 +832,32 @@ export const tmuxRoutes = async (fastify) => {
                 sessionName: session.sessionName,
                 databaseStatus: session.status,
                 verification,
-                isFullyTerminated: verification.allCleaned && session.status === 'terminated'
+                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'
+                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) => {
+    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' });
+                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' });
+                return reply
+                    .code(400)
+                    .send({ error: "No ttyd process running for this session" });
             }
             // Kill ttyd process
             try {
-                process.kill(session.ttydPid, 'SIGTERM');
+                process.kill(session.ttydPid, "SIGTERM");
             }
             catch {
                 // Process might already be dead
@@ -786,49 +865,52 @@ export const tmuxRoutes = async (fastify) => {
             // Update database
             fastify.db.updateTmuxSession(session.id, {
                 ttydPort: undefined,
-                ttydPid: undefined
+                ttydPid: undefined,
             });
             // Emit ttyd stopped event
-            fastify.io.emit('session:ttyd-stopped', { sessionId });
+            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'
+                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');
+    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) => {
+        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);
+            findProcess.on("close", resolve);
         });
         if (processIds.trim()) {
-            const pids = processIds.trim().split('\n').filter(pid => pid);
+            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');
+                    process.kill(pidNum, "SIGTERM");
                     // Wait a moment and verify process is killed
-                    await new Promise(resolve => setTimeout(resolve, 1000));
+                    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');
+                        process.kill(pidNum, "SIGKILL");
                     }
                     catch (killError) {
                         // Process doesn't exist anymore, which is what we want
@@ -840,20 +922,23 @@ async function cleanupOrphanedTtydProcesses(sessionName) {
                 }
             }
             // Wait a moment for processes to terminate
-            await new Promise(resolve => setTimeout(resolve, 500));
+            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) => {
+                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);
+                    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(', ')}`);
+                    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`);
@@ -884,14 +969,14 @@ async function isProcessRunning(pid) {
 }
 // Helper function to check if a tmux session exists
 async function doesTmuxSessionExist(sessionName) {
-    const { spawn } = await import('child_process');
+    const { spawn } = await import("child_process");
     try {
-        const checkProcess = spawn('tmux', ['has-session', '-t', sessionName]);
+        const checkProcess = spawn("tmux", ["has-session", "-t", sessionName]);
         return new Promise((resolve) => {
-            checkProcess.on('close', (code) => {
+            checkProcess.on("close", (code) => {
                 resolve(code === 0);
             });
-            checkProcess.on('error', () => {
+            checkProcess.on("error", () => {
                 resolve(false);
             });
         });
@@ -902,18 +987,22 @@ async function doesTmuxSessionExist(sessionName) {
 }
 // Helper function to get all running TTYd processes for a session
 async function getRunningTtydProcesses(sessionName) {
-    const { spawn } = await import('child_process');
+    const { spawn } = await import("child_process");
     try {
-        const findProcess = spawn('pgrep', ['-f', `ttyd.*${sessionName}`]);
-        let processIds = '';
-        findProcess.stdout.on('data', (data) => {
+        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);
+            findProcess.on("close", resolve);
         });
         if (processIds.trim()) {
-            return processIds.trim().split('\n').filter(pid => pid).map(pid => parseInt(pid));
+            return processIds
+                .trim()
+                .split("\n")
+                .filter((pid) => pid)
+                .map((pid) => parseInt(pid));
         }
         return [];
     }
@@ -933,32 +1022,32 @@ async function verifySessionTermination(sessionId, sessionName, ttydPid) {
         tmuxExists,
         ttydProcesses,
         targetTtydRunning,
-        allCleaned
+        allCleaned,
     });
     return {
         tmuxExists,
         ttydProcesses,
         targetTtydRunning,
-        allCleaned
+        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');
+    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']);
+            const checkProcess = spawn("lsof", ["-i", `:${port}`, "-t"]);
             let hasOutput = false;
-            checkProcess.stdout.on('data', (_data) => {
+            checkProcess.stdout.on("data", (_data) => {
                 hasOutput = true;
             });
-            checkProcess.on('close', (code) => {
+            checkProcess.on("close", (code) => {
                 // If lsof found processes using the port, it's occupied
                 resolve(hasOutput);
             });
-            checkProcess.on('error', () => {
+            checkProcess.on("error", () => {
                 // If lsof fails, fall back to basic check
                 resolve(false);
             });
@@ -974,12 +1063,12 @@ async function findAvailablePort(startPort, endPort) {
         // 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.once("error", () => resolve(false));
+            server.once("listening", () => {
                 server.close();
                 resolve(true);
             });
-            server.listen(port, 'localhost');
+            server.listen(port, "localhost");
         });
         if (available) {
             return port;
@@ -989,26 +1078,30 @@ async function findAvailablePort(startPort, endPort) {
 }
 // Get all tmux sessions on the system
 async function getSystemTmuxSessions() {
-    const { spawn } = await import('child_process');
+    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) => {
+        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) => {
+        listProcess.stderr.on("data", (data) => {
             stderr += data.toString();
         });
         await new Promise((resolve, reject) => {
-            listProcess.on('close', (code) => {
+            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')) {
+                    if (code === 1 && stderr.includes("no server running")) {
                         resolve(undefined);
                     }
                     else {
@@ -1016,17 +1109,20 @@ async function getSystemTmuxSessions() {
                     }
                 }
             });
-            listProcess.on('error', reject);
+            listProcess.on("error", reject);
         });
         if (!output.trim()) {
-            console.log('[System Sessions] No tmux sessions found on system');
+            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('|');
+        const sessions = output
+            .trim()
+            .split("\n")
+            .map((line) => {
+            const [name, attached, windows, created, lastActivity, sessionId] = line.split("|");
             return {
                 name,
-                attached: attached === '1',
+                attached: attached === "1",
                 windows: parseInt(windows) || 0,
                 created: new Date(parseInt(created) * 1000).toISOString(),
                 lastActivity: new Date(parseInt(lastActivity) * 1000).toISOString(),
@@ -1037,45 +1133,45 @@ async function getSystemTmuxSessions() {
         return sessions;
     }
     catch (error) {
-        console.error('[System Sessions] Error getting system tmux sessions:', 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');
+    const { spawn } = await import("child_process");
     try {
-        console.log('[System Processes] Discovering all ttyd processes on system');
+        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) => {
+        const psProcess = spawn("ps", ["aux"]);
+        let output = "";
+        psProcess.stdout.on("data", (data) => {
             output += data.toString();
         });
         await new Promise((resolve, reject) => {
-            psProcess.on('close', (code) => {
+            psProcess.on("close", (code) => {
                 if (code === 0)
                     resolve(undefined);
                 else
                     reject(new Error(`ps command failed with code ${code}`));
             });
-            psProcess.on('error', reject);
+            psProcess.on("error", reject);
         });
         // Parse ps output to find ttyd processes
-        const lines = output.split('\n');
+        const lines = output.split("\n");
         const ttydProcesses = [];
         for (const line of lines) {
-            if (line.includes('ttyd') && !line.includes('grep')) {
+            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(' ');
+                    const command = parts.slice(10).join(" ");
                     // Extract port from command line
                     let port = 0;
-                    let sessionName = '';
+                    let sessionName = "";
                     const portMatch = command.match(/-p\s+(\d+)/);
                     if (portMatch) {
                         port = parseInt(portMatch[1]);
@@ -1100,25 +1196,25 @@ async function getSystemTtydProcesses() {
         return ttydProcesses;
     }
     catch (error) {
-        console.error('[System Processes] Error getting system ttyd processes:', 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 { 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]);
+            const killProcess = spawn("tmux", ["kill-session", "-t", sessionName]);
             await new Promise((resolve, reject) => {
-                let stderr = '';
-                killProcess.stderr?.on('data', (data) => {
+                let stderr = "";
+                killProcess.stderr?.on("data", (data) => {
                     stderr += data.toString();
                 });
-                killProcess.on('close', (code) => {
+                killProcess.on("close", (code) => {
                     if (code === 0) {
                         resolve(undefined);
                     }
@@ -1126,7 +1222,7 @@ async function killSystemTmuxSessions(sessionNames, force = false) {
                         reject(new Error(`tmux kill-session failed with code ${code}: ${stderr}`));
                     }
                 });
-                killProcess.on('error', reject);
+                killProcess.on("error", reject);
             });
             results.push({
                 target: sessionName,
@@ -1135,7 +1231,7 @@ async function killSystemTmuxSessions(sessionNames, force = false) {
             console.log(`[System Sessions] Successfully killed tmux session: ${sessionName}`);
         }
         catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown 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,
@@ -1153,15 +1249,15 @@ async function killSystemTtydProcesses(pids, force = false) {
     for (const pid of pids) {
         try {
             console.log(`[System Processes] Killing ttyd process: ${pid}`);
-            const signal = force ? 'SIGKILL' : 'SIGTERM';
+            const signal = force ? "SIGKILL" : "SIGTERM";
             process.kill(pid, signal);
             // Wait a moment and verify process is killed
-            await new Promise(resolve => setTimeout(resolve, 1000));
+            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');
+                    process.kill(pid, "SIGKILL");
                 }
                 else {
                     throw new Error(`Process ${pid} still running after SIGKILL`);
@@ -1177,7 +1273,7 @@ async function killSystemTtydProcesses(pids, force = false) {
             });
         }
         catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown 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(),