devchain-cli 0.1.0

package/dist/server/modules/terminal/services/pty.service.d.ts

@@ -0,0 +1,29 @@
+import { OnModuleDestroy } from '@nestjs/common';
+import { TerminalGateway } from '../gateways/terminal.gateway';
+import { TerminalActivityService } from '../../mcp/services/terminal-activity.service';
+import { TerminalEmulatorService } from './terminal-emulator.service';
+import { TmuxService } from './tmux.service';
+import { SettingsService } from '../../settings/services/settings.service';
+export declare class PtyService implements OnModuleDestroy {
+    private readonly terminalGateway;
+    private readonly terminalActivity;
+    private readonly terminalEmulator;
+    private readonly tmuxService;
+    private readonly settingsService;
+    private activeSessions;
+    private readonly RESIZE_DISABLED;
+    private readonly sanitizerMode;
+    constructor(terminalGateway: TerminalGateway, terminalActivity: TerminalActivityService, terminalEmulator: TerminalEmulatorService, tmuxService: TmuxService, settingsService: SettingsService);
+    isSanitizerEnabled(): boolean;
+    onModuleDestroy(): void;
+    startStreaming(sessionId: string, tmuxSessionName: string): Promise<void>;
+    stopStreaming(sessionId: string): void;
+    resize(sessionId: string, cols: number, rows: number): void;
+    write(sessionId: string, data: string): void;
+    isStreaming(sessionId: string): boolean;
+    getActiveSessionCount(): number;
+    getDimensions(sessionId: string): {
+        cols: number;
+        rows: number;
+    } | null;
+}

package/dist/server/modules/terminal/services/pty.service.js

