mstro-app 0.1.58 → 0.3.0

package/server/services/terminal/pty-manager.ts

@@ -12,15 +12,13 @@
  * - Scrollback buffer is maintained for replay on reconnect
  * - Sessions can be reattached without losing running processes
  *
- * Also supports tmux-backed persistence for sessions that survive server restarts.
- *
  * NOTE: node-pty is an optional dependency requiring native compilation.
  * Terminal features gracefully degrade when node-pty is not available.
  */
 
 import { EventEmitter } from 'node:events';
 import { homedir, platform } from 'node:os';
-import { getTmuxManager, isTmuxAvailable, type TmuxSession } from './tmux-manager.js';
+import { sanitizeEnvForSandbox } from '../sandbox-utils.js';
 
 // Try to load node-pty (optional native dependency)
 let pty: typeof import('node-pty') | null = null;
@@ -74,11 +72,6 @@ export function getPtyInstallInstructions(): string {
   return instructions;
 }
 
-// Maximum lines to store in scrollback buffer per terminal
-const MAX_SCROLLBACK_LINES = 5000;
-// Maximum characters per line to prevent memory bloat
-const MAX_LINE_LENGTH = 2000;
-
 // Import type separately for type-checking (doesn't require the module to load)
 type IPty = import('node-pty').IPty;
 
