@burdenoff/vibe-agent 1.0.1 → 1.0.3

package/README.md

@@ -36,14 +36,14 @@ vibe status
 
 Create a `.env` file in your working directory or set environment variables:
 
-| Variable | Description | Default |
-|----------|-------------|---------|
-| `PORT` | Agent server port | `3005` |
-| `NODE_ENV` | Environment | `development` |
-| `CORS_ORIGIN` | Allowed CORS origin | `http://localhost:3000` |
-| `AGENT_API_KEY` | API key for authentication | (auto-generated) |
-| `DB_PATH` | SQLite database path | `./vibecontrols-agent.db` |
-| `AGENT_TUNNEL` | Auto-start cloudflared tunnel | `true` |
+| Variable        | Description                   | Default                   |
+| --------------- | ----------------------------- | ------------------------- |
+| `PORT`          | Agent server port             | `3005`                    |
+| `NODE_ENV`      | Environment                   | `development`             |
+| `CORS_ORIGIN`   | Allowed CORS origin           | `http://localhost:3000`   |
+| `AGENT_API_KEY` | API key for authentication    | (auto-generated)          |
+| `DB_PATH`       | SQLite database path          | `./vibecontrols-agent.db` |
+| `AGENT_TUNNEL`  | Auto-start cloudflared tunnel | `true`                    |
 
 An `.env.example` file is included in the package for reference.
 
@@ -203,12 +203,12 @@ The agent runs as a Fastify HTTP server with:
 
 ### System Dependencies
 
-| Tool | Purpose | Required |
-|------|---------|----------|
-| tmux | Terminal multiplexing | Yes |
-| ttyd | Web-based terminal | Recommended |
-| cloudflared | Tunnel management | For tunnels |
-| Node.js 18+ | Runtime | Yes |
+| Tool        | Purpose               | Required    |
+| ----------- | --------------------- | ----------- |
+| tmux        | Terminal multiplexing | Yes         |
+| ttyd        | Web-based terminal    | Recommended |
+| cloudflared | Tunnel management     | For tunnels |
+| Node.js 18+ | Runtime               | Yes         |
 
 Run `vibe setup --check` to verify all dependencies.
 

package/dist/app.d.ts

@@ -1,12 +1,12 @@
-import Fastify from 'fastify';
-import { Server as SocketIOServer } from 'socket.io';
-import AgentDatabase from './db/schema.js';
+import Fastify from "fastify";
+import { Server as SocketIOServer } from "socket.io";
+import AgentDatabase from "./db/schema.js";
 /**
  * Get the current agent API key.
  */
 export declare function getAgentApiKey(): string;
 export declare function startServer(): Promise<Fastify.FastifyInstance<import("http").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>, import("http").IncomingMessage, import("http").ServerResponse<import("http").IncomingMessage>, Fastify.FastifyBaseLogger, Fastify.FastifyTypeProviderDefault>>;