@@ -0,0 +1,236 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PtyService = void 0;
+const common_1 = require("@nestjs/common");
+const pty = __importStar(require("node-pty"));
+const logger_1 = require("../../../common/logging/logger");
+const terminal_gateway_1 = require("../gateways/terminal.gateway");
+const terminal_activity_service_1 = require("../../mcp/services/terminal-activity.service");
+const terminal_emulator_service_1 = require("./terminal-emulator.service");
+const tmux_service_1 = require("./tmux.service");
+const settings_service_1 = require("../../settings/services/settings.service");
+const ansi_sanitizer_1 = require("../utils/ansi-sanitizer");
+const logger = (0, logger_1.createLogger)('PtyService');
+let PtyService = class PtyService {
+    constructor(terminalGateway, terminalActivity, terminalEmulator, tmuxService, settingsService) {
+        this.terminalGateway = terminalGateway;
+        this.terminalActivity = terminalActivity;
+        this.terminalEmulator = terminalEmulator;
+        this.tmuxService = tmuxService;
+        this.settingsService = settingsService;
+        this.activeSessions = new Map();
+        this.RESIZE_DISABLED = false;
+        this.sanitizerMode = 'strip_alt';
+        let engine = 'xterm';
+        try {
+            const stored = this.settingsService.getSetting('terminal.engine');
+            if (stored && typeof stored === 'string')
+                engine = stored.trim().toLowerCase();
+        }
+        catch { }
+        logger.info({ engine, sanitizerMode: this.sanitizerMode }, 'PtyService initialized with ANSI sanitization (strip_alt)');
+    }
+    isSanitizerEnabled() {
+        return this.sanitizerMode !== 'off';
+    }
+    onModuleDestroy() {
+        for (const session of this.activeSessions.values()) {
+            this.stopStreaming(session.sessionId);
+        }
+    }
+    async startStreaming(sessionId, tmuxSessionName) {
+        if (this.activeSessions.has(sessionId)) {
+            logger.warn({ sessionId }, 'PTY session already active');
+            return;
+        }
+        try {
+            logger.info({ sessionId, tmuxSessionName }, 'Starting PTY streaming');
+            const ptyProcess = pty.spawn('tmux', ['attach-session', '-t', `=${tmuxSessionName}`], {
+                name: 'xterm-256color',
+                cols: 80,
+                rows: 24,
+                cwd: process.cwd(),
+                env: process.env,
+            });
+            const useMode = this.sanitizerMode;
+            this.activeSessions.set(sessionId, {
+                sessionId,
+                tmuxSessionName,
+                ptyProcess,
+                cols: 80,
+                rows: 24,
+                sanitizer: new ansi_sanitizer_1.AltAwareAnsiSanitizer(useMode === 'normalize' ? 'normalize' : 'strip_alt'),
+                sanitizeMode: useMode,
+                loggedPath: false,
+            });
+            this.terminalEmulator.initializeSession(sessionId);
+            ptyProcess.onData((data) => {
+                const sess = this.activeSessions.get(sessionId);
+                if (!sess) {
+                    return;
+                }
+                if (!sess.loggedPath) {
+                    logger.info({ sessionId, sanitizeMode: sess.sanitizeMode }, 'PTY data path selected (sanitize indicates server-side ANSI transform)');
+                    sess.loggedPath = true;
+                }
+                try {
+                    this.terminalActivity.observeChunk(sessionId, data);
+                }
+                catch (error) {
+                    logger.warn({ sessionId, error }, 'Activity observer failed');
+                }
+                const sanitized = sess.sanitizeMode === 'normalize'
+                    ? sess.sanitizer.process(data)
+                    : sess.sanitizeMode === 'strip_alt'
+                        ? (0, ansi_sanitizer_1.stripAlternateScreenSequences)(data)
+                        : data;
+                try {
+                    this.terminalEmulator.write(sessionId, sanitized);
+                }
+                catch (error) {
+                    logger.error({ sessionId, error }, 'Emulator write failed');
+                }
+                this.terminalGateway.broadcastTerminalData(sessionId, sanitized);
+            });
+            ptyProcess.onExit(({ exitCode, signal }) => {
+                logger.info({ sessionId, exitCode, signal }, 'PTY process exited');
+                this.activeSessions.delete(sessionId);
+                this.terminalActivity.clearSession(sessionId);
+                this.terminalEmulator.disposeSession(sessionId);
+            });
+            logger.info({ sessionId, tmuxSessionName }, 'PTY streaming started successfully');
+        }
+        catch (error) {
+            logger.error({ sessionId, tmuxSessionName, error }, 'Failed to start PTY streaming');
+            throw error;
+        }
+    }
+    stopStreaming(sessionId) {
+        const session = this.activeSessions.get(sessionId);
+        if (!session) {
+            logger.warn({ sessionId }, 'No active PTY session to stop');
+            return;
+        }
+        try {
+            logger.info({ sessionId }, 'Stopping PTY streaming');
+            session.ptyProcess.kill();
+            this.activeSessions.delete(sessionId);
+            this.terminalActivity.clearSession(sessionId);
+            this.terminalEmulator.disposeSession(sessionId);
+            logger.info({ sessionId }, 'PTY streaming stopped');
+        }
+        catch (error) {
+            logger.error({ sessionId, error }, 'Error stopping PTY streaming');
+        }
+    }
+    resize(sessionId, cols, rows) {
+        const session = this.activeSessions.get(sessionId);
+        if (!session) {
+            logger.warn({ sessionId }, 'Cannot resize: no active PTY session');
+            return;
+        }
+        try {
+            const isInitialResize = session.cols === 80 && session.rows === 24;
+            if (this.RESIZE_DISABLED && !isInitialResize) {
+                logger.info({ sessionId, cols, rows }, 'Dynamic resize disabled; skipping PTY resize');
+                return;
+            }
+            if (session.cols === cols && session.rows === rows) {
+                logger.debug({ sessionId, cols, rows }, 'Skip PTY resize (dimensions unchanged)');
+            }
+            else {
+                session.ptyProcess.resize(cols, rows);
+                session.cols = cols;
+                session.rows = rows;
+                logger.info({ sessionId, cols, rows, isInitial: isInitialResize }, 'PTY resized');
+            }
+        }
+        catch (error) {
+            logger.error({ sessionId, cols, rows, error }, 'Error resizing PTY');
+        }
+    }
+    write(sessionId, data) {
+        const session = this.activeSessions.get(sessionId);
+        if (!session) {
+            logger.warn({ sessionId }, 'Cannot write: no active PTY session');
+            return;
+        }
+        try {
+            session.ptyProcess.write(data);
+        }
+        catch (error) {
+            logger.error({ sessionId, error }, 'Error writing to PTY');
+        }
+    }
+    isStreaming(sessionId) {
+        return this.activeSessions.has(sessionId);
+    }
+    getActiveSessionCount() {
+        return this.activeSessions.size;
+    }
+    getDimensions(sessionId) {
+        const session = this.activeSessions.get(sessionId);
+        if (!session) {
+            return null;
+        }
+        return { cols: session.cols, rows: session.rows };
+    }
+};
+exports.PtyService = PtyService;
+exports.PtyService = PtyService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)((0, common_1.forwardRef)(() => terminal_gateway_1.TerminalGateway))),
+    __param(1, (0, common_1.Inject)((0, common_1.forwardRef)(() => terminal_activity_service_1.TerminalActivityService))),
+    __param(3, (0, common_1.Inject)((0, common_1.forwardRef)(() => tmux_service_1.TmuxService))),
+    __metadata("design:paramtypes", [terminal_gateway_1.TerminalGateway,
+        terminal_activity_service_1.TerminalActivityService,
+        terminal_emulator_service_1.TerminalEmulatorService,
+        tmux_service_1.TmuxService,
+        settings_service_1.SettingsService])
+], PtyService);
+//# sourceMappingURL=pty.service.js.map

