devchain-cli 0.12.4 → 0.13.0

package/dist/server/modules/terminal/gateways/terminal.gateway.js

@@ -16,536 +16,472 @@ exports.TerminalGateway = void 0;
 const websockets_1 = require("@nestjs/websockets");
 const common_1 = require("@nestjs/common");
 const event_emitter_1 = require("@nestjs/event-emitter");
-const core_1 = require("@nestjs/core");
 const socket_io_1 = require("socket.io");
 const logger_1 = require("../../../common/logging/logger");
 const terminal_stream_service_1 = require("../services/terminal-stream.service");
 const pty_service_1 = require("../services/pty.service");
-const tmux_service_1 = require("../services/tmux.service");
-const sessions_service_1 = require("../../sessions/services/sessions.service");
+const terminal_io_service_1 = require("../services/terminal-io/terminal-io.service");
+const terminal_session_registry_1 = require("../services/terminal-session/terminal-session-registry");
 const terminal_seed_service_1 = require("../services/terminal-seed.service");
 const control_keys_1 = require("../utils/control-keys");
 const settings_service_1 = require("../../settings/services/settings.service");
 const ws_envelope_dto_1 = require("../dtos/ws-envelope.dto");
+const sessions_service_1 = require("../../sessions/services/sessions.service");
+const normalize_line_endings_1 = require("../utils/normalize-line-endings");
+const realtime_broadcast_service_1 = require("../../realtime/services/realtime-broadcast.service");
 const logger = (0, logger_1.createLogger)('TerminalGateway');
