glad-web 1.0.7

package/lib/session/session-manager.js

@@ -0,0 +1,382 @@
+const { EventEmitter } = require('events');
+const path = require('path');
+const fs = require('fs');
+const { v4: uuidv4 } = require('uuid');
+const PTYManager = require('./pty-manager');
+const TextHistory = require('./text-history');
+const RenderedHistory = require('./rendered-history');
+const CircularBuffer = require('./buffer');
+const { getToolByKey } = require('../ai-tools/registry');
+
+function previewText(text, maxChars = 320) {
+  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;
+}
+
+class SessionManager extends EventEmitter {
+  constructor({ baseDir, renderHistoryTools, debugHistoryEnabled = false, logger, hasConnectedSessionClient } = {}) {
+    super();
+    this.baseDir = baseDir || process.cwd();
+    this.renderHistoryTools = renderHistoryTools || new Set();
+    this.debugHistoryEnabled = debugHistoryEnabled;
+    this.logger = logger || console;
+    this.hasConnectedSessionClient = hasConnectedSessionClient || (() => false);
+    this.sessions = new Map();
+  }
+
+  list() {
+    return Array.from(this.sessions.entries()).map(([id, session]) => ({
+      id,
+      name: session.name,
+      tool: session.tool.displayName,
+      startTime: session.startTime,
+      toolKey: session.tool.key,
+      workingDirectory: session.ptyManager.workingDir,
+      hasUnreadCompletion: Boolean(session.hasUnreadCompletion)
+    }));
+  }
+
+  get(id) {
+    return this.sessions.get(id) || null;
+  }
+
+  has(id) {
+    return this.sessions.has(id);
+  }
+
+  create({ toolKey, workingDirectory, name }) {
+    this.logger.info(`Creating session: toolKey=${toolKey || ''}, workingDirectory=${workingDirectory || '(default)'}`);
+    const tool = getToolByKey(toolKey);
+    if (!tool) {
+      const err = new Error('Invalid tool');
+      err.statusCode = 400;
+      this.logger.error(`Create session failed: invalid toolKey=${toolKey || ''}`);
+      throw err;
+    }
+
+    const id = uuidv4();
+    const buffer = new CircularBuffer(500000);
+    const textHistory = new TextHistory({ maxBytes: 20 * 1024 * 1024, debugLabel: id });
+    const historyMode = this.getHistoryModeForTool(tool.key);
+    const renderedHistory = historyMode === 'rendered'
+      ? new RenderedHistory({ maxBytes: 20 * 1024 * 1024, debugLabel: id, cols: 80, rows: 24 })
+      : null;
+
+    const sessionDir = workingDirectory && String(workingDirectory).trim()
+      ? path.resolve(this.baseDir, String(workingDirectory).trim())
+      : this.baseDir;
+
+    if (!fs.existsSync(sessionDir)) {
+      const err = new Error(`Directory does not exist: ${sessionDir}`);
+      err.statusCode = 400;
+      this.logger.error(`Create session failed: missing directory ${sessionDir}`);
+      throw err;
+    }
+
+    this.logger.info(`Resolved session directory: ${sessionDir}`);
+
+    const ptyManager = new PTYManager(tool, sessionDir, buffer, { silent: true });
+    const session = {
+      id,
+      name: name || tool.displayName,
+      ptyManager,
+      buffer,
+      textHistory,
+      renderedHistory,
+      historyMode,
+      tool,
+      startTime: Date.now(),
+      isThinking: false,
+      completionTimer: null,
+      awaitingCompletion: false,
+      inputSeq: 0,
+      completionReadInputSeq: 0,
+      resizeOwner: null,
+      hasUnreadCompletion: false,
+      write: data => this.write(id, data),
+      isRunning: () => this.has(id) && ptyManager.isRunning(),
+      kill: () => this.kill(id)
+    };
+
+    this.sessions.set(id, session);
+    this.logSessionDiagnostics('session-created', session, {}, { compact: true });
+
+    ptyManager.onData((data) => this.handleOutput(session, data));
+    ptyManager.onExit(() => this.handleExit(session));
+
+    const started = ptyManager.start([]);
+    if (!started) {
+      const err = new Error(`Failed to start ${tool.displayName}`);
+      err.statusCode = 500;
+      this.sessions.delete(id);
+      throw err;
+    }
+
+    return session;
+  }
+
+  write(id, data) {
+    const session = this.get(id);
+    if (!session) return false;
+    this.markSessionInput(session, data);
+    return session.ptyManager.write(data);
+  }
+
+  resize(id, cols, rows) {
+    const session = this.get(id);
+    if (!session) return false;
+    if (session.renderedHistory) {
+      session.renderedHistory.resize(cols, rows);
+    }
+    session.ptyManager.resize(cols, rows);
+    return true;
+  }
+
+  rename(id, name) {
+    const session = this.get(id);
+    if (!session || !name) return null;
+    session.name = name;
+    this.logSessionDiagnostics('session-renamed', session, {}, { compact: true });
+    return session;
+  }
+
+  markCompletionRead(id) {
+    const session = this.get(id);
+    if (!session) return null;
+    session.hasUnreadCompletion = false;
+    session.awaitingCompletion = false;
+    session.isThinking = false;
+    session.completionReadInputSeq = session.inputSeq || 0;
+    clearTimeout(session.completionTimer);
+    this.logSessionDiagnostics('completion-read', session, {}, { compact: true });
+    return session;
+  }
+
+  kill(id) {
+    const session = this.get(id);
+    if (!session) return false;
+    clearTimeout(session.completionTimer);
+    this.logSessionDiagnostics('session-deleted', session, {}, { compact: true });
+    this.disposeSessionHistory(session);
+    session.ptyManager.kill();
+    this.sessions.delete(id);
+    this.emit('exit', { sessionId: id, session });
+    return true;
+  }
+
+  killAll() {
+    for (const session of this.sessions.values()) {
+      clearTimeout(session.completionTimer);
+      this.disposeSessionHistory(session);
+      session.ptyManager.kill();
+    }
+    this.sessions.clear();
+  }
+
+  getHistory(id) {
+    const session = this.get(id);
+    if (!session) return null;
+    const historySource = session.renderedHistory || session.textHistory;
+    return {
+      success: true,
+      sessionId: session.id,
+      sessionName: session.name,
+      tool: session.tool.displayName,
+      historyMode: session.historyMode,
+      ...historySource.toJSON()
+    };
+  }
+
+  getDiagnostics(id) {
+    const session = this.get(id);
+    return session ? this.getSessionDiagnostics(session) : null;
+  }
+
+  logHistoryRequest(id, req) {
+    const session = this.get(id);
+    if (!session) return;
+    this.logSessionDiagnostics('history-request', session, {
+      userAgent: req.headers['user-agent'] || '',
+      acceptEncoding: req.headers['accept-encoding'] || ''
+    }, { compact: true });
+  }
+
+  logClientDebug(sessionId, event, payload) {
+    const session = sessionId ? this.get(sessionId) : null;
+    this.logger.debugInfo(`[client-debug] ${JSON.stringify({
+      sessionId: sessionId || null,
+      event: event || 'unknown',
+      payload: payload || null,
+      serverSide: session ? this.getSessionDiagnostics(session) : null
+    })}`);
+  }
+
+  logWsConnected(id, req) {
+    const session = this.get(id);
+    if (!session) return;
+    this.logSessionDiagnostics('ws-connected', session, {
+      remoteAddress: req.socket.remoteAddress || null,
+      userAgent: req.headers['user-agent'] || ''
+    }, { compact: true });
+  }
+
+  logWsCatchup(id, history) {
+    const session = this.get(id);
+    if (!session) return;
+    this.logSessionDiagnostics('ws-catchup', session, {
+      catchupItems: history.length,
+      catchupPreview: previewText(history.map(message => message.data).join(''))
+    }, { compact: true });
+  }
+
+  logWsResize(id, cols, rows) {
+    const session = this.get(id);
+    if (!session) return;
+    this.logSessionDiagnostics('ws-resize', session, { cols, rows }, { compact: true });
+  }
+
+  logWsClosed(id) {
+    const session = this.get(id);
+    if (!session) return;
+    this.logSessionDiagnostics('ws-closed', session, {}, { compact: true });
+  }
+
+  getHistoryModeForTool(toolKey) {
+    return this.renderHistoryTools.has(String(toolKey || '').toLowerCase()) ? 'rendered' : 'transcript';
+  }
+
+  handleOutput(session, data) {
+    session.textHistory.write(data);
+    if (session.renderedHistory) {
+      session.renderedHistory.write(data);
+    }
+    this.logSessionDiagnostics('pty-output', session, {
+      chunkBytes: Buffer.byteLength(String(data), 'utf8'),
+      chunkPreview: previewText(data),
+      containsClear: /\x1b\[[0-9;?]*J/.test(data),
+      containsCursorMove: /\x1b\[[0-9;?]*(?:[ABCDGHf])/.test(data)
+    }, { compact: true });
+
+    if (session.awaitingCompletion && !session.isThinking && data.trim().length > 0) session.isThinking = true;
+    if (session.awaitingCompletion && session.isThinking) {
+      clearTimeout(session.completionTimer);
+      const watchedInputSeq = session.inputSeq || 0;
+      session.completionTimer = setTimeout(() => {
+        const hasUnreadInput = watchedInputSeq > (session.completionReadInputSeq || 0);
+        const isCurrentInput = watchedInputSeq === (session.inputSeq || 0);
+        if (session.awaitingCompletion && hasUnreadInput && isCurrentInput && !this.hasConnectedSessionClient(session.id)) {
+          session.hasUnreadCompletion = true;
+        }
+        session.awaitingCompletion = false;
+        session.isThinking = false;
+      }, 10000);
+    }
+
+    this.emit('output', { sessionId: session.id, data, session });
+  }
+
+  handleExit(session) {
+    if (!this.sessions.has(session.id)) return;
+    this.logger.info(`Session ${session.id} (${session.name}) exited.`);
+    clearTimeout(session.completionTimer);
+    this.disposeSessionHistory(session);
+    this.sessions.delete(session.id);
+    this.emit('exit', { sessionId: session.id, session });
+  }
+
+  markSessionInput(session, data) {
+    if (typeof data !== 'string' || data.length === 0) return;
+    session.inputSeq = (session.inputSeq || 0) + 1;
+    session.awaitingCompletion = true;
+    session.isThinking = false;
+    session.hasUnreadCompletion = false;
+    clearTimeout(session.completionTimer);
+    this.logSessionDiagnostics('session-input', session, {
+      inputSeq: session.inputSeq,
+      inputPreview: previewText(data)
+    }, { compact: true });
+  }
+
+  disposeSessionHistory(session) {
+    if (session.renderedHistory) {
+      session.renderedHistory.dispose();
+      session.renderedHistory = null;
+    }
+  }
+
+  getSessionDiagnostics(session, extra = {}) {
+    return {
+      sessionId: session.id,
+      sessionName: session.name,
+      toolKey: session.tool.key,
+      historyMode: session.historyMode,
+      workingDirectory: session.ptyManager.workingDir,
+      buffer: session.buffer.getDebugSnapshot(),
+      textHistory: session.textHistory.getDebugSnapshot(),
+      renderedHistory: session.renderedHistory ? session.renderedHistory.getDebugSnapshot() : null,
+      ...extra
+    };
+  }
+
+  getCompactSessionDiagnostics(session, extra = {}) {
+    const buffer = session.buffer.getDebugSnapshot();
+    const textHistory = session.textHistory.getDebugSnapshot();
+    const renderedHistory = session.renderedHistory ? session.renderedHistory.getDebugSnapshot() : null;
+    return {
+      sessionId: session.id,
+      sessionName: session.name,
+      toolKey: session.tool.key,
+      historyMode: session.historyMode,
+      workingDirectory: session.ptyManager.workingDir,
+      buffer: {
+        items: buffer.items,
+        totalSize: buffer.totalSize,
+        currentSeq: buffer.currentSeq,
+        oldestSeq: buffer.oldestSeq,
+        newestSeq: buffer.newestSeq,
+        combinedTailPreview: buffer.combinedTailPreview
+      },
+      textHistory: {
+        lines: textHistory.lines,
+        bytes: textHistory.bytes,
+        totalWrites: textHistory.totalWrites,
+        totalBytes: textHistory.totalBytes,
+        escapeCount: textHistory.escapeCount,
+        clearEvents: textHistory.clearEvents,
+        eraseLineEvents: textHistory.eraseLineEvents,
+        cursorMoveEvents: textHistory.cursorMoveEvents,
+        trimEvents: textHistory.trimEvents,
+        tailPreview: textHistory.tailPreview
+      },
+      renderedHistory: renderedHistory ? {
+        cols: renderedHistory.cols,
+        rows: renderedHistory.rows,
+        totalWrites: renderedHistory.totalWrites,
+        totalBytes: renderedHistory.totalBytes,
+        pendingWrites: renderedHistory.pendingWrites,
+        resizeEvents: renderedHistory.resizeEvents,
+        bufferLines: renderedHistory.bufferLines,
+        baseY: renderedHistory.baseY,
+        cursorY: renderedHistory.cursorY,
+        cursorX: renderedHistory.cursorX,
+        tailPreview: renderedHistory.tailPreview
+      } : null,
+      ...extra
+    };
+  }
+
+  logSessionDiagnostics(reason, session, extra = {}, options = {}) {
+    if (!this.debugHistoryEnabled || !session) return;
+    const payload = options.compact
+      ? this.getCompactSessionDiagnostics(session, extra)
+      : this.getSessionDiagnostics(session, extra);
+    this.logger.debugInfo(`[history-debug] ${reason} ${JSON.stringify(payload)}`);
+  }
+}
+
+module.exports = SessionManager;

package/lib/session/text-history.js

@@ -0,0 +1,274 @@
+class TextHistory {
+  constructor(options = {}) {
+    this.maxBytes = options.maxBytes || 5 * 1024 * 1024;
+    this.debugLabel = options.debugLabel || 'session';
+    this.lines = [''];
+    this.row = 0;
+    this.col = 0;
+    this.updatedAt = Date.now();
+    this.truncated = false;
+    this.totalWrites = 0;
+    this.totalBytes = 0;
+    this.escapeCount = 0;
+    this.clearEvents = 0;
+    this.eraseLineEvents = 0;
+    this.cursorMoveEvents = 0;
+    this.trimEvents = 0;
+    this.lastEvents = [];
+  }
+
+  write(data) {
+    if (!data) return;
+    const text = String(data);
+    this.totalWrites += 1;
+    this.totalBytes += Buffer.byteLength(text, 'utf8');
+
+    for (let i = 0; i < text.length; i++) {
+      const ch = text[i];
+
+      if (ch === '\x1b') {
+        this.escapeCount += 1;
+        i = this.skipEscape(text, i);
+        continue;
+      }
+
+      if (ch === '\r') {
+        this.col = 0;
+        continue;
+      }
+
+      if (ch === '\n') {
+        this.newLine();
+        continue;
+      }
+
+      if (ch === '\b') {
+        this.col = Math.max(0, this.col - 1);
+        continue;
+      }
+
+      if (ch === '\t') {
+        const spaces = 4 - (this.col % 4);
+        for (let j = 0; j < spaces; j++) this.writeChar(' ');
+        continue;
+      }
+
+      if (ch >= ' ' || ch === '\u00a0') {
+        this.writeChar(ch);
+      }
+    }
+
+    this.updatedAt = Date.now();
+    this.trim();
+  }
+
+  toJSON() {
+    return {
+      text: this.toString(),
+      updatedAt: this.updatedAt,
+      truncated: this.truncated,
+      bytes: Buffer.byteLength(this.toString(), 'utf8'),
+      lines: this.lines.length
+    };
+  }
+
+  getDebugSnapshot(options = {}) {
+    const tailLines = options.tailLines || 12;
+    return {
+      label: this.debugLabel,
+      updatedAt: this.updatedAt,
+      truncated: this.truncated,
+      row: this.row,
+      col: this.col,
+      lines: this.lines.length,
+      bytes: Buffer.byteLength(this.lines.join('\n'), 'utf8'),
+      totalWrites: this.totalWrites,
+      totalBytes: this.totalBytes,
+      escapeCount: this.escapeCount,
+      clearEvents: this.clearEvents,
+      eraseLineEvents: this.eraseLineEvents,
+      cursorMoveEvents: this.cursorMoveEvents,
+      trimEvents: this.trimEvents,
+      lastEvents: [...this.lastEvents],
+      tailPreview: this.previewText(this.lines.slice(-tailLines).join('\n'))
+    };
+  }
+
+  toString() {
+    return this.lines.join('\n').replace(/\s+$/g, '');
+  }
+
+  writeChar(ch) {
+    this.ensureRow();
+    const line = this.lines[this.row] || '';
+    const padded = line.length < this.col ? line + ' '.repeat(this.col - line.length) : line;
+    this.lines[this.row] = padded.slice(0, this.col) + ch + padded.slice(this.col + 1);
+    this.col += 1;
+  }
+
+  newLine() {
+    this.row += 1;
+    this.col = 0;
+    this.ensureRow();
+  }
+
+  ensureRow() {
+    while (this.row >= this.lines.length) {
+      this.lines.push('');
+    }
+  }
+
+  skipEscape(text, index) {
+    const next = text[index + 1];
+
+    if (next === ']') {
+      return this.skipOsc(text, index + 2);
+    }
+
+    if (next === '[') {
+      return this.handleCsi(text, index + 2);
+    }
+
+    return Math.min(index + 1, text.length - 1);
+  }
+
+  skipOsc(text, index) {
+    for (let i = index; i < text.length; i++) {
+      if (text[i] === '\x07') return i;
+      if (text[i] === '\x1b' && text[i + 1] === '\\') return i + 1;
+    }
+    return text.length - 1;
+  }
+
+  handleCsi(text, index) {
+    let i = index;
+    while (i < text.length && !/[A-Za-z@`~]/.test(text[i])) {
+      i++;
+    }
+    if (i >= text.length) return text.length - 1;
+
+    const params = text.slice(index, i);
+    const command = text[i];
+    this.applyCsi(params, command);
+    return i;
+  }
+
+  applyCsi(params, command) {
+    const values = params
+      .replace(/[?>!]/g, '')
+      .split(';')
+      .filter(Boolean)
+      .map(value => Number.parseInt(value, 10))
+      .map(value => Number.isFinite(value) ? value : 0);
+    const first = values[0] || 0;
+
+    if (command === 'K') {
+      this.eraseLineEvents += 1;
+      this.recordEvent(`CSI K(${first})`);
+      this.eraseLine(first);
+      return;
+    }
+
+    if (command === 'J') {
+      if (first === 2 || first === 3) {
+        this.clearEvents += 1;
+        this.recordEvent(`CSI J(${first}) ignored-clear`);
+        this.startFreshLineAfterClear();
+      }
+      return;
+    }
+
+    if (command === 'H' || command === 'f') {
+      this.cursorMoveEvents += 1;
+      this.recordEvent(`CSI ${command}(${params || ''}) ignored-cursor`);
+      return;
+    }
+
+    if (command === 'A') {
+      this.cursorMoveEvents += 1;
+      this.recordEvent(`CSI A(${first || 1}) ignored-cursor`);
+      return;
+    }
+
+    if (command === 'B') {
+      this.cursorMoveEvents += 1;
+      this.recordEvent(`CSI B(${first || 1}) ignored-cursor`);
+      return;
+    }
+
+    if (command === 'C') {
+      this.cursorMoveEvents += 1;
+      this.recordEvent(`CSI C(${first || 1}) ignored-cursor`);
+      return;
+    }
+
+    if (command === 'D') {
+      this.cursorMoveEvents += 1;
+      this.recordEvent(`CSI D(${first || 1}) ignored-cursor`);
+      return;
+    }
+
+    if (command === 'G') {
+      this.cursorMoveEvents += 1;
+      this.recordEvent(`CSI G(${first || 1}) ignored-cursor`);
+    }
+  }
+
+  eraseLine(mode) {
+    this.ensureRow();
+    const line = this.lines[this.row] || '';
+    if (mode === 1) {
+      this.lines[this.row] = ' '.repeat(Math.min(this.col, line.length)) + line.slice(this.col);
+    } else if (mode === 2) {
+      this.lines[this.row] = '';
+      this.col = 0;
+    } else {
+      this.lines[this.row] = line.slice(0, this.col);
+    }
+  }
+
+  startFreshLineAfterClear() {
+    const hasContent = this.lines.some(line => line.length > 0);
+    const currentLine = this.lines[this.row] || '';
+    if (hasContent && currentLine.length > 0) this.newLine();
+    this.row = this.lines.length - 1;
+    this.col = 0;
+    this.lines[this.row] = '';
+  }
+
+  trim() {
+    let bytes = Buffer.byteLength(this.lines.join('\n'), 'utf8');
+    while (bytes > this.maxBytes && this.lines.length > 1) {
+      const removed = this.lines.shift();
+      bytes -= Buffer.byteLength(removed, 'utf8') + 1;
+      this.row = Math.max(0, this.row - 1);
+      this.truncated = true;
+      this.trimEvents += 1;
+    }
+
+    if (bytes > this.maxBytes && this.lines.length === 1) {
+      const keepChars = Math.floor(this.maxBytes / 2);
+      this.lines[0] = this.lines[0].slice(-keepChars);
+      this.col = Math.min(this.col, this.lines[0].length);
+      this.truncated = true;
+      this.trimEvents += 1;
+    }
+  }
+
+  recordEvent(message) {
+    this.lastEvents.push(`${new Date().toISOString()} ${message}`);
+    if (this.lastEvents.length > 25) this.lastEvents.shift();
+  }
+
+  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 = TextHistory;