package/dist/server/modules/terminal/services/pty.service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pty.service.js","sourceRoot":"","sources":["../../../../src/modules/terminal/services/pty.service.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,2CAAiF;AACjF,8CAAgC;AAChC,2DAA8D;AAC9D,mEAA+D;AAC/D,4FAAuF;AACvF,2EAAsE;AACtE,iDAA6C;AAC7C,+EAA2E;AAC3E,4DAA+F;AAE/F,MAAM,MAAM,GAAG,IAAA,qBAAY,EAAC,YAAY,CAAC,CAAC;AAmBnC,IAAM,UAAU,GAAhB,MAAM,UAAU;IAMrB,YAEE,eAAiD,EAEjD,gBAA0D,EACzC,gBAAyC,EAE1D,WAAyC,EACxB,eAAgC;QANhC,oBAAe,GAAf,eAAe,CAAiB;QAEhC,qBAAgB,GAAhB,gBAAgB,CAAyB;QACzC,qBAAgB,GAAhB,gBAAgB,CAAyB;QAEzC,gBAAW,GAAX,WAAW,CAAa;QACxB,oBAAe,GAAf,eAAe,CAAiB;QAb3C,mBAAc,GAA4B,IAAI,GAAG,EAAE,CAAC;QAE3C,oBAAe,GAAY,KAAK,CAAC;QAgBhD,IAAI,CAAC,aAAa,GAAG,WAAW,CAAC;QACjC,IAAI,MAAM,GAAG,OAAO,CAAC;QACrB,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,IAAI,CAAC,eAAe,CAAC,UAAU,CAAC,iBAAiB,CAAC,CAAC;YAClE,IAAI,MAAM,IAAI,OAAO,MAAM,KAAK,QAAQ;gBAAE,MAAM,GAAG,MAAM,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;QACjF,CAAC;QAAC,MAAM,CAAC,CAAA,CAAC;QACV,MAAM,CAAC,IAAI,CACT,EAAE,MAAM,EAAE,aAAa,EAAE,IAAI,CAAC,aAAa,EAAE,EAC7C,2DAA2D,CAC5D,CAAC;IACJ,CAAC;IAGD,kBAAkB;QAChB,OAAO,IAAI,CAAC,aAAa,KAAK,KAAK,CAAC;IACtC,CAAC;IAED,eAAe;QAEb,KAAK,MAAM,OAAO,IAAI,IAAI,CAAC,cAAc,CAAC,MAAM,EAAE,EAAE,CAAC;YACnD,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;QACxC,CAAC;IACH,CAAC;IAMD,KAAK,CAAC,cAAc,CAAC,SAAiB,EAAE,eAAuB;QAC7D,IAAI,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,CAAC;YACvC,MAAM,CAAC,IAAI,CAAC,EAAE,SAAS,EAAE,EAAE,4BAA4B,CAAC,CAAC;YACzD,OAAO;QACT,CAAC;QAED,IAAI,CAAC;YACH,MAAM,CAAC,IAAI,CAAC,EAAE,SAAS,EAAE,eAAe,EAAE,EAAE,wBAAwB,CAAC,CAAC;YAItE,MAAM,UAAU,GAAG,GAAG,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,gBAAgB,EAAE,IAAI,EAAE,IAAI,eAAe,EAAE,CAAC,EAAE;gBACpF,IAAI,EAAE,gBAAgB;gBACtB,IAAI,EAAE,EAAE;gBACR,IAAI,EAAE,EAAE;gBACR,GAAG,EAAE,OAAO,CAAC,GAAG,EAAE;gBAClB,GAAG,EAAE,OAAO,CAAC,GAAgC;aAC9C,CAAC,CAAC;YAGH,MAAM,OAAO,GAAG,IAAI,CAAC,aAAa,CAAC;YACnC,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,SAAS,EAAE;gBACjC,SAAS;gBACT,eAAe;gBACf,UAAU;gBACV,IAAI,EAAE,EAAE;gBACR,IAAI,EAAE,EAAE;gBACR,SAAS,EAAE,IAAI,sCAAqB,CAAC,OAAO,KAAK,WAAW,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,WAAW,CAAC;gBACzF,YAAY,EAAE,OAAO;gBACrB,UAAU,EAAE,KAAK;aAClB,CAAC,CAAC;YAEH,IAAI,CAAC,gBAAgB,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC;YAQnD,UAAU,CAAC,MAAM,CAAC,CAAC,IAAY,EAAE,EAAE;gBACjC,MAAM,IAAI,GAAG,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;gBAChD,IAAI,CAAC,IAAI,EAAE,CAAC;oBAEV,OAAO;gBACT,CAAC;gBACD,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC;oBACrB,MAAM,CAAC,IAAI,CACT,EAAE,SAAS,EAAE,YAAY,EAAE,IAAI,CAAC,YAAY,EAAE,EAC9C,wEAAwE,CACzE,CAAC;oBACF,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;gBACzB,CAAC;gBACD,IAAI,CAAC;oBAEH,IAAI,CAAC,gBAAgB,CAAC,YAAY,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;gBACtD,CAAC;gBAAC,OAAO,KAAK,EAAE,CAAC;oBACf,MAAM,CAAC,IAAI,CAAC,EAAE,SAAS,EAAE,KAAK,EAAE,EAAE,0BAA0B,CAAC,CAAC;gBAChE,CAAC;gBAED,MAAM,SAAS,GACb,IAAI,CAAC,YAAY,KAAK,WAAW;oBAC/B,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,IAAI,CAAC;oBAC9B,CAAC,CAAC,IAAI,CAAC,YAAY,KAAK,WAAW;wBACjC,CAAC,CAAC,IAAA,8CAA6B,EAAC,IAAI,CAAC;wBACrC,CAAC,CAAC,IAAI,CAAC;gBACb,IAAI,CAAC;oBACH,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC;gBACpD,CAAC;gBAAC,OAAO,KAAK,EAAE,CAAC;oBACf,MAAM,CAAC,KAAK,CAAC,EAAE,SAAS,EAAE,KAAK,EAAE,EAAE,uBAAuB,CAAC,CAAC;gBAC9D,CAAC;gBAED,IAAI,CAAC,eAAe,CAAC,qBAAqB,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC;YACnE,CAAC,CAAC,CAAC;YAGH,UAAU,CAAC,MAAM,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE;gBACzC,MAAM,CAAC,IAAI,CAAC,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,oBAAoB,CAAC,CAAC;gBACnE,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;gBACtC,IAAI,CAAC,gBAAgB,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;gBAC9C,IAAI,CAAC,gBAAgB,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC;YAClD,CAAC,CAAC,CAAC;YAEH,MAAM,CAAC,IAAI,CAAC,EAAE,SAAS,EAAE,eAAe,EAAE,EAAE,oCAAoC,CAAC,CAAC;QACpF,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,KAAK,CAAC,EAAE,SAAS,EAAE,eAAe,EAAE,KAAK,EAAE,EAAE,+BAA+B,CAAC,CAAC;YACrF,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;IAKD,aAAa,CAAC,SAAiB;QAC7B,MAAM,OAAO,GAAG,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QACnD,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,MAAM,CAAC,IAAI,CAAC,EAAE,SAAS,EAAE,EAAE,+BAA+B,CAAC,CAAC;YAC5D,OAAO;QACT,CAAC;QAED,IAAI,CAAC;YACH,MAAM,CAAC,IAAI,CAAC,EAAE,SAAS,EAAE,EAAE,wBAAwB,CAAC,CAAC;YAGrD,OAAO,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC;YAG1B,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;YACtC,IAAI,CAAC,gBAAgB,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;YAC9C,IAAI,CAAC,gBAAgB,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC;YAEhD,MAAM,CAAC,IAAI,CAAC,EAAE,SAAS,EAAE,EAAE,uBAAuB,CAAC,CAAC;QACtD,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,KAAK,CAAC,EAAE,SAAS,EAAE,KAAK,EAAE,EAAE,8BAA8B,CAAC,CAAC;QACrE,CAAC;IACH,CAAC;IAKD,MAAM,CAAC,SAAiB,EAAE,IAAY,EAAE,IAAY;QAClD,MAAM,OAAO,GAAG,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QACnD,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,MAAM,CAAC,IAAI,CAAC,EAAE,SAAS,EAAE,EAAE,sCAAsC,CAAC,CAAC;YACnE,OAAO;QACT,CAAC;QAED,IAAI,CAAC;YAEH,MAAM,eAAe,GAAG,OAAO,CAAC,IAAI,KAAK,EAAE,IAAI,OAAO,CAAC,IAAI,KAAK,EAAE,CAAC;YAEnE,IAAI,IAAI,CAAC,eAAe,IAAI,CAAC,eAAe,EAAE,CAAC;gBAC7C,MAAM,CAAC,IAAI,CAAC,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,8CAA8C,CAAC,CAAC;gBACvF,OAAO;YACT,CAAC;YAED,IAAI,OAAO,CAAC,IAAI,KAAK,IAAI,IAAI,OAAO,CAAC,IAAI,KAAK,IAAI,EAAE,CAAC;gBACnD,MAAM,CAAC,KAAK,CAAC,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,wCAAwC,CAAC,CAAC;YACpF,CAAC;iBAAM,CAAC;gBACN,OAAO,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;gBACtC,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC;gBACpB,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC;gBACpB,MAAM,CAAC,IAAI,CAAC,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,eAAe,EAAE,EAAE,aAAa,CAAC,CAAC;YACpF,CAAC;QAKH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,KAAK,CAAC,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,oBAAoB,CAAC,CAAC;QACvE,CAAC;IACH,CAAC;IAKD,KAAK,CAAC,SAAiB,EAAE,IAAY;QACnC,MAAM,OAAO,GAAG,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QACnD,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,MAAM,CAAC,IAAI,CAAC,EAAE,SAAS,EAAE,EAAE,qCAAqC,CAAC,CAAC;YAClE,OAAO;QACT,CAAC;QAED,IAAI,CAAC;YACH,OAAO,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QACjC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,KAAK,CAAC,EAAE,SAAS,EAAE,KAAK,EAAE,EAAE,sBAAsB,CAAC,CAAC;QAC7D,CAAC;IACH,CAAC;IAKD,WAAW,CAAC,SAAiB;QAC3B,OAAO,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;IAC5C,CAAC;IAKD,qBAAqB;QACnB,OAAO,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC;IAClC,CAAC;IAKD,aAAa,CAAC,SAAiB;QAC7B,MAAM,OAAO,GAAG,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QACnD,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,OAAO,IAAI,CAAC;QACd,CAAC;QACD,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,CAAC,IAAI,EAAE,CAAC;IACpD,CAAC;CACF,CAAA;AAjPY,gCAAU;qBAAV,UAAU;IADtB,IAAA,mBAAU,GAAE;IAQR,WAAA,IAAA,eAAM,EAAC,IAAA,mBAAU,EAAC,GAAG,EAAE,CAAC,kCAAe,CAAC,CAAC,CAAA;IAEzC,WAAA,IAAA,eAAM,EAAC,IAAA,mBAAU,EAAC,GAAG,EAAE,CAAC,mDAAuB,CAAC,CAAC,CAAA;IAGjD,WAAA,IAAA,eAAM,EAAC,IAAA,mBAAU,EAAC,GAAG,EAAE,CAAC,0BAAW,CAAC,CAAC,CAAA;qCAJJ,kCAAe;QAEd,mDAAuB;QACvB,mDAAuB;QAE5B,0BAAW;QACP,kCAAe;GAdxC,UAAU,CAiPtB"}