+const THEME_HEX_RE = /^#[0-9a-fA-F]{6}$/;
+const HEARTBEAT_INTERVAL = 30000;
+const HEARTBEAT_TIMEOUT = 45000;
+const INPUT_RATE_WINDOW_MS = 5000;
+const INPUT_RATE_MSG_THRESHOLD = 500;
+const INPUT_RATE_BYTES_THRESHOLD = 512000;
 let TerminalGateway = class TerminalGateway {
-    constructor(streamService, settingsService, ptyService, moduleRef, seedService) {
+    constructor(streamService, settingsService, ptyService, seedService, terminalIO, registry, sessionsService, realtimeBroadcast) {
         this.streamService = streamService;
         this.settingsService = settingsService;
         this.ptyService = ptyService;
-        this.moduleRef = moduleRef;
         this.seedService = seedService;
+        this.terminalIO = terminalIO;
+        this.registry = registry;
+        this.sessionsService = sessionsService;
+        this.realtimeBroadcast = realtimeBroadcast;
         this.clientSessions = new Map();
-        this.authorityBySession = new Map();
-        this.lastDimensions = new Map();
-        this.HEARTBEAT_INTERVAL = 30000;
-        this.HEARTBEAT_TIMEOUT = 45000;
+        this.frameListeners = new Map();
+        this.inputRateTracker = new Map();
+        this.themeCache = new Map();
     }
     afterInit() {
+        this.realtimeBroadcast.setServer(this.server);
         logger.info('WebSocket gateway initialized');
         this.startHeartbeat();
     }
     handleConnection(client) {
-        logger.info({ clientId: client.id, transport: client.conn.transport.name }, 'Client connected to WebSocket gateway');
+        logger.info({ clientId: client.id, transport: client.conn?.transport?.name }, 'Client connected');
         this.clientSessions.set(client.id, {
             sessionId: '',
             lastHeartbeat: new Date(),
             subscriptions: new Set(),
         });
         this.sendHeartbeat(client);
-        setTimeout(() => {
-            const session = this.clientSessions.get(client.id);
-            if (session && session.subscriptions.size === 0) {
-                logger.warn({ clientId: client.id, connected: client.connected }, 'Client connected but has not subscribed to any topics after 5s');
-            }
-        }, 5000);
     }
     handleDisconnect(client) {
         logger.info({ clientId: client.id }, 'Client disconnected');
-        for (const [sessionId, clientId] of this.authorityBySession.entries()) {
-            if (clientId === client.id) {
-                this.authorityBySession.delete(sessionId);
-                const room = this.server.sockets.adapter.rooms.get(`terminal:${sessionId}`);
-                const nextClientId = room ? Array.from(room)[0] : undefined;
-                if (nextClientId) {
-                    this.setAuthority(sessionId, nextClientId);
-                }
-                else {
-                    const envelope = (0, ws_envelope_dto_1.createEnvelope)(`terminal/${sessionId}`, 'focus_changed', {
-                        sessionId,
-                        clientId: null,
-                    });
-                    this.server.to(`terminal:${sessionId}`).emit('message', envelope);
-                }
+        const clientSession = this.clientSessions.get(client.id);
+        if (clientSession?.sessionId) {
+            const session = this.registry.get(clientSession.sessionId);
+            if (session) {
+                session.unsubscribe(client.id);
             }
         }
         this.clientSessions.delete(client.id);
     }
     async handleSubscribe(client, payload) {
         const { sessionId, lastSequence, rows, cols } = payload;
-        const engine = 'chat';
-        let sanitize = false;
-        try {
-            sanitize = this.ptyService.isSanitizerEnabled();
-        }
-        catch { }
-        logger.info({ clientId: client.id, sessionId, lastSequence, rows, cols, engine, sanitize }, 'Client subscribing to session');
+        logger.info({ clientId: client.id, sessionId, lastSequence, rows, cols }, 'Client subscribing');
         const clientSession = this.clientSessions.get(client.id);
-        if (!clientSession) {
+        if (!clientSession)
             return;
-        }
         clientSession.sessionId = sessionId;
         clientSession.subscriptions.add(`session/${sessionId}`);
         client.join(`session:${sessionId}`);
         this.streamService.initializeBuffer(sessionId);
-        await this.ensurePtyStreaming(sessionId);
-        if (!this.authorityBySession.has(sessionId)) {
-            this.setAuthority(sessionId, client.id);
-            logger.info({ sessionId, clientId: client.id }, 'Granted authority to subscribing client');
+        const session = this.registry.get(sessionId);
+        if (!session) {
+            logger.warn({ sessionId }, 'No registry entry — using fallback seed path');
+            client.emit('message', (0, ws_envelope_dto_1.createEnvelope)(`terminal/${sessionId}`, 'subscribed', {
+                sessionId,
+                currentSequence: 0,
+            }));
+            clientSession.subscriptions.add(`terminal/${sessionId}`);
+            client.join(`terminal:${sessionId}`);
+            if (typeof lastSequence !== 'number') {
+                const { maxBytes: seedMaxBytes } = this.seedService.resolveSeedingConfig();
+                this.seedService
+                    .emitSeedToClient({
+                    client,
+                    sessionId,
+                    maxBytes: seedMaxBytes,
+                    cols,
+                    rows,
+                })
+                    .catch((error) => {
+                    logger.error({ sessionId, clientId: client.id, error }, 'Fallback seed failed');
+                });
+            }
+            return;
         }
-        else {
-            const previousAuthority = this.authorityBySession.get(sessionId);
-            this.setAuthority(sessionId, client.id);
-            logger.info({ sessionId, clientId: client.id, previousAuthority }, 'Transferred authority to subscribing client');
+        const tmuxAlive = await this.terminalIO.sessionExists({ name: session.tmuxSessionName });
+        if (!tmuxAlive) {
+            await this.handleDeadTmuxSession(sessionId, client);
+            return;
         }
+        await this.ensurePtyStreaming(sessionId, session.tmuxSessionName, { cols, rows });
         const isFirstAttach = typeof lastSequence !== 'number';
-        const hasResizeDimensions = typeof rows === 'number' && rows > 0 && typeof cols === 'number' && cols > 0;
-        if (hasResizeDimensions) {
-            const forceResize = isFirstAttach;
-            this.tryResizePty(sessionId, cols, rows, forceResize);
+        if (typeof rows === 'number' && rows > 0 && typeof cols === 'number' && cols > 0) {
+            this.ptyService.resize(sessionId, cols, rows);
             if (isFirstAttach) {
                 this.seedService.invalidateCache(sessionId);
-                await new Promise((resolve) => setTimeout(resolve, 50));
-                logger.debug({ sessionId, cols, rows }, 'Resized PTY and invalidated cache for first attach (cursor position via tmux)');
+                await new Promise((r) => setTimeout(r, 50));
             }
         }
-        else if (typeof rows === 'number' || typeof cols === 'number') {
-            logger.warn({ sessionId, rows, cols }, 'Ignoring resize request with partial dimensions');
-        }
-        const { maxBytes: seedMaxBytes } = this.seedService.resolveSeedingConfig();
-        logger.info({ sessionId, seedMaxBytes, source: 'tmux-ansi' }, 'Resolved seeding config');
-        const confirmEnvelope = (0, ws_envelope_dto_1.createEnvelope)(`terminal/${sessionId}`, 'subscribed', {
+        client.emit('message', (0, ws_envelope_dto_1.createEnvelope)(`terminal/${sessionId}`, 'subscribed', {
             sessionId,
             currentSequence: this.streamService.getCurrentSequence(sessionId),
-        });
-        client.emit('message', confirmEnvelope);
+        }));
         clientSession.subscriptions.add(`terminal/${sessionId}`);
         client.join(`terminal:${sessionId}`);
-        if (isFirstAttach) {
-            this.seedService
-                .emitSeedToClient({
-                client,
-                sessionId,
-                maxBytes: seedMaxBytes,
-                cols,
-                rows,
-            })
-                .catch((error) => {
-                logger.error({ sessionId, clientId: client.id, error }, 'Seed failed');
-            });
-        }
-        else {
+        this.wireFrameListener(sessionId);
+        session.subscribe(client.id);
+        if (!isFirstAttach) {
             const bufferedFrames = this.streamService.getFramesSince(sessionId, lastSequence);
-            if (bufferedFrames.length > 0) {
-                logger.info({ clientId: client.id, sessionId, frameCount: bufferedFrames.length }, 'Replaying buffered frames');
-                bufferedFrames.forEach((frame) => {
-                    client.emit('message', frame);
-                });
+            for (const frame of bufferedFrames) {
+                client.emit('message', frame);
             }
         }
     }
     handleEventsSubscribe(client) {
-        const clientSession = this.clientSessions.get(client.id);
-        if (!clientSession) {
-            logger.warn({ clientId: client.id }, 'Skipping events subscribe with no client session');
+        const cs = this.clientSessions.get(client.id);
+        if (!cs)
             return;
-        }
-        clientSession.subscriptions.add('events/logs');
-        const confirmEnvelope = (0, ws_envelope_dto_1.createEnvelope)('events/logs', 'subscribed', { ok: true });
-        client.emit('message', confirmEnvelope);
+        cs.subscriptions.add('events');
+        client.join('events');
+        logger.debug({ clientId: client.id }, 'Subscribed to events');
     }
     handleChatSubscribe(client, payload) {
-        const { threadId } = payload;
-        logger.info({ clientId: client.id, threadId }, 'Client subscribing to chat thread');
-        const clientSession = this.clientSessions.get(client.id);
-        if (!clientSession) {
+        const cs = this.clientSessions.get(client.id);
+        if (!cs)
             return;
-        }
-        clientSession.subscriptions.add(`chat/${threadId}`);
-        client.join(`chat:${threadId}`);
-        const confirmEnvelope = (0, ws_envelope_dto_1.createEnvelope)(`chat/${threadId}`, 'subscribed', { threadId });
-        client.emit('message', confirmEnvelope);
+        const topic = `chat/${payload.threadId}`;
+        cs.subscriptions.add(topic);
+        client.join(`chat:${payload.threadId}`);
+        logger.debug({ clientId: client.id, threadId: payload.threadId }, 'Joined chat room');
     }
     handleChatUnsubscribe(client, payload) {
-        const { threadId } = payload;
-        logger.info({ clientId: client.id, threadId }, 'Client unsubscribing from chat thread');
-        const clientSession = this.clientSessions.get(client.id);
-        if (clientSession) {
-            clientSession.subscriptions.delete(`chat/${threadId}`);
-        }
-        client.leave(`chat:${threadId}`);
+        const cs = this.clientSessions.get(client.id);
+        if (!cs)
+            return;
+        cs.subscriptions.delete(`chat/${payload.threadId}`);
+        client.leave(`chat:${payload.threadId}`);
     }
     handleUnsubscribe(client, payload) {
         const { sessionId } = payload;
-        logger.info({ clientId: client.id, sessionId }, 'Client unsubscribing from session');
-        const clientSession = this.clientSessions.get(client.id);
-        if (clientSession) {
-            clientSession.subscriptions.delete(`terminal/${sessionId}`);
-            clientSession.subscriptions.delete(`session/${sessionId}`);
-        }
+        const cs = this.clientSessions.get(client.id);
+        if (!cs)
+            return;
+        cs.subscriptions.delete(`terminal/${sessionId}`);
+        cs.subscriptions.delete(`session/${sessionId}`);
         client.leave(`terminal:${sessionId}`);
         client.leave(`session:${sessionId}`);
+        const session = this.registry.get(sessionId);
+        if (session)
+            session.unsubscribe(client.id);
     }
-    handleFocus(client, payload) {
-        const { sessionId } = payload;
-        const clientSession = this.clientSessions.get(client.id);
-        if (!clientSession) {
-            logger.warn({ clientId: client.id }, 'Ignoring focus with no client session');
+    async handleTheme(client, payload) {
+        const cs = this.clientSessions.get(client.id);
+        if (!cs)
             return;
+        const { foregroundHex, backgroundHex } = payload ?? {};
+        if (!THEME_HEX_RE.test(foregroundHex) || !THEME_HEX_RE.test(backgroundHex)) {
+            throw new websockets_1.WsException('Invalid terminal:theme payload: foregroundHex and backgroundHex must be strict #RRGGBB hex');
+        }
+        const subscribedSessionIds = [...cs.subscriptions]
+            .filter((s) => s.startsWith('terminal/'))
+            .map((s) => s.slice('terminal/'.length));
+        for (const sessionId of subscribedSessionIds) {
+            const session = this.registry.get(sessionId);
+            if (!session)
+                continue;
+            const cached = this.themeCache.get(sessionId);
+            if (cached?.foregroundHex === foregroundHex && cached?.backgroundHex === backgroundHex) {
+                logger.debug({ sessionId }, 'terminal_theme_skipped_unchanged');
+                continue;
+            }
+            try {
+                await this.terminalIO.applyWindowTheme({ name: session.tmuxSessionName }, foregroundHex, backgroundHex);
+                this.themeCache.set(sessionId, { foregroundHex, backgroundHex });
+                logger.debug({ sessionId }, 'terminal_theme_applied');
+                void this.ptyService.triggerRedraw(sessionId);
+            }
+            catch (error) {
+                logger.debug({ sessionId, error: String(error) }, 'terminal_theme_apply_failed');
+            }
         }
-        if (!clientSession.subscriptions.has(`terminal/${sessionId}`)) {
-            logger.warn({ clientId: client.id, sessionId }, 'Client not subscribed to session; focus ignored');
+    }
+    handleFocus(client, payload) {
+        const session = this.registry.get(payload.sessionId);
+        if (!session)
+            return;
+        if (!session.hasSubscriber(client.id)) {
+            logger.warn({ sessionId: payload.sessionId, clientId: client.id, reason: 'not_subscriber' }, 'Focus rejected');
             return;
         }
-        this.setAuthority(sessionId, client.id);
+        session.claimAuthority(client.id);
     }
-    handleResize(client, payload) {
+    async handleResize(client, payload) {
         const { sessionId, rows, cols } = payload;
-        const currentAuthority = this.authorityBySession.get(sessionId);
-        if (currentAuthority && currentAuthority !== client.id) {
-            logger.debug({ clientId: client.id, sessionId, rows, cols, authority: currentAuthority }, 'Ignoring resize from non-authoritative client');
+        const session = this.registry.get(sessionId);
+        if (!session)
+            return;
+        const tmuxAlive = await this.terminalIO.sessionExists({ name: session.tmuxSessionName });
+        if (!tmuxAlive) {
+            await this.handleDeadTmuxSession(sessionId, client);
             return;
         }
-        const didResize = this.tryResizePty(sessionId, cols, rows);
-        if (didResize) {
-            const envelope = (0, ws_envelope_dto_1.createEnvelope)(`terminal/${sessionId}`, 'resize', { rows, cols });
-            this.server.to(`terminal:${sessionId}`).emit('message', envelope);
+        const result = session.resize(client.id, { cols, rows });
+        if (result.applied) {
+            this.ptyService.resize(sessionId, cols, rows);
+            this.server
+                .to(`terminal:${sessionId}`)
+                .emit('message', (0, ws_envelope_dto_1.createEnvelope)(`terminal/${sessionId}`, 'resize', { rows, cols }));
         }
     }
     async handleInput(client, payload) {
         const { sessionId, data, ttyMode = false } = payload;
-        logger.debug({ clientId: client.id, sessionId, dataLength: data.length }, 'Terminal input');
-        const sessionsService = this.moduleRef.get(sessions_service_1.SessionsService, { strict: false });
-        const tmuxService = this.moduleRef.get(tmux_service_1.TmuxService, { strict: false });
-        if (!sessionsService) {
-            logger.error({ sessionId }, 'SessionsService not available');
-            throw new Error('SessionsService not available');
+        const session = this.registry.get(sessionId);
+        if (!session) {
+            logger.warn({ sessionId }, 'Input for unknown session');
+            return;
         }
-        if (!tmuxService) {
-            logger.error({ sessionId }, 'TmuxService not available');
-            throw new Error('TmuxService not available');
+        if (!session.hasSubscriber(client.id)) {
+            logger.warn({ sessionId, clientId: client.id, reason: 'not_subscriber' }, 'Input rejected');
+            return;
         }
-        const session = sessionsService.getSession(sessionId);
-        if (!session) {
-            logger.error({ sessionId }, 'Session not found');
-            throw new Error(`Session not found: ${sessionId}`);
+        if (session.getAuthority() !== client.id) {
+            logger.warn({ sessionId, clientId: client.id, reason: 'not_authority' }, 'Input rejected');
+            return;
         }
-        if (!session.tmuxSessionId) {
-            logger.error({ sessionId }, 'Session has no tmux session ID');
-            throw new Error(`Session has no tmux session ID: ${sessionId}`);
+        this.trackInputRate(client.id, sessionId, data.length);
+        const tmuxAlive = await this.terminalIO.sessionExists({ name: session.tmuxSessionName });
+        if (!tmuxAlive) {
+            await this.handleDeadTmuxSession(sessionId, client);
+            return;
         }
+        session.signalInput();
+        const target = { name: session.tmuxSessionName };
         if ((0, control_keys_1.isControlKey)(data)) {
-            const keys = (0, control_keys_1.toTmuxKeys)(data);
-            await tmuxService.sendKeys(session.tmuxSessionId, keys);
-            logger.debug({ sessionId, tmuxSessionId: session.tmuxSessionId, keys }, 'Sent raw keys');
+            await this.terminalIO.sendControl(target, (0, control_keys_1.toTmuxKeys)(data));
         }
         else if (ttyMode) {
-            await tmuxService.sendKeys(session.tmuxSessionId, ['-l', data]);
-            logger.debug({ sessionId, tmuxSessionId: session.tmuxSessionId, dataLength: data.length }, 'Sent TTY literal keys');
+            await this.terminalIO.sendControl(target, ['-l', '--', data]);
         }
         else {
             try {
-                await tmuxService.pasteAndSubmit(session.tmuxSessionId, data, { bracketed: true });
-                logger.debug({ sessionId, tmuxSessionId: session.tmuxSessionId }, 'Text pasted and submitted');
+                await this.terminalIO.deliverImmediate(target, data, { bracketed: true });
             }
             catch (error) {
-                logger.warn({ sessionId, tmuxSessionId: session.tmuxSessionId, error: String(error) }, 'pasteAndSubmit failed in form-mode input');
+                logger.warn({ sessionId, error: String(error) }, 'deliverImmediate failed');
             }
         }
     }
-    isControlCharacter(data) {
-        return (0, control_keys_1.isControlKey)(data);
-    }
-    convertToTmuxKeys(data) {
-        const mapped = (0, control_keys_1.toTmuxKeys)(data);
-        if (mapped.length === 1 && mapped[0] === data) {
-            logger.warn({ data }, 'Unknown control character, sending as literal');
-        }
-        return mapped;
-    }
     async handleRequestFullHistory(client, payload) {
         const { sessionId } = payload;
-        let clientMaxLines = 10000;
+        let maxLines = 10000;
         if (payload.maxLines !== undefined && payload.maxLines !== null) {
             const parsed = Math.floor(Number(payload.maxLines));
             if (!Number.isFinite(parsed) || parsed < 1) {
-                logger.warn({ clientId: client.id, sessionId, rawMaxLines: payload.maxLines }, 'Invalid maxLines value, must be positive integer');
                 throw new websockets_1.WsException('maxLines must be a positive integer');
             }
-            clientMaxLines = parsed;
-        }
-        const effectiveScrollback = this.settingsService.getScrollbackLines();
-        const maxLines = Math.min(clientMaxLines, effectiveScrollback);
-        if (clientMaxLines > effectiveScrollback) {
-            logger.warn({
-                clientId: client.id,
-                sessionId,
-                clientMaxLines,
-                effectiveScrollback,
-                clampedTo: maxLines,
-            }, 'Client requested more lines than scrollback setting allows, clamping');
+            maxLines = parsed;
         }
-        logger.debug({ clientId: client.id, sessionId, maxLines }, 'Requesting full history');
-        const clientSession = this.clientSessions.get(client.id);
-        if (!clientSession?.subscriptions.has(`terminal/${sessionId}`)) {
-            logger.warn({ sessionId, clientId: client.id }, 'History request from unsubscribed client');
+        maxLines = Math.min(maxLines, this.settingsService.getScrollbackLines());
+        const cs = this.clientSessions.get(client.id);
+        if (!cs?.subscriptions.has(`terminal/${sessionId}`))
+            return;
+        const session = this.registry.get(sessionId);
+        if (!session)
             return;
-        }
         const capturedSequence = this.streamService.getCurrentSequence(sessionId);
-        logger.debug({ sessionId, capturedSequence }, 'Captured sequence for history deduplication');
-        let history = '';
-        try {
-            const sessionsService = this.moduleRef.get(sessions_service_1.SessionsService, { strict: false });
-            const tmuxService = this.moduleRef.get(tmux_service_1.TmuxService, { strict: false });
-            if (sessionsService && tmuxService) {
-                const session = sessionsService.getSession(sessionId);
-                if (session?.tmuxSessionId) {
-                    logger.info({ sessionId, tmuxSessionId: session.tmuxSessionId, maxLines }, 'Capturing full tmux history');
-                    history = await tmuxService.capturePane(session.tmuxSessionId, maxLines, true);
-                    if (history && history.length > 0) {
-                        logger.info({ sessionId, historyBytes: history.length }, 'Captured full tmux history successfully');
-                    }
-                }
-            }
-        }
-        catch (error) {
-            logger.warn({ sessionId, error }, 'Failed to capture tmux history');
-        }
-        if (!history || history.length === 0) {
-            logger.info({ sessionId }, 'No tmux history available, returning empty history');
-        }
-        if (history.endsWith('\n')) {
+        const target = { name: session.tmuxSessionName };
+        const captureResult = await this.terminalIO.captureHistory(target, maxLines, true);
+        let history = captureResult.ok ? captureResult.output : '';
+        if (history.endsWith('\n'))
             history = history.slice(0, -1);
-        }
         const { maxBytes } = this.seedService.resolveSeedingConfig();
         let hasHistory = false;
-        const historyByteLength = Buffer.byteLength(history, 'utf-8');
-        if (historyByteLength > maxBytes) {
+        if (Buffer.byteLength(history, 'utf-8') > maxBytes) {
             const { truncated, wasTruncated } = this.seedService.truncateToMaxBytes(history, maxBytes);
             history = truncated;
             hasHistory = wasTruncated;
-            if (wasTruncated) {
-                logger.info({ sessionId, originalBytes: historyByteLength, maxBytes, truncatedBytes: history.length }, 'Truncated full history response to fit maxBytes limit');
-            }
         }
-        let cursorX;
-        let cursorY;
-        try {
-            const sessionsService = this.moduleRef.get(sessions_service_1.SessionsService, { strict: false });
-            const tmuxService = this.moduleRef.get(tmux_service_1.TmuxService, { strict: false });
-            if (sessionsService && tmuxService) {
-                const session = sessionsService.getSession(sessionId);
-                if (session?.tmuxSessionId) {
-                    const cursorPos = await tmuxService.getCursorPosition(session.tmuxSessionId);
-                    if (cursorPos) {
-                        cursorX = cursorPos.x;
-                        cursorY = cursorPos.y;
-                        logger.debug({ sessionId, cursorX, cursorY }, 'Captured cursor position for history');
-                    }
-                }
-            }
+        if (this.sessionsService.shouldNormalizeLfFor(sessionId)) {
+            history = (0, normalize_line_endings_1.normalizeLineEndings)(history);
         }
-        catch (error) {
-            logger.warn({ sessionId, error }, 'Failed to get cursor position for history');
-        }
-        const envelope = (0, ws_envelope_dto_1.createEnvelope)(`terminal/${sessionId}`, 'full_history', {
+        const cursorPos = await this.terminalIO.getCursorPosition(target);
+        client.emit('message', (0, ws_envelope_dto_1.createEnvelope)(`terminal/${sessionId}`, 'full_history', {
             history,
-            cursorX,
-            cursorY,
-            hasHistory,
-            capturedSequence,
-        });
-        client.emit('message', envelope);
-        logger.debug({
-            clientId: client.id,
-            sessionId,
-            historyBytes: history.length,
-            cursorX,
-            cursorY,
+            cursorX: cursorPos?.x,
+            cursorY: cursorPos?.y,
             hasHistory,
             capturedSequence,
-        }, 'Sent full ANSI history with cursor position and sequence');
+        }));
     }
     handlePong(client) {
-        const clientSession = this.clientSessions.get(client.id);
-        if (clientSession) {
-            clientSession.lastHeartbeat = new Date();
-        }
+        const cs = this.clientSessions.get(client.id);
+        if (cs)
+            cs.lastHeartbeat = new Date();
     }
     broadcastTerminalData(sessionId, data) {
+        this.registry.get(sessionId)?.pushFrame(data);
         const envelope = this.streamService.addFrame(sessionId, data);
         this.server.to(`terminal:${sessionId}`).emit('message', envelope);
     }
-    broadcastEvent(topic, type, payload) {
-        const envelope = (0, ws_envelope_dto_1.createEnvelope)(topic, type, payload);
-        logger.debug({ topic, type }, 'Broadcasting event');
-        this.server.emit('message', envelope);
-    }
     handleSessionCrashed(payload) {
-        const { sessionId, sessionName } = payload;
-        logger.info({ sessionId, sessionName }, 'Session crashed - broadcasting to clients');
-        const eventPayload = {
-            sessionId,
+        const ep = {
+            sessionId: payload.sessionId,
             status: 'crashed',
             message: 'Session unexpectedly terminated',
         };
-        const envelope = (0, ws_envelope_dto_1.createEnvelope)(`session/${sessionId}`, 'state_change', eventPayload);
-        this.server.to(`session:${sessionId}`).emit('message', envelope);
-        setTimeout(() => {
-            this.streamService.clearBuffer(sessionId);
-        }, 60000);
+        this.server
+            .to(`session:${payload.sessionId}`)
+            .emit('message', (0, ws_envelope_dto_1.createEnvelope)(`session/${payload.sessionId}`, 'state_change', ep));
+        setTimeout(() => this.streamService.clearBuffer(payload.sessionId), 60000);
+        this.themeCache.delete(payload.sessionId);
     }
     handleSessionStarted(payload) {
-        const { sessionId, epicId, agentId } = payload;
-        logger.info({ sessionId, epicId, agentId }, 'Session started - broadcasting to clients');
-        const eventPayload = {
-            sessionId,
+        const ep = {
+            sessionId: payload.sessionId,
             status: 'started',
             message: 'Session started successfully',
         };
-        const envelope = (0, ws_envelope_dto_1.createEnvelope)('sessions', 'started', eventPayload);
-        this.server.emit('message', envelope);
+        this.server.emit('message', (0, ws_envelope_dto_1.createEnvelope)('sessions', 'started', ep));
     }
     handleSessionRestored(payload) {
-        const { sessionId, epicId, agentId } = payload;
-        logger.info({ sessionId, epicId, agentId }, 'Session restored - broadcasting to clients');
-        const eventPayload = {
-            sessionId,
+        if (!this.registry.get(payload.sessionId) && payload.tmuxSessionName) {
+            try {
+                this.registry.create(payload.sessionId, payload.tmuxSessionName, {
+                    normalizeCapturedLineEndings: this.sessionsService.shouldNormalizeLfFor(payload.sessionId),
+                });
+                this.registry.bind(payload.sessionId, this.terminalIO);
+            }
+            catch {
+            }
+        }
+        const ep = {
+            sessionId: payload.sessionId,
             status: 'started',
             message: 'Session restored successfully',
         };
-        const envelope = (0, ws_envelope_dto_1.createEnvelope)('sessions', 'started', eventPayload);
-        this.server.emit('message', envelope);
+        this.server.emit('message', (0, ws_envelope_dto_1.createEnvelope)('sessions', 'started', ep));
     }
     handleSessionStopped(payload) {
-        const { sessionId } = payload;
-        logger.info({ sessionId }, 'Session stopped - broadcasting to clients');
-        const eventPayload = {
-            sessionId,
+        const ep = {
+            sessionId: payload.sessionId,
             status: 'ended',
             message: 'Session terminated',
         };
-        const envelope = (0, ws_envelope_dto_1.createEnvelope)('sessions', 'stopped', eventPayload);
-        this.server.emit('message', envelope);
-        setTimeout(() => {
-            this.streamService.clearBuffer(sessionId);
-        }, 60000);
-        this.seedService.invalidateCache(sessionId);
+        this.server.emit('message', (0, ws_envelope_dto_1.createEnvelope)('sessions', 'stopped', ep));
+        setTimeout(() => this.streamService.clearBuffer(payload.sessionId), 60000);
+        this.seedService.invalidateCache(payload.sessionId);
+        this.themeCache.delete(payload.sessionId);
     }
     startHeartbeat() {
         this.heartbeatInterval = setInterval(() => {
             const now = new Date();
-            this.clientSessions.forEach((session, clientId) => {
-                const timeSinceLastHeartbeat = now.getTime() - session.lastHeartbeat.getTime();
-                if (timeSinceLastHeartbeat > this.HEARTBEAT_TIMEOUT) {
-                    logger.warn({ clientId }, 'Client heartbeat timeout - disconnecting');
-                    const client = this.server.sockets.sockets.get(clientId);
-                    if (client) {
-                        client.disconnect(true);
-                    }
+            this.clientSessions.forEach((cs, clientId) => {
+                if (now.getTime() - cs.lastHeartbeat.getTime() > HEARTBEAT_TIMEOUT) {
+                    logger.warn({ clientId }, 'Client heartbeat timeout');
+                    this.server.sockets.sockets.get(clientId)?.disconnect(true);
                     this.clientSessions.delete(clientId);
                 }
                 else {
-                    const client = this.server.sockets.sockets.get(clientId);
-                    if (client) {
-                        this.sendHeartbeat(client);
-                    }
+                    const sock = this.server.sockets.sockets.get(clientId);
+                    if (sock)
+                        this.sendHeartbeat(sock);
                 }
             });
-        }, this.HEARTBEAT_INTERVAL);
-        logger.info({ intervalMs: this.HEARTBEAT_INTERVAL }, 'Heartbeat started');
+        }, HEARTBEAT_INTERVAL);
     }
     sendHeartbeat(client) {
-        const payload = {
-            timestamp: new Date().toISOString(),
-        };
-        const envelope = (0, ws_envelope_dto_1.createEnvelope)('system', 'ping', payload);
-        client.emit('message', envelope);
+        const p = { timestamp: new Date().toISOString() };
+        client.emit('message', (0, ws_envelope_dto_1.createEnvelope)('system', 'ping', p));
     }
-    setAuthority(sessionId, clientId) {
-        const current = this.authorityBySession.get(sessionId);
-        if (current === clientId)
+    wireFrameListener(sessionId) {
+        if (this.frameListeners.has(sessionId))
             return;
-        this.authorityBySession.set(sessionId, clientId);
-        const focusEnvelope = (0, ws_envelope_dto_1.createEnvelope)(`terminal/${sessionId}`, 'focus_changed', {
-            sessionId,
-            clientId,
-        });
-        this.server.to(`terminal:${sessionId}`).emit('message', focusEnvelope);
+        const session = this.registry.get(sessionId);
+        if (!session)
+            return;
+        const FORWARDED_FRAME_TYPES = new Set([
+            'focus_changed',
+            'seed_ansi',
+            'resize_jiggle',
+            'full_history',
+        ]);
+        const listener = (frame) => {
+            if (FORWARDED_FRAME_TYPES.has(frame.type)) {
+                this.server
+                    .to(`terminal:${sessionId}`)
+                    .emit('message', (0, ws_envelope_dto_1.createEnvelope)(`terminal/${sessionId}`, frame.type, frame.payload));
+            }
+        };
+        session.stream.on('frame', listener);
+        this.frameListeners.set(sessionId, listener);
     }
-    tryResizePty(sessionId, cols, rows, force = false) {
-        let actualPtyDims = null;
-        try {
-            actualPtyDims = this.ptyService.getDimensions(sessionId);
-        }
-        catch (error) {
-            logger.warn({ sessionId, error }, 'Failed to get PTY dimensions, will resize anyway');
-        }
-        if (!force && actualPtyDims && actualPtyDims.cols === cols && actualPtyDims.rows === rows) {
-            this.lastDimensions.set(sessionId, { cols, rows });
-            return false;
-        }
-        this.lastDimensions.set(sessionId, { cols, rows });
-        logger.debug({ sessionId, cols, rows, forced: force }, 'Resizing PTY');
-        this.ptyService.resize(sessionId, cols, rows);
-        return true;
+    async handleDeadTmuxSession(sessionId, client) {
+        logger.warn({ sessionId }, 'Dead tmux detected — marking session failed');
+        this.sessionsService.markSessionFailed(sessionId, 'tmux session no longer exists');
+        this.ptyService.stopStreaming(sessionId);
+        this.registry.dispose(sessionId);
+        this.themeCache.delete(sessionId);
+        const ep = {
+            sessionId,
+            status: 'crashed',
+            message: 'Terminal session is no longer available',
+        };
+        const envelope = (0, ws_envelope_dto_1.createEnvelope)(`session/${sessionId}`, 'state_change', ep);
+        client.emit('message', envelope);
+        this.server.to(`session:${sessionId}`).emit('message', envelope);
     }
-    async ensurePtyStreaming(sessionId) {
-        if (this.ptyService.isStreaming(sessionId)) {
-            logger.debug({ sessionId }, 'PTY already streaming');
+    async ensurePtyStreaming(sessionId, tmuxSessionName, options) {
+        if (this.ptyService.isStreaming(sessionId))
             return;
-        }
-        logger.info({ sessionId }, 'PTY not streaming, checking if session is still active');
-        try {
-            const sessionsService = this.moduleRef.get(sessions_service_1.SessionsService, { strict: false });
-            if (!sessionsService) {
-                logger.error({ sessionId }, 'SessionsService not available');
-                return;
-            }
-            const session = sessionsService.getSession(sessionId);
-            if (!session) {
-                logger.warn({ sessionId }, 'Session not found in database');
-                return;
-            }
-            if (session.status !== 'running') {
-                logger.warn({ sessionId, status: session.status }, 'Session is not running');
-                return;
-            }
-            if (!session.tmuxSessionId) {
-                logger.warn({ sessionId }, 'Session has no tmux session ID');
-                return;
-            }
-            const tmuxService = this.moduleRef.get(tmux_service_1.TmuxService, { strict: false });
-            if (!tmuxService) {
-                logger.error({ sessionId }, 'TmuxService not available');
-                return;
-            }
-            const tmuxExists = await tmuxService.hasSession(session.tmuxSessionId);
-            if (!tmuxExists) {
-                logger.warn({ sessionId, tmuxSessionId: session.tmuxSessionId }, 'Tmux session no longer exists');
-                return;
+        const alive = await this.terminalIO.sessionExists({ name: tmuxSessionName });
+        if (!alive)
+            return;
+        await this.ptyService.startStreaming(sessionId, tmuxSessionName, options);
+    }
+    trackInputRate(clientId, sessionId, dataBytes) {
+        const key = `${clientId}:${sessionId}`;
+        const now = Date.now();
+        let entry = this.inputRateTracker.get(key);
+        if (!entry) {
+            entry = { messages: 0, bytes: 0, windowStart: now, warned: false };
+            this.inputRateTracker.set(key, entry);
+        }
+        const elapsed = now - entry.windowStart;
+        if (elapsed >= INPUT_RATE_WINDOW_MS) {
+            if (!entry.warned &&
+                (entry.messages > INPUT_RATE_MSG_THRESHOLD || entry.bytes > INPUT_RATE_BYTES_THRESHOLD)) {
+                const windowSec = elapsed / 1000;
+                logger.warn({
+                    clientId,
+                    sessionId,
+                    msgRate: Math.round(entry.messages / windowSec),
+                    byteRate: Math.round(entry.bytes / windowSec),
+                    messages: entry.messages,
+                    bytes: entry.bytes,
+                    windowMs: elapsed,
+                }, 'Input rate threshold exceeded');
             }
-            logger.info({ sessionId, tmuxSessionId: session.tmuxSessionId }, 'Restarting PTY streaming for active session');
-            await this.ptyService.startStreaming(sessionId, session.tmuxSessionId);
-        }
-        catch (error) {
-            logger.error({ sessionId, error }, 'Error ensuring PTY streaming');
+            entry.messages = 0;
+            entry.bytes = 0;
+            entry.windowStart = now;
+            entry.warned = false;
         }
+        entry.messages++;
+        entry.bytes += dataBytes;
     }
     onModuleDestroy() {
-        if (this.heartbeatInterval) {
+        if (this.heartbeatInterval)
             clearInterval(this.heartbeatInterval);
+        for (const [sessionId, listener] of this.frameListeners) {
+            const session = this.registry.get(sessionId);
+            if (session)
+                session.stream.off('frame', listener);
         }
+        this.frameListeners.clear();
+        this.themeCache.clear();
     }
 };
 exports.TerminalGateway = TerminalGateway;
@@ -553,18 +489,6 @@ __decorate([
     (0, websockets_1.WebSocketServer)(),
     __metadata("design:type", socket_io_1.Server)
 ], TerminalGateway.prototype, "server", void 0);
-__decorate([
-    __param(0, (0, websockets_1.ConnectedSocket)()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [socket_io_1.Socket]),
-    __metadata("design:returntype", void 0)
-], TerminalGateway.prototype, "handleConnection", null);
-__decorate([
-    __param(0, (0, websockets_1.ConnectedSocket)()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [socket_io_1.Socket]),
-    __metadata("design:returntype", void 0)
-], TerminalGateway.prototype, "handleDisconnect", null);
 __decorate([
     (0, websockets_1.SubscribeMessage)('terminal:subscribe'),
     __param(0, (0, websockets_1.ConnectedSocket)()),
@@ -604,6 +528,14 @@ __decorate([
     __metadata("design:paramtypes", [socket_io_1.Socket, Object]),
     __metadata("design:returntype", void 0)
 ], TerminalGateway.prototype, "handleUnsubscribe", null);
+__decorate([
+    (0, websockets_1.SubscribeMessage)('terminal:theme'),
+    __param(0, (0, websockets_1.ConnectedSocket)()),
+    __param(1, (0, websockets_1.MessageBody)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [socket_io_1.Socket, Object]),
+    __metadata("design:returntype", Promise)
+], TerminalGateway.prototype, "handleTheme", null);
 __decorate([
     (0, websockets_1.SubscribeMessage)('terminal:focus'),
     __param(0, (0, websockets_1.ConnectedSocket)()),
@@ -618,7 +550,7 @@ __decorate([
     __param(1, (0, websockets_1.MessageBody)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [socket_io_1.Socket, Object]),
-    __metadata("design:returntype", void 0)
+    __metadata("design:returntype", Promise)
 ], TerminalGateway.prototype, "handleResize", null);
 __decorate([
     (0, websockets_1.SubscribeMessage)('terminal:input'),
@@ -668,16 +600,18 @@ __decorate([
     __metadata("design:returntype", void 0)
 ], TerminalGateway.prototype, "handleSessionStopped", null);
 exports.TerminalGateway = TerminalGateway = __decorate([
-    (0, websockets_1.WebSocketGateway)({
-        cors: false,
-        transports: ['websocket'],
-    }),
+    (0, websockets_1.WebSocketGateway)({ cors: false, transports: ['websocket'] }),
     (0, common_1.Injectable)(),
     __param(2, (0, common_1.Inject)((0, common_1.forwardRef)(() => pty_service_1.PtyService))),
+    __param(4, (0, common_1.Inject)((0, common_1.forwardRef)(() => terminal_io_service_1.TerminalIOService))),
+    __param(6, (0, common_1.Inject)((0, common_1.forwardRef)(() => sessions_service_1.SessionsService))),
     __metadata("design:paramtypes", [terminal_stream_service_1.TerminalStreamService,
         settings_service_1.SettingsService,
         pty_service_1.PtyService,
-        core_1.ModuleRef,
-        terminal_seed_service_1.TerminalSeedService])
+        terminal_seed_service_1.TerminalSeedService,
+        terminal_io_service_1.TerminalIOService,
+        terminal_session_registry_1.TerminalSessionRegistry,
+        sessions_service_1.SessionsService,
+        realtime_broadcast_service_1.RealtimeBroadcastService])
 ], TerminalGateway);
 //# sourceMappingURL=terminal.gateway.js.map