@@ -87,8 +80,6 @@ export interface PTYSession {
   pty: IPty;
   shell: string;
   cwd: string;
-  // Scrollback buffer for replay on reconnect
-  scrollback: string[];
   // Timestamp when session was created
   createdAt: number;
   // Last activity timestamp
@@ -96,6 +87,9 @@ export interface PTYSession {
   // Current dimensions
   cols: number;
   rows: number;
+  // Output coalescing: buffer small chunks into fewer WS messages
+  _outputBuffer: string;
+  _outputTimer: ReturnType<typeof setTimeout> | null;
 }
 
 /**
@@ -156,41 +150,6 @@ export class PTYManager extends EventEmitter {
     };
   }
 
-  /**
-   * Get scrollback buffer for replay on reconnect
-   * Returns the stored output history
-   */
-  getScrollback(terminalId: string): string[] {
-    const session = this.terminals.get(terminalId);
-    if (!session) return [];
-    return [...session.scrollback];
-  }
-
-  /**
-   * Add data to scrollback buffer
-   * Maintains a rolling buffer of recent terminal output
-   */
-  private addToScrollback(session: PTYSession, data: string): void {
-    // Split data into lines
-    const lines = data.split(/\r?\n/);
-
-    for (const line of lines) {
-      // Truncate very long lines to prevent memory issues
-      const truncatedLine = line.length > MAX_LINE_LENGTH
-        ? `${line.slice(0, MAX_LINE_LENGTH)}...`
-        : line;
-
-      session.scrollback.push(truncatedLine);
-    }
-
-    // Trim buffer if it exceeds max size
-    if (session.scrollback.length > MAX_SCROLLBACK_LINES) {
-      session.scrollback = session.scrollback.slice(-MAX_SCROLLBACK_LINES);
-    }
-
-    session.lastActivityAt = Date.now();
-  }
-
   /**
    * Check if PTY functionality is available
    */
@@ -213,7 +172,8 @@ export class PTYManager extends EventEmitter {
     workingDir: string,
     cols: number = 80,
     rows: number = 24,
-    requestedShell?: string
+    requestedShell?: string,
+    options?: { sandboxed?: boolean }
   ): { shell: string; cwd: string; isReconnect: boolean } {
     // Check if node-pty is available
     if (!pty) {
@@ -242,43 +202,83 @@ export class PTYManager extends EventEmitter {
 
 
     try {
+      // Build env: sandboxed sessions get stripped secrets and HOME=projectDir
+      const baseEnv = options?.sandboxed
+        ? sanitizeEnvForSandbox(process.env, cwd)
+        : { ...process.env, HOME: homedir() };
+      const env = {
+        ...baseEnv,
+        TERM: 'xterm-256color',
+        COLORTERM: 'truecolor',
+      };
+
       // Spawn the PTY process
       const ptyProcess = pty.spawn(shell, [], {
         name: 'xterm-256color',
         cols,
         rows,
         cwd,
-        env: {
-          ...process.env,
-          TERM: 'xterm-256color',
-          COLORTERM: 'truecolor',
-          // Ensure home directory is set
-          HOME: homedir(),
-        },
+        env,
       });
 
-      // Store the session with scrollback buffer
       const session: PTYSession = {
         id: terminalId,
         pty: ptyProcess,
         shell: getShellName(shell),
         cwd,
-        scrollback: [],
         createdAt: Date.now(),
         lastActivityAt: Date.now(),
         cols,
         rows,
+        _outputBuffer: '',
+        _outputTimer: null,
       };
       this.terminals.set(terminalId, session);
 
-      // Handle data output - store in scrollback and emit
+      // Handle data output — coalesce small chunks to reduce WebSocket message count.
+      // On macOS, node-pty emits many tiny chunks (sometimes single bytes) and zsh
+      // wraps echoed chars in multi-part ANSI sequences (RPROMPT, syntax highlighting).
+      // A longer window on macOS ensures these multi-part sequences arrive as one chunk,
+      // which the browser's predictive echo can match correctly.
+      const OUTPUT_COALESCE_MS = platform() === 'darwin' ? 16 : 8;
+      // High-water mark: flush immediately when buffer exceeds this size
+      // to prevent unbounded memory growth during high-output commands (e.g. `yes`)
+      const OUTPUT_HIGH_WATER = 64 * 1024; // 64KB
+      // Maximum chunk size per WebSocket message to prevent browser overload
+      const OUTPUT_CHUNK_SIZE = 64 * 1024;
+
+      const flushOutputBuffer = () => {
+        if (session._outputTimer) {
+          clearTimeout(session._outputTimer);
+          session._outputTimer = null;
+        }
+        const buffered = session._outputBuffer;
+        session._outputBuffer = '';
+        // Chunk large output to prevent single massive WebSocket frames
+        for (let i = 0; i < buffered.length; i += OUTPUT_CHUNK_SIZE) {
+          this.emit('output', terminalId, buffered.slice(i, i + OUTPUT_CHUNK_SIZE));
+        }
+      };
+
       ptyProcess.onData((data: string) => {
-        this.addToScrollback(session, data);
-        this.emit('output', terminalId, data);
+        session.lastActivityAt = Date.now();
+        session._outputBuffer += data;
+        // Flush immediately if buffer exceeds high-water mark
+        if (session._outputBuffer.length >= OUTPUT_HIGH_WATER) {
+          flushOutputBuffer();
+        } else if (!session._outputTimer) {
+          session._outputTimer = setTimeout(flushOutputBuffer, OUTPUT_COALESCE_MS);
+        }
       });
 
-      // Handle exit
+      // Handle exit — flush any buffered output first
       ptyProcess.onExit(({ exitCode }) => {
+        if (session._outputBuffer) {
+          flushOutputBuffer();
+        } else if (session._outputTimer) {
+          clearTimeout(session._outputTimer);
+          session._outputTimer = null;
+        }
         this.emit('exit', terminalId, exitCode);
         this.terminals.delete(terminalId);
       });
@@ -341,6 +341,15 @@ export class PTYManager extends EventEmitter {
 
 
     try {
+      // Flush any coalesced output before closing
+      if (session._outputTimer) {
+        clearTimeout(session._outputTimer);
+        if (session._outputBuffer) {
+          this.emit('output', terminalId, session._outputBuffer);
+          session._outputBuffer = '';
+        }
+        session._outputTimer = null;
+      }
       session.pty.kill();
       this.terminals.delete(terminalId);
       return true;
@@ -381,76 +390,6 @@ export class PTYManager extends EventEmitter {
     }
   }
 
-  /**
-   * Check if tmux persistence is available
-   */
-  isTmuxAvailable(): boolean {
-    return isTmuxAvailable();
-  }
-
-  /**
-   * Get list of persistent tmux sessions that can be restored
-   * These are sessions that survived a server restart
-   */
-  getPersistentSessions(): TmuxSession[] {
-    const tmux = getTmuxManager();
-    return tmux.getActiveSessions();
-  }
-
-  /**
-   * Create a persistent (tmux-backed) terminal session
-   * These sessions survive server restarts
-   */
-  createPersistent(
-    terminalId: string,
-    workingDir: string,
-    cols: number = 80,
-    rows: number = 24,
-    requestedShell?: string
-  ): { shell: string; cwd: string; isReconnect: boolean; persistent: true } {
-    const tmux = getTmuxManager();
-
-    if (!tmux.isAvailable()) {
-      throw new Error('tmux is not available for persistent sessions');
-    }
-
-    const result = tmux.create(terminalId, workingDir, cols, rows, requestedShell);
-    return { ...result, persistent: true };
-  }
-
-  /**
-   * Attach to a persistent (tmux) session
-   * Returns handlers for write, resize, and detach
-   */
-  attachPersistent(
-    terminalId: string,
-    onOutput: (data: string) => void,
-    onExit: (code: number) => void
-  ): { write: (data: string) => void; resize: (cols: number, rows: number) => void; detach: () => void } | null {
-    const tmux = getTmuxManager();
-
-    if (!tmux.exists(terminalId)) {
-      return null;
-    }
-
-    return tmux.attach(terminalId, onOutput, onExit);
-  }
-
-  /**
-   * Get scrollback from a persistent (tmux) session
-   */
-  getPersistentScrollback(terminalId: string): string[] {
-    const tmux = getTmuxManager();
-    return tmux.getScrollback(terminalId);
-  }
-
-  /**
-   * Close a persistent (tmux) session
-   */
-  closePersistent(terminalId: string): boolean {
-    const tmux = getTmuxManager();
-    return tmux.close(terminalId);
-  }
 }
 
 // Singleton instance

package/server/services/websocket/autocomplete.test.ts

@@ -0,0 +1,194 @@
+import { describe, expect, it, vi } from 'vitest';
+import { AutocompleteService } from './autocomplete.js';
+
+// Mock file system operations to avoid hitting real FS
+vi.mock('node:fs', () => ({
+  existsSync: vi.fn(() => false),
+  readdirSync: vi.fn(() => []),
+  statSync: vi.fn(() => ({ isDirectory: () => false })),
+}));
+
+vi.mock('./file-utils.js', () => ({
+  CACHE_TTL_MS: 5000,
+  directoryCache: new Map(),
+  getFileType: vi.fn((path: string) => {
+    const ext = path.split('.').pop() || '';
+    return ext || 'unknown';
+  }),
+  isIgnored: vi.fn(() => false),
+  parseGitignore: vi.fn(() => []),
+  scanDirectoryRecursiveWithDepth: vi.fn(() => []),
+}));
+
+describe('AutocompleteService', () => {
+  // ========== Frecency ==========
+
+  describe('calculateFrecencyScore', () => {
+    it('returns 0 for unknown files', () => {
+      const svc = new AutocompleteService();
+      expect(svc.calculateFrecencyScore('nonexistent.ts')).toBe(0);
+    });
+
+    it('returns positive score for recently used files', () => {
+      const svc = new AutocompleteService();
+      svc.recordFileSelection('src/index.ts');
+      const score = svc.calculateFrecencyScore('src/index.ts');
+      expect(score).toBeGreaterThan(0);
+    });
+
+    it('increases score with more selections', () => {
+      const svc = new AutocompleteService();
+      svc.recordFileSelection('src/index.ts');
+      const score1 = svc.calculateFrecencyScore('src/index.ts');
+
+      svc.recordFileSelection('src/index.ts');
+      svc.recordFileSelection('src/index.ts');
+      const score3 = svc.calculateFrecencyScore('src/index.ts');
+
+      expect(score3).toBeGreaterThan(score1);
+    });
+
+    it('decays score over time', () => {
+      const svc = new AutocompleteService();
+
+      // Record selection at a specific time
+      const now = Date.now();
+      vi.spyOn(Date, 'now').mockReturnValue(now);
+      svc.recordFileSelection('src/index.ts');
+      const recentScore = svc.calculateFrecencyScore('src/index.ts');
+
+      // Move forward 8 days (past the 7-day recency window)
+      vi.spyOn(Date, 'now').mockReturnValue(now + 8 * 24 * 60 * 60 * 1000);
+      const staleScore = svc.calculateFrecencyScore('src/index.ts');
+
+      expect(staleScore).toBeLessThan(recentScore);
+      vi.restoreAllMocks();
+    });
+
+    it('handles initial frecency data in constructor', () => {
+      const svc = new AutocompleteService({
+        'src/main.ts': { count: 5, lastUsed: Date.now() },
+      });
+      expect(svc.calculateFrecencyScore('src/main.ts')).toBeGreaterThan(0);
+    });
+  });
+
+  // ========== recordFileSelection ==========
+
+  describe('recordFileSelection', () => {
+    it('creates new entry for first selection', () => {
+      const svc = new AutocompleteService();
+      svc.recordFileSelection('new-file.ts');
+
+      const data = svc.getFrecencyData();
+      expect(data['new-file.ts']).toBeDefined();
+      expect(data['new-file.ts'].count).toBe(1);
+    });
+
+    it('increments count for existing entry', () => {
+      const svc = new AutocompleteService();
+      svc.recordFileSelection('file.ts');
+      svc.recordFileSelection('file.ts');
+      svc.recordFileSelection('file.ts');
+
+      const data = svc.getFrecencyData();
+      expect(data['file.ts'].count).toBe(3);
+    });
+
+    it('updates lastUsed timestamp', () => {
+      const svc = new AutocompleteService();
+      const before = Date.now();
+      svc.recordFileSelection('file.ts');
+      const data = svc.getFrecencyData();
+      expect(data['file.ts'].lastUsed).toBeGreaterThanOrEqual(before);
+    });
+  });
+
+  // ========== setFrecencyData / getFrecencyData ==========
+
+  describe('setFrecencyData / getFrecencyData', () => {
+    it('replaces frecency data', () => {
+      const svc = new AutocompleteService();
+      svc.recordFileSelection('old.ts');
+
+      const newData = {
+        'new.ts': { count: 10, lastUsed: Date.now() },
+      };
+      svc.setFrecencyData(newData);
+
+      expect(svc.getFrecencyData()).toBe(newData);
+      expect(svc.calculateFrecencyScore('old.ts')).toBe(0);
+      expect(svc.calculateFrecencyScore('new.ts')).toBeGreaterThan(0);
+    });
+  });
+
+  // ========== getFileCompletions ==========
+
+  describe('getFileCompletions', () => {
+    it('returns empty array when no files match', () => {
+      const svc = new AutocompleteService();
+      const results = svc.getFileCompletions('nonexistent', '/tmp/test');
+      expect(results).toEqual([]);
+    });
+
+    it('handles @ symbol prefix', () => {
+      const svc = new AutocompleteService();
+      // Should not throw when handling @ prefix
+      const results = svc.getFileCompletions('@src/index', '/tmp/test');
+      expect(Array.isArray(results)).toBe(true);
+    });
+
+    it('returns empty array on error', () => {
+      const svc = new AutocompleteService();
+      // Invalid working dir should return empty (caught by try/catch)
+      const results = svc.getFileCompletions('test', '/nonexistent/path');
+      expect(results).toEqual([]);
+    });
+
+    it('limits results to 15', () => {
+      // This is tested structurally — the code slices to 15
+      const svc = new AutocompleteService();
+      const results = svc.getFileCompletions('', '/tmp/test');
+      expect(results.length).toBeLessThanOrEqual(15);
+    });
+  });
+
+  // ========== Scoring logic (frecency weight formula) ==========
+
+  describe('frecency scoring formula', () => {
+    it('uses log2 for frequency weight', () => {
+      const svc = new AutocompleteService();
+
+      // count=1: log2(2) = 1
+      svc.setFrecencyData({ 'a.ts': { count: 1, lastUsed: Date.now() } });
+      const score1 = svc.calculateFrecencyScore('a.ts');
+
+      // count=7: log2(8) = 3
+      svc.setFrecencyData({ 'a.ts': { count: 7, lastUsed: Date.now() } });
+      const score7 = svc.calculateFrecencyScore('a.ts');
+
+      // Score should roughly triple (3x) since frequency goes from 1 to 3
+      expect(score7 / score1).toBeCloseTo(3, 0);
+    });
+
+    it('recency weight is ~1.0 for very recent files', () => {
+      const svc = new AutocompleteService();
+      svc.setFrecencyData({ 'a.ts': { count: 1, lastUsed: Date.now() } });
+      const score = svc.calculateFrecencyScore('a.ts');
+
+      // With recencyWeight ≈ 1, score ≈ log2(2) * (0.3 + 0.7*1) * 100 = 100
+      expect(score).toBeCloseTo(100, -1);
+    });
+
+    it('recency weight is ~0.3 for files used > 7 days ago', () => {
+      const svc = new AutocompleteService();
+      const eightDaysAgo = Date.now() - (8 * 24 * 60 * 60 * 1000);
+      svc.setFrecencyData({ 'a.ts': { count: 1, lastUsed: eightDaysAgo } });
+      const score = svc.calculateFrecencyScore('a.ts');
+
+      // With recencyWeight = max(0, 1 - 8*24/168) = 0
+      // score ≈ log2(2) * (0.3 + 0.7*0) * 100 = 30
+      expect(score).toBeCloseTo(30, -1);
+    });
+  });
+});