instar 0.7.52 → 0.7.53

package/dist/server/WebSocketManager.js

@@ -0,0 +1,288 @@
+/**
+ * WebSocket Manager — real-time terminal streaming for the dashboard.
+ *
+ * Handles client subscriptions to tmux sessions, streams terminal output
+ * via diff-based updates, and forwards input to sessions.
+ *
+ * Protocol (JSON messages):
+ *
+ * Client → Server:
+ *   { type: 'subscribe', session: 'session-name' }
+ *   { type: 'unsubscribe', session: 'session-name' }
+ *   { type: 'input', session: 'session-name', text: 'some input' }
+ *   { type: 'key', session: 'session-name', key: 'C-c' }
+ *   { type: 'ping' }
+ *
+ * Server → Client:
+ *   { type: 'output', session: 'session-name', data: '...terminal output...' }
+ *   { type: 'sessions', sessions: [...] }
+ *   { type: 'session_ended', session: 'session-name' }
+ *   { type: 'subscribed', session: 'session-name' }
+ *   { type: 'unsubscribed', session: 'session-name' }
+ *   { type: 'input_ack', session: 'session-name', success: true }
+ *   { type: 'pong' }
+ *   { type: 'error', message: '...' }
+ */
+import { WebSocketServer, WebSocket } from 'ws';
+import { createHash, timingSafeEqual } from 'node:crypto';
+export class WebSocketManager {
+    wss;
+    clients = new Map();
+    sessionOutputCache = new Map();
+    streamInterval = null;
+    heartbeatInterval = null;
+    sessionBroadcastInterval = null;
+    sessionManager;
+    state;
+    authToken;
+    constructor(options) {
+        this.sessionManager = options.sessionManager;
+        this.state = options.state;
+        this.authToken = options.authToken;
+        this.wss = new WebSocketServer({
+            noServer: true,
+        });
+        // Handle upgrade manually for auth
+        options.server.on('upgrade', (request, socket, head) => {
+            // Only handle /ws path
+            const url = new URL(request.url || '/', `http://${request.headers.host || 'localhost'}`);
+            if (url.pathname !== '/ws') {
+                socket.destroy();
+                return;
+            }
+            // Authenticate via query param or header
+            if (this.authToken && !this.authenticate(request, url)) {
+                socket.write('HTTP/1.1 401 Unauthorized\r\n\r\n');
+                socket.destroy();
+                return;
+            }
+            this.wss.handleUpgrade(request, socket, head, (ws) => {
+                this.wss.emit('connection', ws, request);
+            });
+        });
+        this.wss.on('connection', (ws) => {
+            const client = {
+                ws,
+                subscriptions: new Set(),
+                isAlive: true,
+            };
+            this.clients.set(ws, client);
+            // Send initial session list
+            this.sendSessionList(ws);
+            ws.on('message', (data) => {
+                try {
+                    const msg = JSON.parse(data.toString());
+                    this.handleMessage(client, msg);
+                }
+                catch {
+                    this.send(ws, { type: 'error', message: 'Invalid JSON' });
+                }
+            });
+            ws.on('pong', () => {
+                client.isAlive = true;
+            });
+            ws.on('close', () => {
+                this.clients.delete(ws);
+            });
+            ws.on('error', () => {
+                this.clients.delete(ws);
+            });
+        });
+        // Start streaming terminal output to subscribers
+        this.startStreaming();
+        // Heartbeat to detect dead connections
+        this.heartbeatInterval = setInterval(() => {
+            for (const [ws, client] of this.clients) {
+                if (!client.isAlive) {
+                    ws.terminate();
+                    this.clients.delete(ws);
+                    continue;
+                }
+                client.isAlive = false;
+                ws.ping();
+            }
+        }, 30_000);
+        this.heartbeatInterval.unref();
+        // Broadcast session list periodically
+        this.sessionBroadcastInterval = setInterval(() => {
+            this.broadcastSessionList();
+        }, 5_000);
+        this.sessionBroadcastInterval.unref();
+    }
+    authenticate(request, url) {
+        if (!this.authToken)
+            return true;
+        // Check query param first (for browser WebSocket which can't set headers)
+        const tokenParam = url.searchParams.get('token');
+        if (tokenParam && this.verifyToken(tokenParam))
+            return true;
+        // Check Authorization header
+        const header = request.headers.authorization;
+        if (header?.startsWith('Bearer ')) {
+            const token = header.slice(7);
+            if (this.verifyToken(token))
+                return true;
+        }
+        return false;
+    }
+    verifyToken(token) {
+        if (!this.authToken)
+            return true;
+        const ha = createHash('sha256').update(token).digest();
+        const hb = createHash('sha256').update(this.authToken).digest();
+        return timingSafeEqual(ha, hb);
+    }
+    handleMessage(client, msg) {
+        switch (msg.type) {
+            case 'subscribe': {
+                const session = String(msg.session || '');
+                if (!session) {
+                    this.send(client.ws, { type: 'error', message: 'Missing session name' });
+                    return;
+                }
+                client.subscriptions.add(session);
+                // Send current output immediately
+                const output = this.sessionManager.captureOutput(session, 200);
+                if (output) {
+                    this.sessionOutputCache.set(`${this.clientId(client)}:${session}`, output);
+                    this.send(client.ws, { type: 'output', session, data: output });
+                }
+                this.send(client.ws, { type: 'subscribed', session });
+                break;
+            }
+            case 'unsubscribe': {
+                const session = String(msg.session || '');
+                client.subscriptions.delete(session);
+                this.sessionOutputCache.delete(`${this.clientId(client)}:${session}`);
+                this.send(client.ws, { type: 'unsubscribed', session });
+                break;
+            }
+            case 'input': {
+                const session = String(msg.session || '');
+                const text = String(msg.text || '');
+                if (!session || !text) {
+                    this.send(client.ws, { type: 'error', message: 'Missing session or text' });
+                    return;
+                }
+                const success = this.sessionManager.sendInput(session, text);
+                this.send(client.ws, { type: 'input_ack', session, success });
+                break;
+            }
+            case 'key': {
+                const session = String(msg.session || '');
+                const key = String(msg.key || '');
+                if (!session || !key) {
+                    this.send(client.ws, { type: 'error', message: 'Missing session or key' });
+                    return;
+                }
+                const success = this.sessionManager.sendKey(session, key);
+                this.send(client.ws, { type: 'input_ack', session, success });
+                break;
+            }
+            case 'ping':
+                this.send(client.ws, { type: 'pong' });
+                break;
+            default:
+                this.send(client.ws, { type: 'error', message: `Unknown message type: ${msg.type}` });
+        }
+    }
+    /**
+     * Stream terminal output to subscribed clients.
+     * Uses diff-based approach: only sends new content since last capture.
+     */
+    startStreaming() {
+        this.streamInterval = setInterval(() => {
+            // Collect all unique session subscriptions across clients
+            const subscribedSessions = new Set();
+            for (const client of this.clients.values()) {
+                for (const session of client.subscriptions) {
+                    subscribedSessions.add(session);
+                }
+            }
+            // Capture output for each subscribed session
+            for (const session of subscribedSessions) {
+                const output = this.sessionManager.captureOutput(session, 200);
+                // Broadcast to each subscribed client
+                for (const [, client] of this.clients) {
+                    if (!client.subscriptions.has(session))
+                        continue;
+                    const cacheKey = `${this.clientId(client)}:${session}`;
+                    const cached = this.sessionOutputCache.get(cacheKey);
+                    if (output === null) {
+                        // Session may have ended
+                        if (cached !== undefined) {
+                            this.send(client.ws, { type: 'session_ended', session });
+                            this.sessionOutputCache.delete(cacheKey);
+                        }
+                        continue;
+                    }
+                    // Only send if output changed
+                    if (output !== cached) {
+                        this.sessionOutputCache.set(cacheKey, output);
+                        this.send(client.ws, { type: 'output', session, data: output });
+                    }
+                }
+            }
+        }, 500);
+        this.streamInterval.unref();
+    }
+    sendSessionList(ws) {
+        const running = this.sessionManager.listRunningSessions();
+        const sessions = running.map(s => ({
+            id: s.id,
+            name: s.name,
+            tmuxSession: s.tmuxSession,
+            status: s.status,
+            startedAt: s.startedAt,
+            jobSlug: s.jobSlug,
+            model: s.model,
+        }));
+        this.send(ws, { type: 'sessions', sessions });
+    }
+    broadcastSessionList() {
+        if (this.clients.size === 0)
+            return;
+        const running = this.sessionManager.listRunningSessions();
+        const sessions = running.map(s => ({
+            id: s.id,
+            name: s.name,
+            tmuxSession: s.tmuxSession,
+            status: s.status,
+            startedAt: s.startedAt,
+            jobSlug: s.jobSlug,
+            model: s.model,
+        }));
+        const msg = JSON.stringify({ type: 'sessions', sessions });
+        for (const client of this.clients.values()) {
+            if (client.ws.readyState === WebSocket.OPEN) {
+                client.ws.send(msg);
+            }
+        }
+    }
+    clientId(client) {
+        // Use object identity via a WeakRef-friendly approach
+        return String(client.ws._socket?.remotePort || Math.random());
+    }
+    send(ws, msg) {
+        if (ws.readyState === WebSocket.OPEN) {
+            ws.send(JSON.stringify(msg));
+        }
+    }
+    /**
+     * Graceful shutdown — close all connections and stop intervals.
+     */
+    shutdown() {
+        if (this.streamInterval)
+            clearInterval(this.streamInterval);
+        if (this.heartbeatInterval)
+            clearInterval(this.heartbeatInterval);
+        if (this.sessionBroadcastInterval)
+            clearInterval(this.sessionBroadcastInterval);
+        for (const [ws] of this.clients) {
+            ws.close(1001, 'Server shutting down');
+        }
+        this.clients.clear();
+        this.wss.close();
+    }
+}
+//# sourceMappingURL=WebSocketManager.js.map