-declare module 'fastify' {
+declare module "fastify" {
     interface FastifyInstance {
         db: AgentDatabase;
         io: SocketIOServer;

package/dist/app.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"app.d.ts","sourceRoot":"","sources":["../src/app.ts"],"names":[],"mappings":"AAAA,OAAO,OAAO,MAAM,SAAS,CAAC;AAK9B,OAAO,EAAE,MAAM,IAAI,cAAc,EAAE,MAAM,WAAW,CAAC;AAErD,OAAO,aAAa,MAAM,gBAAgB,CAAC;AA+B3C;;GAEG;AACH,wBAAgB,cAAc,IAAI,MAAM,CAEvC;AAWD,wBAAsB,WAAW,uSA4bhC;AAGD,OAAO,QAAQ,SAAS,CAAC;IACvB,UAAU,eAAe;QACvB,EAAE,EAAE,aAAa,CAAC;QAClB,EAAE,EAAE,cAAc,CAAC;KACpB;CACF"}
+{"version":3,"file":"app.d.ts","sourceRoot":"","sources":["../src/app.ts"],"names":[],"mappings":"AAAA,OAAO,OAAO,MAAM,SAAS,CAAC;AAK9B,OAAO,EAAE,MAAM,IAAI,cAAc,EAAE,MAAM,WAAW,CAAC;AAErD,OAAO,aAAa,MAAM,gBAAgB,CAAC;AAoC3C;;GAEG;AACH,wBAAgB,cAAc,IAAI,MAAM,CAEvC;AAWD,wBAAsB,WAAW,uSAigBhC;AAGD,OAAO,QAAQ,SAAS,CAAC;IACvB,UAAU,eAAe;QACvB,EAAE,EAAE,aAAa,CAAC;QAClB,EAAE,EAAE,cAAc,CAAC;KACpB;CACF"}

package/dist/app.js

@@ -1,37 +1,37 @@
-import Fastify from 'fastify';
-import cors from '@fastify/cors';
-import helmet from '@fastify/helmet';
-import os from 'node:os';
-import crypto from 'node:crypto';
-import { Server as SocketIOServer } from 'socket.io';
-import { WebSocketServer, WebSocket } from 'ws';
-import AgentDatabase from './db/schema.js';
-import { tmuxRoutes } from './routes/tmux.js';
-import { sshRoutes } from './routes/ssh.js';
-import { portForwardRoutes } from './routes/port-forward.js';
-import { taskRoutes } from './routes/tasks.js';
-import { configRoutes } from './routes/config.js';
-import { gitRoutes } from './routes/git.js';
-import { fileRoutes } from './routes/files.js';
-import { bookmarkRoutes } from './routes/bookmarks.js';
-import { notificationRoutes } from './routes/notifications.js';
-import { projectRoutes } from './routes/projects.js';
-import { moduleRegistryRoutes } from './routes/moduleRegistry.js';
-import { tunnelRoutes, getAgentTunnelUrl, startAgentTunnel, stopAgentTunnel } from './routes/tunnel.js';
-import { bootstrap, checkDependencies } from './services/bootstrap.js';
+import Fastify from "fastify";
+import cors from "@fastify/cors";
+import helmet from "@fastify/helmet";
+import os from "node:os";
+import crypto from "node:crypto";
+import { Server as SocketIOServer } from "socket.io";
+import { WebSocketServer, WebSocket } from "ws";
+import AgentDatabase from "./db/schema.js";
+import { tmuxRoutes } from "./routes/tmux.js";
+import { sshRoutes } from "./routes/ssh.js";
+import { portForwardRoutes } from "./routes/port-forward.js";
+import { taskRoutes } from "./routes/tasks.js";
+import { configRoutes } from "./routes/config.js";
+import { gitRoutes } from "./routes/git.js";
+import { fileRoutes } from "./routes/files.js";
+import { bookmarkRoutes } from "./routes/bookmarks.js";
+import { notificationRoutes } from "./routes/notifications.js";
+import { projectRoutes } from "./routes/projects.js";
+import { moduleRegistryRoutes } from "./routes/moduleRegistry.js";
+import { tunnelRoutes, getAgentTunnelUrl, startAgentTunnel, stopAgentTunnel, } from "./routes/tunnel.js";
+import { bootstrap, checkDependencies } from "./services/bootstrap.js";
 // ── Agent API Key ──────────────────────────────────────────────────────
 // Generated fresh on every agent start/restart. Must be provided via
 // `x-agent-api-key` header (or `apiKey` query param) for all requests
 // except /health and /api/agent-identity.
 // The key is printed to stdout on startup so the user can copy it into
 // the agent configuration in the VibeControls UI.
-let agentApiKey = '';
+let agentApiKey = "";
 /**
  * Generate a new cryptographically random API key for this agent instance.
  * Called once at startup.
  */
 function generateAgentApiKey() {
-    return `vcak_${crypto.randomBytes(32).toString('base64url')}`;
+    return `vcak_${crypto.randomBytes(32).toString("base64url")}`;
 }
 /**
  * Get the current agent API key.
@@ -45,36 +45,38 @@ export function getAgentApiKey() {
  */
 function getMachineFingerprint() {
     const raw = `${os.hostname()}|${os.platform()}|${os.arch()}`;
-    return crypto.createHash('sha256').update(raw).digest('hex').substring(0, 16);
+    return crypto.createHash("sha256").update(raw).digest("hex").substring(0, 16);
 }
 export async function startServer() {
     // Generate a fresh API key for this agent instance
     agentApiKey = generateAgentApiKey();
     const app = Fastify({
-        logger: process.env.NODE_ENV === 'development' ? {
-            level: 'info',
-            serializers: {
-                req: (req) => {
-                    return {
-                        method: req.method,
-                        url: req.url,
-                        host: req.headers.host,
-                        remoteAddress: req.ip,
-                        remotePort: req.socket?.remotePort,
-                    };
+        logger: process.env.NODE_ENV === "development"
+            ? {
+                level: "info",
+                serializers: {
+                    req: (req) => {
+                        return {
+                            method: req.method,
+                            url: req.url,
+                            host: req.headers.host,
+                            remoteAddress: req.ip,
+                            remotePort: req.socket?.remotePort,
+                        };
+                    },
+                    res: (res) => {
+                        return {
+                            statusCode: res.statusCode,
+                        };
+                    },
                 },
-                res: (res) => {
-                    return {
-                        statusCode: res.statusCode,
-                    };
-                },
-            },
-        } : false,
+            }
+            : false,
     });
     // Initialize database
-    const db = new AgentDatabase(process.env.DB_PATH || './vibecontrols-agent.db');
+    const db = new AgentDatabase(process.env.DB_PATH || "./vibecontrols-agent.db");
     // Make db available to routes
-    app.decorate('db', db);
+    app.decorate("db", db);
     // Register plugins
     await app.register(cors, {
         origin: process.env.CORS_ORIGIN || true,
@@ -86,11 +88,11 @@ export async function startServer() {
         frameguard: false, // Allow embedding in iframes (terminal UI)
     });
     // Health check endpoint
-    app.get('/health', async () => {
+    app.get("/health", async () => {
         return {
-            status: 'healthy',
+            status: "healthy",
             timestamp: new Date().toISOString(),
-            version: '1.0.0',
+            version: "1.0.0",
             uptime: process.uptime(),
             tunnelUrl: getAgentTunnelUrl(),
         };
@@ -99,7 +101,7 @@ export async function startServer() {
     // backend can verify that a tunnel URL reaches the EXPECTED machine.
     // This prevents silent misrouting when a cloudflare quick-tunnel URL
     // is stale or was reassigned.
-    app.get('/api/agent-identity', async () => {
+    app.get("/api/agent-identity", async () => {
         return {
             fingerprint: getMachineFingerprint(),
             hostname: os.hostname(),
@@ -113,23 +115,28 @@ export async function startServer() {
     // This is auth-exempt so the key can be retrieved from the agent itself
     // (e.g. by the agent CLI or during initial setup). In production, access
     // should be restricted to localhost via network policy.
-    app.get('/api/agent-api-key', async () => {
+    app.get("/api/agent-api-key", async () => {
         return {
             apiKey: agentApiKey,
             generatedAt: new Date().toISOString(),
-            note: 'This key changes every time the agent restarts. Store it in the agent configuration in VibeControls.',
+            note: "This key changes every time the agent restarts. Store it in the agent configuration in VibeControls.",
         };
     });
     // ── API Key Authentication ─────────────────────────────────────────────
     // Every request (except allowlisted paths) must include the agent API key
     // via `x-agent-api-key` header or `apiKey` query parameter.
     // The key is generated fresh on every agent start/restart.
-    const AUTH_EXEMPT_PATHS = new Set(['/health', '/api/agent-identity', '/api/agent-api-key']);
+    const AUTH_EXEMPT_PATHS = new Set([
+        "/health",
+        "/api/agent-identity",
+        "/api/agent-api-key",
+        "/api/agent-tunnel",
+    ]);
     // Terminal proxy paths are exempt because they're accessed via iframe/WS
     // and the key was already verified when the session was started via the backend.
-    const AUTH_EXEMPT_PREFIXES = ['/terminal/'];
-    app.addHook('onRequest', async (request, reply) => {
-        const url = request.url.split('?')[0]; // strip query string for matching
+    const AUTH_EXEMPT_PREFIXES = ["/terminal/"];
+    app.addHook("onRequest", async (request, reply) => {
+        const url = request.url.split("?")[0]; // strip query string for matching
         // Skip auth for exempt paths
         if (AUTH_EXEMPT_PATHS.has(url))
             return;
@@ -138,28 +145,28 @@ export async function startServer() {
                 return;
         }
         // Check API key from header or query param
-        const headerKey = request.headers['x-agent-api-key'];
+        const headerKey = request.headers["x-agent-api-key"];
         const queryKey = request.query?.apiKey;
         const providedKey = headerKey || queryKey;
         if (!providedKey || providedKey !== agentApiKey) {
             return reply.code(401).send({
-                error: 'Unauthorized',
-                message: 'Invalid or missing API key. Provide the agent API key via x-agent-api-key header.',
+                error: "Unauthorized",
+                message: "Invalid or missing API key. Provide the agent API key via x-agent-api-key header.",
             });
         }
     });
     // Register routes
-    app.register(tmuxRoutes, { prefix: '/api/tmux' });
-    app.register(sshRoutes, { prefix: '/api/ssh' });
-    app.register(portForwardRoutes, { prefix: '/api/port-forward' });
-    app.register(taskRoutes, { prefix: '/api/tasks' });
-    app.register(configRoutes, { prefix: '/api/config' });
-    app.register(gitRoutes, { prefix: '/api/git' });
-    app.register(fileRoutes, { prefix: '/api/files' });
-    app.register(bookmarkRoutes, { prefix: '/api/bookmarks' });
-    app.register(notificationRoutes, { prefix: '/api/notifications' });
-    app.register(projectRoutes, { prefix: '/api/projects' });
-    app.register(tunnelRoutes, { prefix: '/api/tunnel' });
+    app.register(tmuxRoutes, { prefix: "/api/tmux" });
+    app.register(sshRoutes, { prefix: "/api/ssh" });
+    app.register(portForwardRoutes, { prefix: "/api/port-forward" });
+    app.register(taskRoutes, { prefix: "/api/tasks" });
+    app.register(configRoutes, { prefix: "/api/config" });
+    app.register(gitRoutes, { prefix: "/api/git" });
+    app.register(fileRoutes, { prefix: "/api/files" });
+    app.register(bookmarkRoutes, { prefix: "/api/bookmarks" });
+    app.register(notificationRoutes, { prefix: "/api/notifications" });
+    app.register(projectRoutes, { prefix: "/api/projects" });
+    app.register(tunnelRoutes, { prefix: "/api/tunnel" });
     app.register(moduleRegistryRoutes);
     // --- Terminal proxy: forward /terminal/:sessionId/* → ttyd on localhost ---
     // This lets the single agent tunnel proxy all ttyd sessions, removing the need
@@ -188,16 +195,16 @@ export async function startServer() {
             const fetchInit = {
                 method: request.method,
                 headers: Object.fromEntries(Object.entries(request.headers)
-                    .filter(([k, v]) => v != null && !['host', 'connection'].includes(k.toLowerCase()))
+                    .filter(([k, v]) => v != null && !["host", "connection"].includes(k.toLowerCase()))
                     .map(([k, v]) => [k, String(v)])),
             };
-            if (request.method !== 'GET' && request.method !== 'HEAD') {
+            if (request.method !== "GET" && request.method !== "HEAD") {
                 fetchInit.body = request.body;
             }
             const proxyRes = await fetch(`http://127.0.0.1:${port}${upstreamPath}`, fetchInit);
             reply.code(proxyRes.status);
             for (const [key, value] of proxyRes.headers.entries()) {
-                if (!['transfer-encoding', 'connection'].includes(key.toLowerCase())) {
+                if (!["transfer-encoding", "connection"].includes(key.toLowerCase())) {
                     reply.header(key, value);
                 }
             }
@@ -205,19 +212,23 @@ export async function startServer() {
             return reply.send(buf);
         }
         // HTTP proxy for /terminal/:sessionId and /terminal/:sessionId/*
-        instance.all('/terminal/:sessionId', async (request, reply) => {
+        instance.all("/terminal/:sessionId", async (request, reply) => {
             const { sessionId } = request.params;
             const port = resolveTtydPort(sessionId);
             if (!port)
-                return reply.code(502).send({ error: 'Terminal not running for this session' });
-            return proxyToTtyd(request, reply, port, '/');
+                return reply
+                    .code(502)
+                    .send({ error: "Terminal not running for this session" });
+            return proxyToTtyd(request, reply, port, "/");
         });
-        instance.all('/terminal/:sessionId/*', async (request, reply) => {
+        instance.all("/terminal/:sessionId/*", async (request, reply) => {
             const { sessionId } = request.params;
-            const wildcardPath = request.params['*'] || '';
+            const wildcardPath = request.params["*"] || "";
             const port = resolveTtydPort(sessionId);
             if (!port)
-                return reply.code(502).send({ error: 'Terminal not running for this session' });
+                return reply
+                    .code(502)
+                    .send({ error: "Terminal not running for this session" });
             return proxyToTtyd(request, reply, port, `/${wildcardPath}`);
         });
         // ─── WebSocket proxy for ttyd using the `ws` library ───────────────
@@ -229,20 +240,20 @@ export async function startServer() {
             // Handle sub-protocol negotiation: ttyd requires the 'tty' protocol.
             // When the browser sends Sec-WebSocket-Protocol: tty, we must accept it.
             handleProtocols(protocols) {
-                if (protocols.has('tty'))
-                    return 'tty';
+                if (protocols.has("tty"))
+                    return "tty";
                 return false;
             },
         });
-        terminalWss.on('connection', (clientWs, req, ttydPort) => {
+        terminalWss.on("connection", (clientWs, req, ttydPort) => {
             // Connect to the local ttyd WebSocket.
             // CRITICAL: ttyd requires the 'tty' sub-protocol. We must forward it
             // from the client's request headers, otherwise ttyd immediately closes
             // the connection.
-            const clientProtocols = req.headers['sec-websocket-protocol'];
+            const clientProtocols = req.headers["sec-websocket-protocol"];
             const protocols = clientProtocols
-                ? clientProtocols.split(',').map((p) => p.trim())
-                : ['tty']; // Default to 'tty' if browser didn't send it
+                ? clientProtocols.split(",").map((p) => p.trim())
+                : ["tty"]; // Default to 'tty' if browser didn't send it
             const upstreamUrl = `ws://127.0.0.1:${ttydPort}/ws`;
             const upstreamWs = new WebSocket(upstreamUrl, protocols, {
                 perMessageDeflate: false,
@@ -252,7 +263,7 @@ export async function startServer() {
             // Buffer messages from upstream until bridge is ready
             const upstreamBuffer = [];
             // When upstream ttyd connection opens, flush buffered messages and bridge
-            upstreamWs.on('open', () => {
+            upstreamWs.on("open", () => {
                 upstreamAlive = true;
                 console.log(`[TerminalProxy] WS bridge established → 127.0.0.1:${ttydPort}/ws (protocol: ${upstreamWs.protocol})`);
                 // Flush any buffered messages
@@ -264,7 +275,7 @@ export async function startServer() {
                 upstreamBuffer.length = 0;
             });
             // Forward: upstream ttyd → client browser
-            upstreamWs.on('message', (data, isBinary) => {
+            upstreamWs.on("message", (data, isBinary) => {
                 if (!upstreamAlive) {
                     // Buffer until upstream is ready (shouldn't happen, but be safe)
                     upstreamBuffer.push({ data, isBinary });
@@ -275,38 +286,40 @@ export async function startServer() {
                 }
             });
             // Forward: client browser → upstream ttyd
-            clientWs.on('message', (data, isBinary) => {
+            clientWs.on("message", (data, isBinary) => {
                 if (upstreamAlive && upstreamWs.readyState === WebSocket.OPEN) {
                     upstreamWs.send(data, { binary: isBinary });
                 }
             });
             // Handle close in both directions
-            clientWs.on('close', (code, reason) => {
+            clientWs.on("close", (code, reason) => {
                 clientAlive = false;
                 console.log(`[TerminalProxy] Client WS closed (code=${code})`);
-                if (upstreamWs.readyState === WebSocket.OPEN || upstreamWs.readyState === WebSocket.CONNECTING) {
-                    upstreamWs.close(1000, 'Client disconnected');
+                if (upstreamWs.readyState === WebSocket.OPEN ||
+                    upstreamWs.readyState === WebSocket.CONNECTING) {
+                    upstreamWs.close(1000, "Client disconnected");
                 }
             });
-            upstreamWs.on('close', (code, reason) => {
+            upstreamWs.on("close", (code, reason) => {
                 upstreamAlive = false;
                 console.log(`[TerminalProxy] Upstream ttyd WS closed (code=${code})`);
-                if (clientWs.readyState === WebSocket.OPEN || clientWs.readyState === WebSocket.CONNECTING) {
-                    clientWs.close(1000, 'Upstream closed');
+                if (clientWs.readyState === WebSocket.OPEN ||
+                    clientWs.readyState === WebSocket.CONNECTING) {
+                    clientWs.close(1000, "Upstream closed");
                 }
             });
             // Handle errors
-            clientWs.on('error', (err) => {
-                console.error('[TerminalProxy] Client WS error:', err.message);
+            clientWs.on("error", (err) => {
+                console.error("[TerminalProxy] Client WS error:", err.message);
                 clientAlive = false;
                 if (upstreamWs.readyState === WebSocket.OPEN)
                     upstreamWs.close();
             });
-            upstreamWs.on('error', (err) => {
-                console.error('[TerminalProxy] Upstream WS error:', err.message);
+            upstreamWs.on("error", (err) => {
+                console.error("[TerminalProxy] Upstream WS error:", err.message);
                 upstreamAlive = false;
                 if (clientWs.readyState === WebSocket.OPEN) {
-                    clientWs.close(1011, 'Upstream error');
+                    clientWs.close(1011, "Upstream error");
                 }
             });
         });
@@ -316,47 +329,49 @@ export async function startServer() {
         instance.server._resolveTtydPort = resolveTtydPort;
     });
     // --- Agent tunnel management endpoints ---
-    app.get('/api/agent-tunnel', async () => {
+    app.get("/api/agent-tunnel", async () => {
         return {
             tunnelUrl: getAgentTunnelUrl(),
-            status: getAgentTunnelUrl() ? 'active' : 'inactive',
+            status: getAgentTunnelUrl() ? "active" : "inactive",
         };
     });
-    app.post('/api/agent-tunnel/start', async (_request, reply) => {
+    app.post("/api/agent-tunnel/start", async (_request, reply) => {
         try {
             const port = Number(process.env.PORT || 3005);
             const url = await startAgentTunnel(port);
-            return { tunnelUrl: url, status: 'active' };
+            return { tunnelUrl: url, status: "active" };
         }
         catch (err) {
             return reply.code(500).send({
-                error: 'Failed to start agent tunnel',
+                error: "Failed to start agent tunnel",
                 details: err instanceof Error ? err.message : String(err),
             });
         }
     });
-    app.post('/api/agent-tunnel/stop', async () => {
+    app.post("/api/agent-tunnel/stop", async () => {
         stopAgentTunnel();
-        return { status: 'inactive' };
+        return { status: "inactive" };
     });
     // Setup/bootstrap endpoint - check and install dependencies
-    app.get('/api/setup/check', async () => {
+    app.get("/api/setup/check", async () => {
         return { dependencies: checkDependencies() };
     });
-    app.post('/api/setup/install', async () => {
+    app.post("/api/setup/install", async () => {
         const results = await bootstrap({ verbose: false });
-        const failed = results.filter(r => r.status === 'failed');
+        const failed = results.filter((r) => r.status === "failed");
         return {
             success: failed.length === 0,
             results,
             message: failed.length === 0
-                ? 'All dependencies installed successfully'
-                : `Failed to install: ${failed.map(f => f.tool).join(', ')}`,
+                ? "All dependencies installed successfully"
+                : `Failed to install: ${failed.map((f) => f.tool).join(", ")}`,
         };
     });
     // Version endpoint
-    app.get('/api/version', async (_request, _reply) => {
-        const packageJson = await import('../package.json', { assert: { type: 'json' } });
+    app.get("/api/version", async (_request, _reply) => {
+        const packageJson = await import("../package.json", {
+            assert: { type: "json" },
+        });
         return {
             name: packageJson.default.name,
             version: packageJson.default.version,
@@ -364,48 +379,48 @@ export async function startServer() {
             platform: process.platform,
             arch: process.arch,
             uptime: process.uptime(),
-            apiVersion: 'v1'
+            apiVersion: "v1",
         };
     });
     // Socket.io for real-time updates
     const io = new SocketIOServer(app.server, {
         cors: {
             origin: process.env.CORS_ORIGIN || true,
-            credentials: true
-        }
+            credentials: true,
+        },
     });
-    io.on('connection', (socket) => {
-        console.log('Client connected:', socket.id);
-        socket.on('subscribe', (channel) => {
+    io.on("connection", (socket) => {
+        console.log("Client connected:", socket.id);
+        socket.on("subscribe", (channel) => {
             socket.join(channel);
             console.log(`Client ${socket.id} subscribed to ${channel}`);
         });
-        socket.on('unsubscribe', (channel) => {
+        socket.on("unsubscribe", (channel) => {
             socket.leave(channel);
             console.log(`Client ${socket.id} unsubscribed from ${channel}`);
         });
-        socket.on('disconnect', () => {
-            console.log('Client disconnected:', socket.id);
+        socket.on("disconnect", () => {
+            console.log("Client disconnected:", socket.id);
         });
     });
     // Make io available to routes
-    app.decorate('io', io);
+    app.decorate("io", io);
     // ── Terminal WebSocket upgrade handler ──────────────────────────────
     // Install this in onReady hook so that:
     // 1. Fastify plugins (including terminalProxy) have initialized
     // 2. Socket.IO has attached its upgrade listener
     // We replace ALL upgrade listeners with a single master handler that
     // routes terminal WS to our WSS and everything else to Socket.IO.
-    app.addHook('onReady', async () => {
+    app.addHook("onReady", async () => {
         const terminalWss = app.server._terminalWss;
         const resolveTtydPort = app.server._resolveTtydPort;
         if (terminalWss && resolveTtydPort) {
             // Grab all current upgrade listeners (Socket.IO's handler)
-            const existingUpgradeListeners = app.server.listeners('upgrade').slice();
+            const existingUpgradeListeners = app.server.listeners("upgrade").slice();
             // Remove them all
-            app.server.removeAllListeners('upgrade');
+            app.server.removeAllListeners("upgrade");
             // Add a single master upgrade handler
-            app.server.on('upgrade', (req, socket, head) => {
+            app.server.on("upgrade", (req, socket, head) => {
                 const match = req.url?.match(/^\/terminal\/([^/]+)\/ws/);
                 if (match) {
                     // Terminal WebSocket — handle with our WSS
@@ -413,13 +428,13 @@ export async function startServer() {
                     const port = resolveTtydPort(sessionId);
                     if (!port) {
                         console.warn(`[TerminalProxy] No ttyd running for session ${sessionId}, rejecting`);
-                        socket.write('HTTP/1.1 502 Bad Gateway\r\n\r\n');
+                        socket.write("HTTP/1.1 502 Bad Gateway\r\n\r\n");
                         socket.destroy();
                         return;
                     }
                     console.log(`[TerminalProxy] Upgrading WS for session ${sessionId} → ttyd port ${port}`);
                     terminalWss.handleUpgrade(req, socket, head, (ws) => {
-                        terminalWss.emit('connection', ws, req, port);
+                        terminalWss.emit("connection", ws, req, port);
                     });
                     // Do NOT call other handlers — terminal WS is fully handled
                     return;
@@ -429,14 +444,14 @@ export async function startServer() {
                     listener.call(app.server, req, socket, head);
                 }
             });
-            console.log('[App] Terminal WS upgrade handler installed (master handler replaces Socket.IO)');
+            console.log("[App] Terminal WS upgrade handler installed (master handler replaces Socket.IO)");
         }
         else {
-            console.warn('[App] Terminal proxy not initialized — WS upgrade handler not installed');
+            console.warn("[App] Terminal proxy not initialized — WS upgrade handler not installed");
         }
     });
     // Graceful shutdown
-    app.addHook('onClose', async () => {
+    app.addHook("onClose", async () => {
         db.close();
         io.close();
     });