glad-web 1.0.45 → 2.0.1

package/lib/session/file-attachment-store.js

@@ -1,168 +0,0 @@
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-const { v4: uuidv4 } = require('uuid');
-
-const MAX_BYTES = 50 * 1024 * 1024;
-const MAX_PER_SESSION = 8;
-const MAX_CHUNKS = 128;
-const CLEANUP_DELAY_MS = 30 * 60 * 1000;
-
-function inputError(message, statusCode = 400) {
-  const error = new Error(message);
-  error.statusCode = statusCode;
-  return error;
-}
-
-function safeUploadId(value) {
-  return typeof value === 'string' && /^[a-zA-Z0-9-]{8,100}$/.test(value);
-}
-
-function safeFileName(value) {
-  let decoded = String(value || 'attachment.bin');
-  try { decoded = decodeURIComponent(decoded); } catch (_) {}
-  const base = decoded.replace(/\\/g, '/').split('/').pop() || 'attachment.bin';
-  const cleaned = base.replace(/[\u0000-\u001f\u007f<>:"|?*]/g, '_').trim().slice(0, 160);
-  return cleaned || 'attachment.bin';
-}
-
-class FileAttachmentStore {
-  constructor({ logger, root, uploadRoot } = {}) {
-    this.logger = logger || console;
-    this.root = root || path.join(os.tmpdir(), 'glad', 'session-files');
-    this.uploadRoot = uploadRoot || path.join(os.tmpdir(), 'glad', 'session-file-uploads');
-  }
-
-  assertSession(session) {
-    if (!session) throw inputError('Session not found', 404);
-    if (!session.fileAttachments || !session.fileUploads) throw inputError('File attachments are unavailable for this session');
-  }
-
-  async appendChunk(session, input = {}, bytes) {
-    this.assertSession(session);
-    if (!Buffer.isBuffer(bytes) || bytes.length === 0) throw inputError('File chunk is required');
-    const uploadId = String(input.uploadId || '');
-    const chunkIndex = Number(input.chunkIndex);
-    const chunkTotal = Number(input.chunkTotal);
-    const name = safeFileName(input.name);
-    if (!safeUploadId(uploadId)) throw inputError('Invalid file upload id');
-    if (!Number.isInteger(chunkIndex) || !Number.isInteger(chunkTotal) || chunkIndex < 0 || chunkTotal < 1 || chunkTotal > MAX_CHUNKS || chunkIndex >= chunkTotal) {
-      throw inputError('Invalid file chunk metadata');
-    }
-
-    let upload = session.fileUploads.get(uploadId);
-    if (!upload) {
-      if (chunkIndex !== 0) throw inputError('File upload must start with the first chunk');
-      const directory = path.join(this.uploadRoot, session.id);
-      await fs.promises.mkdir(directory, { recursive: true, mode: 0o700 });
-      upload = { id: uploadId, name, path: path.join(directory, `${uploadId}.part`), chunkTotal, nextChunkIndex: 0, bytes: 0 };
-      session.fileUploads.set(uploadId, upload);
-    }
-    if (upload.name !== name || upload.chunkTotal !== chunkTotal || upload.nextChunkIndex !== chunkIndex) {
-      throw inputError('File chunks arrived out of order');
-    }
-    if (upload.bytes + bytes.length > MAX_BYTES) {
-      await this.discardUpload(session, uploadId);
-      throw inputError('File must be 50 MB or smaller');
-    }
-
-    if (chunkIndex === 0) await fs.promises.writeFile(upload.path, bytes, { mode: 0o600, flag: 'wx' });
-    else await fs.promises.appendFile(upload.path, bytes, { mode: 0o600 });
-    upload.bytes += bytes.length;
-    upload.nextChunkIndex += 1;
-    if (upload.nextChunkIndex < upload.chunkTotal) {
-      return { complete: false, receivedChunks: upload.nextChunkIndex, size: upload.bytes };
-    }
-
-    const pendingAttachmentCount = Array.from(session.fileAttachments.values()).filter(item => !item.sent).length;
-    if (pendingAttachmentCount >= MAX_PER_SESSION) {
-      await this.discardUpload(session, uploadId);
-      throw inputError(`You can attach at most ${MAX_PER_SESSION} files at a time`);
-    }
-    const directory = path.join(this.root, session.id);
-    await fs.promises.mkdir(directory, { recursive: true, mode: 0o700 });
-    const attachment = {
-      id: uuidv4(),
-      name: upload.name,
-      path: path.join(directory, `${uuidv4()}-${upload.name}`),
-      size: upload.bytes,
-      createdAt: Date.now(),
-      cleanupTimer: null
-    };
-    session.fileUploads.delete(uploadId);
-    try {
-      await fs.promises.rename(upload.path, attachment.path);
-      await fs.promises.chmod(attachment.path, 0o600);
-      session.fileAttachments.set(attachment.id, attachment);
-      return { complete: true, attachment: { id: attachment.id, name: attachment.name, size: attachment.size, kind: 'file' } };
-    } catch (error) {
-      await fs.promises.rm(upload.path, { force: true });
-      throw error;
-    }
-  }
-
-  async discardUpload(session, uploadId) {
-    if (!session?.fileUploads || !safeUploadId(uploadId)) return false;
-    const upload = session.fileUploads.get(uploadId);
-    if (!upload) return false;
-    session.fileUploads.delete(uploadId);
-    await fs.promises.rm(upload.path, { force: true });
-    return true;
-  }
-
-  async discardAttachment(session, attachmentId) {
-    if (!session?.fileAttachments) return false;
-    const attachment = session.fileAttachments.get(attachmentId);
-    if (!attachment) return false;
-    clearTimeout(attachment.cleanupTimer);
-    session.fileAttachments.delete(attachmentId);
-    await fs.promises.rm(attachment.path, { force: true });
-    return true;
-  }
-
-  resolve(session, attachmentIds = []) {
-    const ids = Array.isArray(attachmentIds) ? attachmentIds : [];
-    if (!session) throw inputError('Session not found', 404);
-    if (ids.length === 0) return [];
-    this.assertSession(session);
-    if (ids.length > MAX_PER_SESSION) throw inputError(`You can attach at most ${MAX_PER_SESSION} files at a time`);
-    const uniqueIds = [...new Set(ids.map(String))];
-    if (uniqueIds.length !== ids.length) throw inputError('Duplicate file attachment');
-    return uniqueIds.map(attachmentId => {
-      const attachment = session.fileAttachments.get(attachmentId);
-      if (!attachment) throw inputError('File attachment is no longer available');
-      return attachment;
-    });
-  }
-
-  scheduleCleanup(session, attachmentIds) {
-    if (!session?.fileAttachments) return;
-    for (const attachmentId of attachmentIds) {
-      const attachment = session.fileAttachments.get(attachmentId);
-      if (!attachment) continue;
-      attachment.sent = true;
-      clearTimeout(attachment.cleanupTimer);
-      attachment.cleanupTimer = setTimeout(() => {
-        this.discardAttachment(session, attachmentId).catch(error => {
-          this.logger.debugInfo?.(`[file-attachment] cleanup failed: ${error.message}`);
-        });
-      }, CLEANUP_DELAY_MS);
-      attachment.cleanupTimer.unref?.();
-    }
-  }
-
-  clear(session) {
-    if (!session) return;
-    for (const attachment of session.fileAttachments?.values?.() || []) clearTimeout(attachment.cleanupTimer);
-    session.fileAttachments?.clear?.();
-    session.fileUploads?.clear?.();
-    fs.promises.rm(path.join(this.root, session.id), { recursive: true, force: true }).catch(error => {
-      this.logger.debugInfo?.(`[file-attachment] cleanup failed: ${error.message}`);
-    });
-    fs.promises.rm(path.join(this.uploadRoot, session.id), { recursive: true, force: true }).catch(error => {
-      this.logger.debugInfo?.(`[file-upload] cleanup failed: ${error.message}`);
-    });
-  }
-}
-
-module.exports = FileAttachmentStore;

package/lib/session/pty-manager.js

@@ -1,255 +0,0 @@
-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 = ['antigravity', '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);
-    }
-  }
-
-  redraw(cols, rows) {
-    if (!this.ptyProcess) return false;
-
-    const targetCols = Math.max(2, Number.parseInt(cols, 10) || 80);
-    const targetRows = Math.max(1, Number.parseInt(rows, 10) || 24);
-    const pulseCols = targetCols > 2 ? targetCols - 1 : targetCols + 1;
-
-    this.ptyProcess.resize(pulseCols, targetRows);
-    setTimeout(() => {
-      if (this.ptyProcess) this.ptyProcess.resize(targetCols, targetRows);
-    }, 30);
-    return true;
-  }
-
-  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

@@ -1,225 +0,0 @@
-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;