@jhizzard/termdeck 0.2.0

package/packages/server/src/session.js

@@ -0,0 +1,421 @@
+// Session manager - PTY lifecycle, metadata tracking, output analysis
+// Each session wraps a node-pty instance with rich metadata
+
+const { v4: uuidv4 } = require('uuid');
+const os = require('os');
+const path = require('path');
+
+// Strip ANSI escape codes for pattern matching
+function stripAnsi(str) {
+  return str
+    .replace(/\x1b\[[\?]?[0-9;]*[A-Za-z]/g, '')   // CSI sequences (including ?-prefixed like bracketed paste)
+    .replace(/\x1b\][^\x07]*\x07/g, '')             // OSC sequences
+    .replace(/\x1b[()][A-Z0-9]/g, '')               // Character set sequences
+    .replace(/\x1b[>=<]/g, '');                      // Keypad/cursor modes
+}
+
+// Pattern matchers for detecting terminal type and status
+const PATTERNS = {
+  claudeCode: {
+    prompt: /^[>❯]\s/m,
+    thinking: /\b(thinking|Thinking)\b/,
+    editing: /^(Edit|Create|Update|Delete)\s/m,
+    tool: /^⏺\s/m,
+    idle: /^>\s*$/m
+  },
+  geminiCli: {
+    prompt: /^gemini>\s/m,
+    thinking: /\b(Generating|Working)\b/,
+  },
+  pythonServer: {
+    uvicorn: /Uvicorn running on/,
+    flask: /Running on http/,
+    django: /Starting development server/,
+    httpServer: /Serving HTTP on/,
+    request: /(?:^|\s|")(GET|POST|PUT|DELETE|PATCH)\s+\S+.*?\s(\d{3})/m,
+    port: /(?:port\s+(\d+)|(?:on|at)\s+(?:https?:\/\/)?[\w.\[\]:]*:(\d+))/i
+  },
+  shell: {
+    prompt: /[\$#%❯>]\s*$/m,
+    // Match lines ending with common shell control sequences that indicate a new prompt
+    // We track commands via input echo instead (see _trackInput)
+    command: /^[\$#%❯>]\s+(.+)$/m
+  },
+  // Broad error markers across shells, compilers, scripts, and HTTP servers.
+  error: /\b(error|Error|ERROR|exception|Exception|Traceback|fatal|FATAL|segmentation fault|panic|EACCES|ECONNREFUSED|ENOENT|command not found|undefined reference|cannot find module|failed with exit code|\b5\d\d\b)\b/
+};
+
+class Session {
+  constructor(options) {
+    this.id = options.id || uuidv4();
+    this.pid = null;
+    this.pty = null;
+    this.ws = null;
+
+    // Metadata
+    this.meta = {
+      type: options.type || 'shell',        // shell, claude-code, gemini, python-server, one-shot
+      project: options.project || null,
+      label: options.label || '',
+      command: options.command || '',
+      cwd: options.cwd || os.homedir(),
+      createdAt: new Date().toISOString(),
+      reason: options.reason || 'manual launch',
+
+      // Dynamic state (updated by output analyzer)
+      status: 'starting',                   // starting, active, idle, thinking, editing, errored, exited
+      statusDetail: '',
+      lastCommands: [],                      // rolling buffer of last 10 commands
+      lastActivity: new Date().toISOString(),
+      detectedPort: null,
+      requestCount: 0,
+      exitCode: null,
+      childProcesses: [],
+
+      // Theme
+      theme: options.theme || 'tokyo-night',
+
+      // RAG
+      ragEnabled: options.ragEnabled !== false,
+      ragEvents: []                          // buffer before flush
+    };
+
+    // Output analysis state
+    this._outputBuffer = '';
+    this._outputFlushTimer = null;
+    this._commandBuffer = '';
+    this._inputBuffer = '';   // tracks user keyboard input for command detection
+    this.onCommand = null;    // callback: (sessionId, command) => void
+    this.onStatusChange = null; // callback: (session, oldStatus, newStatus) => void
+    this.onErrorDetected = null; // callback: (session, { lastCommand, tail }) => void
+    this._statusChangeTimer = null;
+    this._pendingStatusChange = null;
+    this._lastErrorFireAt = 0;
+  }
+
+  // Analyze PTY output to extract metadata
+  analyzeOutput(data) {
+    this._outputBuffer += data;
+    this.meta.lastActivity = new Date().toISOString();
+
+    // Strip ANSI codes for reliable pattern matching
+    const clean = stripAnsi(data);
+
+    // Detect terminal type if still generic
+    if (this.meta.type === 'shell') {
+      this._detectType(clean);
+    }
+
+    // Detect ports before status update (so status can reference the port)
+    this._detectPort(clean);
+
+    // Update status based on type-specific patterns
+    this._updateStatus(clean);
+
+    // Extract commands from shell-like prompts
+    this._extractCommands(clean);
+
+    // Count HTTP requests for server terminals
+    this._countRequests(clean);
+
+    // Error detection — transition to 'errored' and fire onErrorDetected (rate limited 30s)
+    this._detectErrors(clean);
+
+    // Flush buffer periodically (don't hold too much in memory)
+    clearTimeout(this._outputFlushTimer);
+    this._outputFlushTimer = setTimeout(() => {
+      // Keep last 4KB for pattern matching
+      if (this._outputBuffer.length > 4096) {
+        this._outputBuffer = this._outputBuffer.slice(-4096);
+      }
+      // Server types: revert to 'listening' after output settles
+      if (this.meta.type === 'python-server' && this.meta.status === 'active') {
+        this.meta.status = 'listening';
+        this.meta.statusDetail = this.meta.detectedPort
+          ? `Serving on :${this.meta.detectedPort}`
+          : 'Server running';
+      }
+    }, 2000);
+  }
+
+  _detectType(data) {
+    if (PATTERNS.claudeCode.prompt.test(data) || /claude/i.test(this.meta.command)) {
+      this.meta.type = 'claude-code';
+    } else if (PATTERNS.geminiCli.prompt.test(data) || /gemini/i.test(this.meta.command)) {
+      this.meta.type = 'gemini';
+    } else if (
+      PATTERNS.pythonServer.uvicorn.test(data) ||
+      PATTERNS.pythonServer.flask.test(data) ||
+      PATTERNS.pythonServer.django.test(data) ||
+      PATTERNS.pythonServer.httpServer.test(data)
+    ) {
+      this.meta.type = 'python-server';
+    }
+  }
+
+  _updateStatus(data) {
+    const p = PATTERNS;
+    const oldStatus = this.meta.status;
+
+    switch (this.meta.type) {
+      case 'claude-code':
+        if (p.claudeCode.thinking.test(data)) {
+          this.meta.status = 'thinking';
+          this.meta.statusDetail = 'Claude is reasoning...';
+        } else if (p.claudeCode.editing.test(data)) {
+          this.meta.status = 'editing';
+          const match = data.match(/^(Edit|Create|Update|Delete)\s+(.+)$/m);
+          this.meta.statusDetail = match ? `${match[1]} ${match[2]}` : 'Editing files';
+        } else if (p.claudeCode.tool.test(data)) {
+          this.meta.status = 'active';
+          this.meta.statusDetail = 'Using tools';
+        } else if (p.claudeCode.idle.test(data)) {
+          this.meta.status = 'idle';
+          this.meta.statusDetail = 'Waiting for input';
+        }
+        break;
+
+      case 'gemini':
+        if (p.geminiCli.thinking.test(data)) {
+          this.meta.status = 'thinking';
+          this.meta.statusDetail = 'Gemini is generating...';
+        } else if (p.geminiCli.prompt.test(data)) {
+          this.meta.status = 'idle';
+          this.meta.statusDetail = 'Waiting for input';
+        }
+        break;
+
+      case 'python-server':
+        if (p.pythonServer.request.test(data)) {
+          this.meta.status = 'active';
+          const match = data.match(p.pythonServer.request);
+          if (match) {
+            this.meta.statusDetail = `${match[1]} → ${match[2]}`;
+          }
+        } else {
+          this.meta.status = 'listening';
+          this.meta.statusDetail = this.meta.detectedPort
+            ? `Serving on :${this.meta.detectedPort}`
+            : 'Server running';
+        }
+        break;
+
+      default:
+        if (p.shell.prompt.test(data)) {
+          this.meta.status = 'idle';
+          this.meta.statusDetail = 'Ready';
+        } else {
+          this.meta.status = 'active';
+        }
+    }
+
+    // Debounce status change events (3s) to avoid flooding RAG with active↔idle flaps
+    if (this.meta.status !== oldStatus && this.onStatusChange) {
+      clearTimeout(this._statusChangeTimer);
+      this._pendingStatusChange = { oldStatus, newStatus: this.meta.status };
+      this._statusChangeTimer = setTimeout(() => {
+        if (this._pendingStatusChange) {
+          this.onStatusChange(this, this._pendingStatusChange.oldStatus, this._pendingStatusChange.newStatus);
+          this._pendingStatusChange = null;
+        }
+      }, 3000);
+    }
+  }
+
+  _detectPort(data) {
+    const match = data.match(PATTERNS.pythonServer.port);
+    if (match) {
+      // Two capture groups: match[1] for "port XXXX", match[2] for ":XXXX"
+      this.meta.detectedPort = parseInt(match[1] || match[2], 10);
+    }
+  }
+
+  // Track user input to detect commands (called from server when PTY receives input)
+  trackInput(data) {
+    for (let i = 0; i < data.length; i++) {
+      const ch = data[i];
+      const code = ch.charCodeAt(0);
+
+      if (ch === '\r' || ch === '\n') {
+        // Enter — flush the buffer as a command
+        const cmd = this._inputBuffer.trim();
+        if (cmd.length > 0 && cmd.length < 500) {
+          const clean = cmd.replace(/\x1b\[[A-Za-z0-9;]*[A-Za-z]/g, '').trim();
+          if (clean.length > 0) {
+            this.meta.lastCommands.push({
+              command: clean,
+              timestamp: new Date().toISOString()
+            });
+            if (this.meta.lastCommands.length > 10) {
+              this.meta.lastCommands.shift();
+            }
+            if (this.onCommand) {
+              this.onCommand(this.id, clean);
+            }
+          }
+        }
+        this._inputBuffer = '';
+      } else if (ch === '\x7f' || ch === '\b') {
+        this._inputBuffer = this._inputBuffer.slice(0, -1);
+      } else if (ch === '\x1b') {
+        // Skip escape sequences
+        if (i + 1 < data.length && data[i + 1] === '[') {
+          i += 2; // skip \x1b[
+          while (i < data.length && !/[A-Za-z]/.test(data[i])) i++;
+          // i now points at the final letter, loop increment will skip it
+        }
+      } else if (code >= 32) {
+        this._inputBuffer += ch;
+      }
+    }
+  }
+
+  _detectErrors(clean) {
+    if (!PATTERNS.error.test(clean)) return;
+
+    const oldStatus = this.meta.status;
+    this.meta.status = 'errored';
+    this.meta.statusDetail = 'Error detected in output';
+
+    // Mirror status-change callback so T1 sees 'errored' in status_broadcast without
+    // waiting for the 3s debounce.
+    if (oldStatus !== 'errored' && this.onStatusChange) {
+      try { this.onStatusChange(this, oldStatus, 'errored'); } catch {}
+    }
+
+    // Server-side rate limit: at most one error_detected event every 30s per session
+    const now = Date.now();
+    if (now - this._lastErrorFireAt < 30000) return;
+    this._lastErrorFireAt = now;
+
+    if (this.onErrorDetected) {
+      const lastCommand = this.meta.lastCommands.length > 0
+        ? this.meta.lastCommands[this.meta.lastCommands.length - 1].command
+        : '';
+      const tail = this._outputBuffer.slice(-200).replace(/\x1b\[[\?]?[0-9;]*[A-Za-z]/g, '').replace(/\x1b\][^\x07]*\x07/g, '');
+      try {
+        this.onErrorDetected(this, { lastCommand, tail });
+      } catch (err) {
+        console.error('[session] onErrorDetected handler error:', err);
+      }
+    }
+  }
+
+  _extractCommands(data) {
+    // Output-based command extraction as fallback (e.g. for commands echoed by shell)
+    // Primary command tracking is via trackInput()
+  }
+
+  _countRequests(data) {
+    const globalRequest = new RegExp(PATTERNS.pythonServer.request.source, 'gm');
+    const matches = data.match(globalRequest);
+    if (matches) {
+      this.meta.requestCount += matches.length;
+    }
+  }
+
+  toJSON() {
+    return {
+      id: this.id,
+      pid: this.pid,
+      meta: { ...this.meta }
+    };
+  }
+
+  destroy() {
+    clearTimeout(this._outputFlushTimer);
+    clearTimeout(this._statusChangeTimer);
+    this._outputBuffer = '';
+  }
+}
+
+class SessionManager {
+  constructor(db) {
+    this.sessions = new Map();
+    this.db = db;
+    this._listeners = new Map(); // event listeners
+  }
+
+  create(options) {
+    const session = new Session(options);
+    this.sessions.set(session.id, session);
+
+    // Persist to SQLite
+    if (this.db) {
+      this.db.prepare(`
+        INSERT INTO sessions (id, type, project, label, command, cwd, created_at, reason, theme)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(
+        session.id,
+        session.meta.type,
+        session.meta.project,
+        session.meta.label,
+        session.meta.command,
+        session.meta.cwd,
+        session.meta.createdAt,
+        session.meta.reason,
+        session.meta.theme
+      );
+    }
+
+    this._emit('session:created', session);
+    return session;
+  }
+
+  get(id) {
+    return this.sessions.get(id);
+  }
+
+  getAll() {
+    return Array.from(this.sessions.values()).map(s => s.toJSON());
+  }
+
+  updateMeta(id, updates) {
+    const session = this.sessions.get(id);
+    if (!session) return null;
+
+    Object.assign(session.meta, updates);
+
+    // Persist theme changes to SQLite
+    if (updates.theme && this.db) {
+      this.db.prepare('UPDATE sessions SET theme = ? WHERE id = ?')
+        .run(updates.theme, id);
+    }
+
+    this._emit('session:updated', session);
+    return session;
+  }
+
+  remove(id) {
+    const session = this.sessions.get(id);
+    if (!session) return false;
+
+    session.destroy();
+    this.sessions.delete(id);
+
+    if (this.db) {
+      this.db.prepare(`
+        UPDATE sessions SET exited_at = ?, exit_code = ? WHERE id = ?
+      `).run(new Date().toISOString(), session.meta.exitCode, id);
+    }
+
+    this._emit('session:removed', session);
+    return true;
+  }
+
+  on(event, fn) {
+    if (!this._listeners.has(event)) {
+      this._listeners.set(event, []);
+    }
+    this._listeners.get(event).push(fn);
+  }
+
+  _emit(event, data) {
+    const fns = this._listeners.get(event) || [];
+    for (const fn of fns) {
+      try { fn(data); } catch (e) { console.error(`[events] handler error for ${event}:`, e); }
+    }
+  }
+}
+
+module.exports = { Session, SessionManager, PATTERNS };

package/packages/server/src/themes.js

@@ -0,0 +1,250 @@
+// Terminal themes for xterm.js
+// Each theme is a complete xterm ITheme object
+
+const themes = {
+  'tokyo-night': {
+    label: 'Tokyo Night',
+    category: 'dark',
+    theme: {
+      background: '#1a1b26',
+      foreground: '#c0caf5',
+      cursor: '#c0caf5',
+      cursorAccent: '#1a1b26',
+      selectionBackground: '#33467c',
+      selectionForeground: '#c0caf5',
+      black: '#15161e',
+      red: '#f7768e',
+      green: '#9ece6a',
+      yellow: '#e0af68',
+      blue: '#7aa2f7',
+      magenta: '#bb9af7',
+      cyan: '#7dcfff',
+      white: '#a9b1d6',
+      brightBlack: '#414868',
+      brightRed: '#f7768e',
+      brightGreen: '#9ece6a',
+      brightYellow: '#e0af68',
+      brightBlue: '#7aa2f7',
+      brightMagenta: '#bb9af7',
+      brightCyan: '#7dcfff',
+      brightWhite: '#c0caf5'
+    }
+  },
+
+  'rose-pine-dawn': {
+    label: 'Rosé Pine Dawn',
+    category: 'light',
+    theme: {
+      background: '#faf4ed',
+      foreground: '#575279',
+      cursor: '#575279',
+      cursorAccent: '#faf4ed',
+      selectionBackground: '#dfdad9',
+      selectionForeground: '#575279',
+      black: '#f2e9e1',
+      red: '#b4637a',
+      green: '#286983',
+      yellow: '#ea9d34',
+      blue: '#56949f',
+      magenta: '#907aa9',
+      cyan: '#d7827e',
+      white: '#575279',
+      brightBlack: '#9893a5',
+      brightRed: '#b4637a',
+      brightGreen: '#286983',
+      brightYellow: '#ea9d34',
+      brightBlue: '#56949f',
+      brightMagenta: '#907aa9',
+      brightCyan: '#d7827e',
+      brightWhite: '#575279'
+    }
+  },
+
+  'catppuccin-mocha': {
+    label: 'Catppuccin Mocha',
+    category: 'dark',
+    theme: {
+      background: '#1e1e2e',
+      foreground: '#cdd6f4',
+      cursor: '#f5e0dc',
+      cursorAccent: '#1e1e2e',
+      selectionBackground: '#45475a',
+      selectionForeground: '#cdd6f4',
+      black: '#45475a',
+      red: '#f38ba8',
+      green: '#a6e3a1',
+      yellow: '#f9e2af',
+      blue: '#89b4fa',
+      magenta: '#f5c2e7',
+      cyan: '#94e2d5',
+      white: '#bac2de',
+      brightBlack: '#585b70',
+      brightRed: '#f38ba8',
+      brightGreen: '#a6e3a1',
+      brightYellow: '#f9e2af',
+      brightBlue: '#89b4fa',
+      brightMagenta: '#f5c2e7',
+      brightCyan: '#94e2d5',
+      brightWhite: '#a6adc8'
+    }
+  },
+
+  'github-light': {
+    label: 'GitHub Light',
+    category: 'light',
+    theme: {
+      background: '#ffffff',
+      foreground: '#24292f',
+      cursor: '#044289',
+      cursorAccent: '#ffffff',
+      selectionBackground: '#0969da33',
+      selectionForeground: '#24292f',
+      black: '#24292f',
+      red: '#cf222e',
+      green: '#116329',
+      yellow: '#4d2d00',
+      blue: '#0550ae',
+      magenta: '#8250df',
+      cyan: '#1b7c83',
+      white: '#6e7781',
+      brightBlack: '#57606a',
+      brightRed: '#a40e26',
+      brightGreen: '#1a7f37',
+      brightYellow: '#633c01',
+      brightBlue: '#0969da',
+      brightMagenta: '#8250df',
+      brightCyan: '#3192aa',
+      brightWhite: '#8c959f'
+    }
+  },
+
+  'dracula': {
+    label: 'Dracula',
+    category: 'dark',
+    theme: {
+      background: '#282a36',
+      foreground: '#f8f8f2',
+      cursor: '#f8f8f2',
+      cursorAccent: '#282a36',
+      selectionBackground: '#44475a',
+      selectionForeground: '#f8f8f2',
+      black: '#21222c',
+      red: '#ff5555',
+      green: '#50fa7b',
+      yellow: '#f1fa8c',
+      blue: '#bd93f9',
+      magenta: '#ff79c6',
+      cyan: '#8be9fd',
+      white: '#f8f8f2',
+      brightBlack: '#6272a4',
+      brightRed: '#ff6e6e',
+      brightGreen: '#69ff94',
+      brightYellow: '#ffffa5',
+      brightBlue: '#d6acff',
+      brightMagenta: '#ff92df',
+      brightCyan: '#a4ffff',
+      brightWhite: '#ffffff'
+    }
+  },
+
+  'solarized-dark': {
+    label: 'Solarized Dark',
+    category: 'dark',
+    theme: {
+      background: '#002b36',
+      foreground: '#839496',
+      cursor: '#839496',
+      cursorAccent: '#002b36',
+      selectionBackground: '#073642',
+      selectionForeground: '#93a1a1',
+      black: '#073642',
+      red: '#dc322f',
+      green: '#859900',
+      yellow: '#b58900',
+      blue: '#268bd2',
+      magenta: '#d33682',
+      cyan: '#2aa198',
+      white: '#eee8d5',
+      brightBlack: '#586e75',
+      brightRed: '#cb4b16',
+      brightGreen: '#586e75',
+      brightYellow: '#657b83',
+      brightBlue: '#839496',
+      brightMagenta: '#6c71c4',
+      brightCyan: '#93a1a1',
+      brightWhite: '#fdf6e3'
+    }
+  },
+
+  'nord': {
+    label: 'Nord',
+    category: 'dark',
+    theme: {
+      background: '#2e3440',
+      foreground: '#d8dee9',
+      cursor: '#d8dee9',
+      cursorAccent: '#2e3440',
+      selectionBackground: '#434c5e',
+      selectionForeground: '#d8dee9',
+      black: '#3b4252',
+      red: '#bf616a',
+      green: '#a3be8c',
+      yellow: '#ebcb8b',
+      blue: '#81a1c1',
+      magenta: '#b48ead',
+      cyan: '#88c0d0',
+      white: '#e5e9f0',
+      brightBlack: '#4c566a',
+      brightRed: '#bf616a',
+      brightGreen: '#a3be8c',
+      brightYellow: '#ebcb8b',
+      brightBlue: '#81a1c1',
+      brightMagenta: '#b48ead',
+      brightCyan: '#8fbcbb',
+      brightWhite: '#eceff4'
+    }
+  },
+
+  'gruvbox-dark': {
+    label: 'Gruvbox Dark',
+    category: 'dark',
+    theme: {
+      background: '#282828',
+      foreground: '#ebdbb2',
+      cursor: '#ebdbb2',
+      cursorAccent: '#282828',
+      selectionBackground: '#504945',
+      selectionForeground: '#ebdbb2',
+      black: '#282828',
+      red: '#cc241d',
+      green: '#98971a',
+      yellow: '#d79921',
+      blue: '#458588',
+      magenta: '#b16286',
+      cyan: '#689d6a',
+      white: '#a89984',
+      brightBlack: '#928374',
+      brightRed: '#fb4934',
+      brightGreen: '#b8bb26',
+      brightYellow: '#fabd2f',
+      brightBlue: '#83a598',
+      brightMagenta: '#d3869b',
+      brightCyan: '#8ec07c',
+      brightWhite: '#ebdbb2'
+    }
+  }
+};
+
+// Status indicator colors (for the dot next to terminal name)
+const statusColors = {
+  starting: '#7aa2f7',    // blue
+  active: '#9ece6a',      // green
+  idle: '#888780',         // gray
+  thinking: '#bb9af7',    // purple
+  editing: '#e0af68',     // amber
+  listening: '#7dcfff',   // cyan
+  errored: '#f7768e',     // red
+  exited: '#414868'       // dim
+};
+
+module.exports = { themes, statusColors };