package/dist/server/modules/terminal/services/terminal-emulator.service.d.ts

@@ -0,0 +1,40 @@
+import { OnModuleDestroy } from '@nestjs/common';
+import { SettingsService } from '../../settings/services/settings.service';
+export interface SnapshotOptions {
+    visibleOnly?: boolean;
+    withScrollback?: boolean;
+    maxBytes?: number;
+}
+export declare class TerminalEmulatorService implements OnModuleDestroy {
+    private readonly settingsService;
+    private readonly sessions;
+    private readonly logger;
+    private readonly DEFAULT_COLS;
+    private readonly DEFAULT_ROWS;
+    private readonly DEFAULT_SCROLLBACK;
+    private readonly MIN_SCROLLBACK;
+    private readonly MAX_SCROLLBACK;
+    private readonly scrollbackLines;
+    constructor(settingsService: SettingsService);
+    onModuleDestroy(): void;
+    initializeSession(sessionId: string): void;
+    getScrollbackLines(): number;
+    write(sessionId: string, data: string): void;
+    getDimensions(sessionId: string): {
+        cols: number;
+        rows: number;
+    };
+    resize(sessionId: string, cols: number, rows: number): void;
+    getSnapshotANSI(sessionId: string, options?: SnapshotOptions): string;
+    getSnapshotText(sessionId: string, options?: SnapshotOptions): string;
+    getHistoryText(sessionId: string, viewportRows: number, maxBytes?: number): string;
+    getHistoryANSI(sessionId: string, maxBytes?: number): string;
+    getTotalLines(sessionId: string): number;
+    getViewportStart(sessionId: string): number;
+    hasHistory(sessionId: string): boolean;
+    disposeSession(sessionId: string): void;
+    private getOrCreateSession;
+    private sanitizeDimension;
+    private resolveScrollbackSetting;
+    private applyMaxBytes;
+}