package/dist/server/routes.d.ts

@@ -21,6 +21,7 @@ import type { TelegraphService } from '../publishing/TelegraphService.js';
 import type { PrivateViewer } from '../publishing/PrivateViewer.js';
 import type { TunnelManager } from '../tunnel/TunnelManager.js';
 import type { EvolutionManager } from '../core/EvolutionManager.js';
+import type { SessionWatchdog } from '../monitoring/SessionWatchdog.js';
 export interface RouteContext {
     config: InstarConfig;
     sessionManager: SessionManager;
@@ -38,6 +39,7 @@ export interface RouteContext {
     viewer: PrivateViewer | null;
     tunnel: TunnelManager | null;
     evolution: EvolutionManager | null;
+    watchdog: SessionWatchdog | null;
     startTime: Date;
 }
 export declare function createRoutes(ctx: RouteContext): Router;

package/dist/server/routes.js

@@ -1695,6 +1695,27 @@ export function createRoutes(ctx) {
         }
         res.json({ ok: true, id: req.params.id, status });
     });
+    // ── Watchdog ──────────────────────────────────────────────────
+    router.get('/watchdog/status', (req, res) => {
+        if (!ctx.watchdog) {
+            res.json({ enabled: false, sessions: [], interventionHistory: [] });
+            return;
+        }
+        res.json(ctx.watchdog.getStatus());
+    });
+    router.post('/watchdog/toggle', (req, res) => {
+        if (!ctx.watchdog) {
+            res.status(404).json({ error: 'Watchdog not configured' });
+            return;
+        }
+        const { enabled } = req.body;
+        if (typeof enabled !== 'boolean') {
+            res.status(400).json({ error: 'enabled (boolean) required' });
+            return;
+        }
+        ctx.watchdog.setEnabled(enabled);
+        res.json({ enabled: ctx.watchdog.isEnabled() });
+    });
     return router;
 }
 export function formatUptime(ms) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "instar",
-  "version": "0.7.52",
+  "version": "0.7.53",
   "description": "Persistent autonomy infrastructure for AI agents",
   "type": "module",
   "main": "dist/index.js",
@@ -55,12 +55,14 @@
     "commander": "^12.0.0",
     "croner": "^8.0.0",
     "express": "^4.18.0",
-    "picocolors": "^1.0.0"
+    "picocolors": "^1.0.0",
+    "ws": "^8.19.0"
   },
   "devDependencies": {
     "@types/express": "^4.17.21",
     "@types/node": "^20.11.0",
     "@types/supertest": "^6.0.3",
+    "@types/ws": "^8.18.1",
     "supertest": "^7.2.2",
     "typescript": "^5.9.3",
     "vitest": "^2.0.0"