glad-web 1.0.7

package/lib/session/pty-manager.js

@@ -0,0 +1,241 @@
+const pty = require('node-pty');
+const os = require('os');
+const crypto = require('crypto');
+const logger = require('../utils/logger');
+
+function previewText(text, maxChars = 500) {
+  const normalized = String(text || '')
+    .replace(/\r/g, '\\r')
+    .replace(/\n/g, '\\n')
+    .replace(/\t/g, '\\t')
+    .replace(/\x1b/g, '\\x1b');
+  return normalized.length > maxChars ? normalized.slice(0, maxChars) + '...' : normalized;
+}
+
+class PTYManager {
+  constructor(tool, workingDir, buffer, options = {}) {
+    this.tool = tool;
+    this.workingDir = workingDir;
+    this.buffer = buffer;
+    this.silent = options.silent || false;
+    this.ptyProcess = null;
+    this.onDataCallback = null;
+    this.onExitCallback = null;
+    this.localResizeListener = null;
+
+    this.tuiTools = ['opencode', 'kilo'];
+    this.isTUIMode = this.tuiTools.includes(tool.key);
+
+    this.recentOutputs = []; 
+    this.duplicateThresholdMs = 150; 
+    this.maxRecentOutputs = 10; 
+    this.debugOutputCount = 0;
+  }
+
+  // Start PTY process
+  start(additionalArgs = []) {
+    const isWindows = os.platform() === 'win32';
+    const args = [...this.tool.args, ...additionalArgs];
+
+    logger.info(`Starting ${this.tool.displayName}...`);
+    
+    try {
+      if (!this.silent) {
+        process.stdout.write('\x1b[?2004l');
+      }
+
+      let spawnCommand = this.tool.command;
+      let spawnArgs = args;
+
+      if (isWindows) {
+        spawnCommand = 'cmd.exe';
+        spawnArgs = ['/c', this.tool.command, ...args];
+      } else {
+        spawnCommand = 'bash';
+        const escaped = [this.tool.command, ...args]
+          .map(a => `'${String(a).replace(/'/g, "'\\''")}'`)
+          .join(' ');
+        spawnArgs = ['-i', '-c', escaped];
+      }
+
+      let spawnEnv = {
+        ...process.env,
+        TERM: 'xterm-256color',
+        COLORTERM: 'truecolor',
+        FORCE_COLOR: '1',
+        CLICOLOR: '1'
+      };
+      delete spawnEnv.NO_COLOR;
+      delete spawnEnv.STY;
+      delete spawnEnv.WINDOW;
+      delete spawnEnv.TERMCAP;
+
+      if (isWindows) {
+        const path = require('path');
+        const npmGlobalBin = path.join(process.env.APPDATA || '', 'npm');
+        const currentPath = process.env.PATH || '';
+
+        spawnEnv = {
+          ...spawnEnv,
+          PATH: `${npmGlobalBin};${currentPath}`
+        };
+      }
+
+      logger.debugInfo(`[pty-start] tool=${this.tool.key}; displayName=${this.tool.displayName}; command=${spawnCommand}; args=${JSON.stringify(spawnArgs)}; cwd=${this.workingDir}`);
+      logger.debugInfo(`[pty-start] PATH=${spawnEnv.PATH || ''}; SHELL=${spawnEnv.SHELL || ''}; TERM=${spawnEnv.TERM || ''}; HOME=${spawnEnv.HOME || ''}`);
+
+      this.ptyProcess = pty.spawn(spawnCommand, spawnArgs, {
+        name: 'xterm-256color',
+        cols: this.silent ? 80 : (process.stdout.columns || 80),
+        rows: this.silent ? 24 : (process.stdout.rows || 24),
+        cwd: this.workingDir,
+        env: spawnEnv
+      });
+
+      logger.success(`${this.tool.displayName} started (PID: ${this.ptyProcess.pid})`);
+
+      this.ptyProcess.onData((data) => {
+        this.handlePTYOutput(data);
+      });
+
+      this.ptyProcess.onExit((exitCode) => {
+        this.handlePTYExit(exitCode);
+      });
+
+      if (!this.silent && process.stdin.isTTY) {
+        process.stdin.setRawMode(true);
+        process.stdin.setEncoding('utf8');
+        process.stdin.resume(); 
+
+        process.stdin.on('data', (data) => {
+          const filtered = data.toString()
+            .replace(/\x1b\[I/g, '') 
+            .replace(/\x1b\[O/g, ''); 
+
+          if (filtered.length > 0) {
+            this.ptyProcess.write(filtered);
+          }
+
+          if (data === '\u0003') { 
+            this.kill();
+            process.exit(0);
+          }
+        });
+      }
+
+      if (!this.silent) {
+        this.setupLocalResizeListener();
+      }
+
+      return true;
+    } catch (err) {
+      logger.error(`Failed to start ${this.tool.displayName}: ${err.message}`);
+      return false;
+    }
+  }
+
+  // Handle PTY output
+  handlePTYOutput(data) {
+    let filtered = data
+      .replace(/\x1b\[I/g, '') 
+      .replace(/\x1b\[O/g, ''); 
+
+    if (filtered.length > 0) {
+      if (this.debugOutputCount < 12) {
+        this.debugOutputCount += 1;
+        logger.debugInfo(`[pty-output] tool=${this.tool.key}; chunk=${this.debugOutputCount}; bytes=${Buffer.byteLength(filtered, 'utf8')}; preview="${previewText(filtered)}"`);
+      }
+
+      if (os.platform() === 'win32') {
+        const now = Date.now();
+        const hash = crypto.createHash('sha256').update(filtered).digest('hex');
+        this.recentOutputs = this.recentOutputs.filter(entry => now - entry.timestamp < this.duplicateThresholdMs);
+        const duplicate = this.recentOutputs.find(entry => entry.hash === hash);
+        if (duplicate) return;
+        this.recentOutputs.push({ hash, timestamp: now });
+        if (this.recentOutputs.length > this.maxRecentOutputs) this.recentOutputs.shift();
+      }
+
+      if (!this.silent) {
+        process.stdout.write(filtered);
+      }
+
+      let forMobile = filtered;
+      if (os.platform() === 'win32' && forMobile.startsWith('\x1b[H\x1b[K')) {
+        forMobile = '\x1b[2J\x1b[3J\x1b[H' + forMobile.slice(6);
+      }
+
+      if (!this.isTUIMode) {
+        this.buffer.append(forMobile);
+      }
+
+      if (this.onDataCallback) {
+        this.onDataCallback(forMobile);
+      }
+    }
+  }
+
+  handlePTYExit(exitCode) {
+    logger.info(`${this.tool.displayName} exited with code ${exitCode.exitCode}`);
+    logger.debugInfo(`[pty-exit] tool=${this.tool.key}; exitCode=${exitCode.exitCode}; signal=${exitCode.signal || ''}`);
+    if (this.onExitCallback) {
+      this.onExitCallback(exitCode);
+    }
+  }
+
+  write(data) {
+    if (this.ptyProcess) {
+      this.ptyProcess.write(data);
+      return true;
+    }
+    return false;
+  }
+
+  resize(cols, rows) {
+    if (this.ptyProcess) {
+      this.ptyProcess.resize(cols, rows);
+    }
+  }
+
+  setupLocalResizeListener() {
+    if (!process.stdout.isTTY) return;
+    this.localResizeListener = () => {
+      const cols = process.stdout.columns || 80;
+      const rows = process.stdout.rows || 24;
+      this.resize(cols, rows);
+    };
+    process.stdout.on('resize', this.localResizeListener);
+  }
+
+  onData(callback) {
+    this.onDataCallback = callback;
+  }
+
+  onExit(callback) {
+    this.onExitCallback = callback;
+  }
+
+  kill() {
+    if (this.ptyProcess) {
+      this.ptyProcess.kill();
+      this.ptyProcess = null;
+    }
+    if (this.localResizeListener && process.stdout.off) {
+      process.stdout.off('resize', this.localResizeListener);
+      this.localResizeListener = null;
+    }
+    if (!this.silent && process.stdin.isTTY && process.stdin.setRawMode) {
+      process.stdin.setRawMode(false);
+    }
+  }
+
+  isRunning() {
+    return this.ptyProcess !== null;
+  }
+
+  getPid() {
+    return this.ptyProcess ? this.ptyProcess.pid : null;
+  }
+}
+
+module.exports = PTYManager;

package/lib/session/rendered-history.js

@@ -0,0 +1,225 @@
+let TerminalCtor = null;
+
+function getTerminalCtor() {
+  if (TerminalCtor) return TerminalCtor;
+  if (typeof global.window === 'undefined') {
+    global.window = {};
+  }
+  ({ Terminal: TerminalCtor } = require('xterm-headless'));
+  return TerminalCtor;
+}
+
+class RenderedHistory {
+  constructor(options = {}) {
+    const Terminal = getTerminalCtor();
+
+    this.maxBytes = options.maxBytes || 5 * 1024 * 1024;
+    this.debugLabel = options.debugLabel || 'session';
+    this.cols = Math.max(2, options.cols || 80);
+    this.rows = Math.max(1, options.rows || 24);
+    this.minCols = Math.max(2, options.minCols || 20);
+    this.minRows = Math.max(1, options.minRows || 8);
+    this.updatedAt = Date.now();
+    this.totalWrites = 0;
+    this.totalBytes = 0;
+    this.pendingWrites = 0;
+    this.resizeEvents = 0;
+    this.truncated = false;
+    this.lastEvents = [];
+    this.archivedLines = [];
+    this.archivedBytes = 0;
+    this.term = new Terminal({
+      cols: this.cols,
+      rows: this.rows,
+      scrollback: Math.max(20000, options.scrollback || 20000),
+      allowProposedApi: true
+    });
+    this.hookBufferTrim();
+  }
+
+  write(data) {
+    if (!this.term) return;
+    if (!data) return;
+    const text = String(data);
+    this.totalWrites += 1;
+    this.totalBytes += Buffer.byteLength(text, 'utf8');
+    this.pendingWrites += 1;
+    this.updatedAt = Date.now();
+
+    this.term.write(text, () => {
+      this.pendingWrites = Math.max(0, this.pendingWrites - 1);
+      this.updatedAt = Date.now();
+    });
+  }
+
+  resize(cols, rows) {
+    if (!this.term) return;
+    const rawCols = Number.parseInt(cols, 10);
+    const rawRows = Number.parseInt(rows, 10);
+    const nextCols = Math.max(2, rawCols || this.cols);
+    const nextRows = Math.max(1, rawRows || this.rows);
+
+    // Hidden or unstable layouts can briefly report pathological sizes like 10x6.
+    // Ignore those for rendered history so we don't reflow the whole buffer into noise.
+    if (nextCols < this.minCols || nextRows < this.minRows) {
+      this.recordEvent(`resize ignored ${nextCols}x${nextRows}`);
+      return;
+    }
+
+    if (nextCols === this.cols && nextRows === this.rows) return;
+
+    this.cols = nextCols;
+    this.rows = nextRows;
+    this.resizeEvents += 1;
+    this.updatedAt = Date.now();
+    this.recordEvent(`resize ${this.cols}x${this.rows}`);
+    this.term.resize(this.cols, this.rows);
+  }
+
+  toJSON() {
+    const snapshot = this.buildSnapshot();
+    return {
+      text: snapshot.text,
+      updatedAt: this.updatedAt,
+      truncated: snapshot.truncated,
+      bytes: snapshot.bytes,
+      lines: snapshot.lines.length
+    };
+  }
+
+  getDebugSnapshot(options = {}) {
+    const tailLines = options.tailLines || 12;
+    const snapshot = this.buildSnapshot();
+    const active = this.term.buffer.active;
+    return {
+      label: this.debugLabel,
+      updatedAt: this.updatedAt,
+      truncated: snapshot.truncated,
+      cols: this.cols,
+      rows: this.rows,
+      totalWrites: this.totalWrites,
+      totalBytes: this.totalBytes,
+      pendingWrites: this.pendingWrites,
+      resizeEvents: this.resizeEvents,
+      bufferLines: active.length,
+      baseY: active.baseY,
+      cursorY: active.cursorY,
+      cursorX: active.cursorX,
+      lastEvents: [...this.lastEvents],
+      tailPreview: this.previewText(snapshot.lines.slice(-tailLines).join('\n'))
+    };
+  }
+
+  dispose() {
+    if (this.term) {
+      this.term.dispose();
+      this.term = null;
+    }
+  }
+
+  hookBufferTrim() {
+    const lines = this.term && this.term._core && this.term._core.buffer && this.term._core.buffer.lines;
+    if (!lines || typeof lines.trimStart !== 'function') return;
+
+    const originalPush = lines.push.bind(lines);
+    lines.push = (value) => {
+      if (lines.isFull) {
+        const line = lines.get(0);
+        this.archiveLines([line ? line.translateToString(true) : '']);
+      }
+      return originalPush(value);
+    };
+
+    if (typeof lines.recycle === 'function') {
+      const originalRecycle = lines.recycle.bind(lines);
+      lines.recycle = () => {
+        if (lines.isFull) {
+          const line = lines.get(0);
+          this.archiveLines([line ? line.translateToString(true) : '']);
+        }
+        return originalRecycle();
+      };
+    }
+
+    const originalTrimStart = lines.trimStart.bind(lines);
+    lines.trimStart = (amount) => {
+      const removed = [];
+      for (let i = 0; i < amount; i++) {
+        const line = lines.get(i);
+        removed.push(line ? line.translateToString(true) : '');
+      }
+      this.archiveLines(removed);
+      return originalTrimStart(amount);
+    };
+  }
+
+  archiveLines(lines) {
+    if (!lines || lines.length === 0) return;
+    for (const line of lines) {
+      this.archivedLines.push(line);
+      this.archivedBytes += Buffer.byteLength(line, 'utf8') + 1;
+    }
+    this.trimArchivedBytes();
+  }
+
+  buildSnapshot() {
+    const active = this.term.buffer.active;
+    let lines = [...this.archivedLines];
+
+    for (let i = 0; i < active.length; i++) {
+      const line = active.getLine(i);
+      lines.push(line ? line.translateToString(true) : '');
+    }
+
+    let truncated = false;
+
+    let bytes = Buffer.byteLength(lines.join('\n'), 'utf8');
+    while (bytes > this.maxBytes && lines.length > 1) {
+      const removed = lines.shift();
+      bytes -= Buffer.byteLength(removed, 'utf8') + 1;
+      truncated = true;
+    }
+
+    if (bytes > this.maxBytes && lines.length === 1) {
+      const line = lines[0];
+      const keepChars = Math.max(1, Math.floor(this.maxBytes / 2));
+      lines[0] = line.slice(-keepChars);
+      bytes = Buffer.byteLength(lines[0], 'utf8');
+      truncated = true;
+    }
+
+    const text = lines.join('\n').replace(/\s+$/g, '');
+    this.truncated = truncated;
+    return {
+      lines,
+      text,
+      bytes: Buffer.byteLength(text, 'utf8'),
+      truncated
+    };
+  }
+
+  recordEvent(message) {
+    this.lastEvents.push(`${new Date().toISOString()} ${message}`);
+    if (this.lastEvents.length > 25) this.lastEvents.shift();
+  }
+
+  trimArchivedBytes() {
+    while (this.archivedBytes > this.maxBytes && this.archivedLines.length > 0) {
+      const removed = this.archivedLines.shift();
+      this.archivedBytes -= Buffer.byteLength(removed, 'utf8') + 1;
+      this.truncated = true;
+    }
+  }
+
+  previewText(text, maxChars = 400) {
+    if (!text) return '';
+    const normalized = String(text)
+      .replace(/\r/g, '\\r')
+      .replace(/\n/g, '\\n')
+      .replace(/\t/g, '\\t')
+      .replace(/\x1b/g, '\\x1b');
+    return normalized.length > maxChars ? normalized.slice(-maxChars) : normalized;
+  }
+}
+
+module.exports = RenderedHistory;