package/dist/server/modules/terminal/services/terminal-emulator.service.js

@@ -0,0 +1,356 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TerminalEmulatorService = void 0;
+const common_1 = require("@nestjs/common");
+const headless_1 = require("@xterm/headless");
+const logger_1 = require("../../../common/logging/logger");
+const settings_service_1 = require("../../settings/services/settings.service");
+let TerminalEmulatorService = class TerminalEmulatorService {
+    constructor(settingsService) {
+        this.settingsService = settingsService;
+        this.sessions = new Map();
+        this.logger = (0, logger_1.createLogger)('TerminalEmulatorService');
+        this.DEFAULT_COLS = 80;
+        this.DEFAULT_ROWS = 24;
+        this.DEFAULT_SCROLLBACK = 10000;
+        this.MIN_SCROLLBACK = 100;
+        this.MAX_SCROLLBACK = 50000;
+        this.scrollbackLines = this.resolveScrollbackSetting();
+        this.logger.info({ scrollback: this.scrollbackLines }, 'Terminal emulator service ready');
+    }
+    onModuleDestroy() {
+        for (const sessionId of this.sessions.keys()) {
+            this.disposeSession(sessionId);
+        }
+    }
+    initializeSession(sessionId) {
+        this.getOrCreateSession(sessionId);
+    }
+    getScrollbackLines() {
+        return this.scrollbackLines;
+    }
+    write(sessionId, data) {
+        const session = this.getOrCreateSession(sessionId);
+        try {
+            session.terminal.write(data);
+            if (Math.random() < 0.05) {
+                const normalBuffer = session.terminal.buffer.normal;
+                const activeBuffer = session.terminal.buffer.active;
+                this.logger.debug({
+                    sessionId,
+                    normalBufferLength: normalBuffer.length,
+                    activeBufferLength: activeBuffer.length,
+                    normalViewportY: normalBuffer.viewportY,
+                    activeViewportY: activeBuffer.viewportY,
+                    isInAltScreen: activeBuffer === session.terminal.buffer.alternate,
+                    scrollbackSetting: this.scrollbackLines,
+                    actualScrollback: session.terminal.options?.scrollback ??
+                        this.scrollbackLines,
+                    terminalRows: session.terminal.rows,
+                    terminalCols: session.terminal.cols,
+                    dataLength: data.length,
+                }, 'Emulator write - buffer state');
+            }
+        }
+        catch (error) {
+            this.logger.error({ sessionId, error }, 'Failed to write PTY chunk into emulator');
+        }
+    }
+    getDimensions(sessionId) {
+        const s = this.sessions.get(sessionId);
+        return { cols: s?.cols ?? this.DEFAULT_COLS, rows: s?.rows ?? this.DEFAULT_ROWS };
+    }
+    resize(sessionId, cols, rows) {
+        const session = this.getOrCreateSession(sessionId);
+        const safeCols = this.sanitizeDimension(cols, session.cols, this.DEFAULT_COLS);
+        const safeRows = this.sanitizeDimension(rows, session.rows, this.DEFAULT_ROWS);
+        if (safeCols === session.cols && safeRows === session.rows) {
+            return;
+        }
+        try {
+            session.terminal.resize(safeCols, safeRows);
+            session.cols = safeCols;
+            session.rows = safeRows;
+            this.logger.debug({ sessionId, cols: safeCols, rows: safeRows }, 'Emulator resized');
+        }
+        catch (error) {
+            this.logger.error({ sessionId, cols: safeCols, rows: safeRows, error }, 'Failed to resize emulator');
+        }
+    }
+    getSnapshotANSI(sessionId, options) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            this.logger.debug({ sessionId }, 'Requested ANSI snapshot for missing session');
+            return '';
+        }
+        const { visibleOnly, withScrollback, maxBytes } = options ?? {};
+        const isInAltScreen = session.terminal.buffer.active === session.terminal.buffer.alternate;
+        try {
+            if (isInAltScreen) {
+                this.logger.debug({ sessionId }, 'In alt-screen, manually extracting primary buffer');
+                const buffer = session.terminal.buffer.normal;
+                const scrollbackLines = visibleOnly || withScrollback === false ? 0 : this.scrollbackLines;
+                const start = 0;
+                const end = Math.min(buffer.length, scrollbackLines + session.rows);
+                const lines = [];
+                for (let y = start; y < end; y++) {
+                    const line = buffer.getLine(y);
+                    if (line) {
+                        lines.push(line.translateToString(true));
+                    }
+                }
+                const snapshot = lines.join('\r\n');
+                this.logger.debug({
+                    sessionId,
+                    lines: lines.length,
+                    bytes: Buffer.byteLength(snapshot, 'utf8'),
+                }, 'Manually extracted primary buffer (alt-screen mode)');
+                return this.applyMaxBytes(snapshot, maxBytes, sessionId, 'ansi');
+            }
+            const scrollback = visibleOnly || withScrollback === false ? 0 : this.scrollbackLines;
+            const serialized = session.serializeAddon.serialize({
+                scrollback,
+                excludeAltBuffer: true,
+                excludeModes: true,
+            });
+            if (!serialized) {
+                this.logger.warn({ sessionId }, 'Empty ANSI snapshot');
+                return '';
+            }
+            const applied = this.applyMaxBytes(serialized, maxBytes, sessionId, 'ansi');
+            this.logger.debug({
+                sessionId,
+                bytes: Buffer.byteLength(applied, 'utf8'),
+            }, 'Prepared ANSI snapshot');
+            return applied;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.logger.error({ sessionId, error: message }, 'Failed to serialize ANSI snapshot');
+            return '';
+        }
+    }
+    getSnapshotText(sessionId, options) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            this.logger.debug({ sessionId }, 'Requested text snapshot for missing session');
+            return '';
+        }
+        const buffer = session.terminal.buffer.active;
+        const includeScrollback = options?.visibleOnly === true ? false : (options?.withScrollback ?? true);
+        let start;
+        let end;
+        if (options?.visibleOnly) {
+            start = buffer.viewportY;
+            end = Math.min(buffer.length, start + session.rows);
+        }
+        else if (includeScrollback) {
+            start = 0;
+            end = buffer.length;
+        }
+        else {
+            end = buffer.length;
+            start = Math.max(0, end - session.rows);
+        }
+        const lines = [];
+        for (let y = start; y < end; y += 1) {
+            const line = buffer.getLine(y);
+            if (!line) {
+                continue;
+            }
+            lines.push(line.translateToString(true));
+        }
+        const snapshot = lines.join('\n');
+        return this.applyMaxBytes(snapshot, options?.maxBytes, sessionId, 'text');
+    }
+    getHistoryText(sessionId, viewportRows, maxBytes) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            this.logger.debug({ sessionId }, 'Requested history for missing session');
+            return '';
+        }
+        const buffer = session.terminal.buffer.active;
+        const viewportStart = buffer.viewportY;
+        const start = 0;
+        const end = viewportStart;
+        if (end <= start) {
+            this.logger.debug({ sessionId, viewportY: viewportStart, bufferLength: buffer.length }, 'No history before viewport');
+            return '';
+        }
+        const lines = [];
+        for (let y = start; y < end; y += 1) {
+            const line = buffer.getLine(y);
+            if (!line)
+                continue;
+            lines.push(line.translateToString(true));
+        }
+        this.logger.debug({ sessionId, historyLines: lines.length, viewportY: viewportStart }, 'Extracted history excluding viewport');
+        const snapshot = lines.join('\n');
+        return this.applyMaxBytes(snapshot, maxBytes, sessionId, 'text');
+    }
+    getHistoryANSI(sessionId, maxBytes) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            this.logger.debug({ sessionId }, 'Requested ANSI history for missing session');
+            return '';
+        }
+        const buffer = session.terminal.buffer.active;
+        const viewportStart = buffer.viewportY;
+        if (viewportStart <= 0) {
+            this.logger.debug({ sessionId, viewportY: viewportStart }, 'No history before viewport');
+            return '';
+        }
+        try {
+            const fullSnapshot = session.serializeAddon.serialize({
+                scrollback: this.scrollbackLines,
+                excludeAltBuffer: false,
+                excludeModes: true,
+            });
+            this.logger.debug({
+                sessionId,
+                viewportY: viewportStart,
+                snapshotBytes: fullSnapshot.length,
+            }, 'Prepared ANSI history');
+            return this.applyMaxBytes(fullSnapshot, maxBytes, sessionId, 'ansi');
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.logger.error({ sessionId, error: message }, 'Failed to serialize ANSI history');
+            return '';
+        }
+    }
+    getTotalLines(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            return 0;
+        return session.terminal.buffer.normal.length;
+    }
+    getViewportStart(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            return 0;
+        return session.terminal.buffer.normal.viewportY;
+    }
+    hasHistory(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            return false;
+        const buffer = session.terminal.buffer.normal;
+        const activeBuffer = session.terminal.buffer.active;
+        const isInAltScreen = activeBuffer === session.terminal.buffer.alternate;
+        const hasHistory = buffer.length > session.rows;
+        this.logger.debug({
+            sessionId,
+            normalBufferLength: buffer.length,
+            activeBufferLength: activeBuffer.length,
+            rows: session.rows,
+            isInAltScreen,
+            hasHistory,
+        }, 'Checking hasHistory');
+        return hasHistory;
+    }
+    disposeSession(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            return;
+        }
+        try {
+            session.serializeAddon.dispose();
+            session.terminal.dispose();
+        }
+        catch (error) {
+            this.logger.warn({ sessionId, error }, 'Failed to dispose emulator session cleanly');
+        }
+        finally {
+            this.sessions.delete(sessionId);
+        }
+    }
+    getOrCreateSession(sessionId) {
+        const existing = this.sessions.get(sessionId);
+        if (existing) {
+            return existing;
+        }
+        const terminal = new headless_1.Terminal({
+            allowProposedApi: true,
+            cols: this.DEFAULT_COLS,
+            rows: this.DEFAULT_ROWS,
+            scrollback: this.scrollbackLines,
+            convertEol: true,
+        });
+        const SerializeAddonModule = require('@xterm/addon-serialize');
+        const serializeAddon = new SerializeAddonModule.SerializeAddon();
+        terminal.loadAddon(serializeAddon);
+        const session = {
+            terminal,
+            serializeAddon,
+            cols: this.DEFAULT_COLS,
+            rows: this.DEFAULT_ROWS,
+        };
+        this.sessions.set(sessionId, session);
+        this.logger.info({
+            sessionId,
+            configuredScrollback: this.scrollbackLines,
+            terminalScrollback: terminal.options?.scrollback ??
+                this.scrollbackLines,
+            cols: terminal.cols,
+            rows: terminal.rows,
+        }, 'Created terminal emulator session');
+        return session;
+    }
+    sanitizeDimension(value, current, fallback) {
+        if (!Number.isFinite(value) || value <= 0) {
+            return current || fallback;
+        }
+        const coerced = Math.floor(value);
+        return coerced > 0 ? coerced : current || fallback;
+    }
+    resolveScrollbackSetting() {
+        try {
+            const stored = this.settingsService.getSetting('terminal.scrollback.lines');
+            if (!stored) {
+                return this.DEFAULT_SCROLLBACK;
+            }
+            const parsed = Number(stored);
+            if (!Number.isFinite(parsed)) {
+                this.logger.warn({ stored }, 'Invalid scrollback setting, using default');
+                return this.DEFAULT_SCROLLBACK;
+            }
+            const clamped = Math.max(this.MIN_SCROLLBACK, Math.min(parsed, this.MAX_SCROLLBACK));
+            if (clamped !== parsed) {
+                this.logger.warn({ parsed, clamped }, 'Clamped scrollback setting to safe range');
+            }
+            return clamped;
+        }
+        catch (error) {
+            this.logger.warn({ error }, 'Failed to read scrollback setting, using default');
+            return this.DEFAULT_SCROLLBACK;
+        }
+    }
+    applyMaxBytes(data, maxBytes, sessionId, kind) {
+        if (!maxBytes || maxBytes <= 0) {
+            return data;
+        }
+        const byteLength = Buffer.byteLength(data, 'utf8');
+        if (byteLength <= maxBytes) {
+            return data;
+        }
+        const truncated = Buffer.from(data, 'utf8').subarray(Math.max(0, byteLength - maxBytes));
+        this.logger.warn({ sessionId, kind, byteLength, maxBytes }, 'Snapshot truncated due to maxBytes limit');
+        return truncated.toString('utf8');
+    }
+};
+exports.TerminalEmulatorService = TerminalEmulatorService;
+exports.TerminalEmulatorService = TerminalEmulatorService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [settings_service_1.SettingsService])
+], TerminalEmulatorService);
+//# sourceMappingURL=terminal-emulator.service.js.map