mstro-app 0.1.57 → 0.2.0

package/server/index.ts

@@ -8,6 +8,7 @@
 import { randomBytes } from 'node:crypto'
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
 import type { IncomingMessage } from 'node:http'
+import { homedir } from 'node:os'
 import { basename, join } from 'node:path'
 import { serve } from '@hono/node-server'
 import { Hono } from 'hono'
@@ -213,7 +214,6 @@ app.route('/api/notifications', createNotificationRoutes(WORKING_DIR))
 if (IS_PRODUCTION) {
   // For production static file serving, use a reverse proxy like nginx
   // or implement a simple static file middleware if needed
-  console.log('Production mode: serve static files via nginx or similar')
 }
 
 // ========================================
@@ -342,10 +342,9 @@ async function startServer() {
     })
   })
 
-  console.log(`🚀 Mstro Server (Node.js + Hono) on port ${PORT}`)
-  console.log(`📁 Working directory: ${WORKING_DIR}`)
-  console.log(`Runtime: Node.js ${process.version}`)
-  console.log(`Framework: Hono`)
+  const home = homedir()
+  const displayDir = WORKING_DIR.startsWith(home) ? `~${WORKING_DIR.slice(home.length)}` : WORKING_DIR
+  console.log(`Machine: ${displayDir}`)
 
   // Track server started event
   trackEvent(AnalyticsEvents.SERVER_STARTED, {
@@ -364,7 +363,7 @@ async function startServer() {
   // Connect to platform
   const platformConnection = new PlatformConnection(WORKING_DIR, {
     onConnected: (_connectionId) => {
-      console.log(`🎵 Orchestra ready: ${basename(WORKING_DIR)}`)
+      console.log(`Connected: https://mstro.app`)
 
       // Set up usage reporter to send token usage to platform
       wsHandler.setUsageReporter((report) => {
@@ -429,8 +428,6 @@ async function startServer() {
     await Promise.all([shutdownAnalytics(), flushSentry()])
     platformConnection.disconnect()
     instanceRegistry.unregister()
-    // Close all non-persistent terminal sessions (PTY processes)
-    // Note: Persistent (tmux) sessions are intentionally left running
     getPTYManager().closeAll()
     wss.close()
     console.log('\n\n👋 Shutting down gracefully...\n')
@@ -442,8 +439,6 @@ async function startServer() {
     await Promise.all([shutdownAnalytics(), flushSentry()])
     platformConnection.disconnect()
     instanceRegistry.unregister()
-    // Close all non-persistent terminal sessions (PTY processes)
-    // Note: Persistent (tmux) sessions are intentionally left running
     getPTYManager().closeAll()
     wss.close()
     console.log('\n\n👋 Shutting down gracefully...\n')

package/server/mcp/bouncer-integration.ts

@@ -251,6 +251,34 @@ export async function reviewOperation(request: BouncerReviewRequest): Promise<Bo
     console.error(`[Bouncer] User request: ${request.context.userRequest}`);
   }
 
+  // ========================================
+  // PRE-CHECK: Malformed/empty tool calls
+  // ========================================
+  // Empty-param Edit/Write calls are no-ops that will fail validation anyway.
+  // Allow immediately instead of wasting ~8s on Haiku analysis.
+  const toolInput = request.context?.toolInput;
+  if (toolInput && typeof toolInput === 'object' && Object.keys(toolInput).length === 0) {
+    console.error('[Bouncer] ⚡ Fast path: Empty tool parameters (no-op)');
+    const latencyMs = Math.round(performance.now() - startTime);
+
+    const decision: BouncerDecision = {
+      decision: 'allow',
+      confidence: 95,
+      reasoning: 'Empty tool parameters - operation is a no-op with no side effects.',
+      threatLevel: 'low'
+    };
+
+    logBouncerDecision(
+      operation,
+      decision.decision,
+      decision.confidence,
+      decision.reasoning,
+      { context: request.context, threatLevel: decision.threatLevel, layer: 'pattern-noop', latencyMs }
+    );
+
+    return decision;
+  }
+
   // ========================================
   // LAYER 1: Pattern-Based Fast Path (< 5ms)
   // ========================================

package/server/mcp/security-audit.ts

@@ -10,8 +10,8 @@
 import { appendFileSync, existsSync, mkdirSync, } from 'node:fs';
 import { join } from 'node:path';
 
-// Default log directory inside .mstro/ sibling directory
-const DEFAULT_LOG_DIR = './.mstro/logs/security';
+// Default log subdirectory inside .mstro/
+const DEFAULT_LOG_SUBDIR = '.mstro/logs';
 
 export type BouncerLayer = 'pattern-critical' | 'pattern-safe' | 'pattern-default' | 'haiku-ai' | 'ai-disabled' | 'ai-error';
 
@@ -33,7 +33,8 @@ export interface AuditLogEntry {
 export class SecurityAuditLogger {
   private logFile: string;
 
-  constructor(logDir: string = DEFAULT_LOG_DIR) {
+  constructor(workingDir?: string) {
+    const logDir = join(workingDir || process.cwd(), DEFAULT_LOG_SUBDIR);
     this.logFile = join(logDir, 'bouncer-audit.jsonl');
 
     // Ensure log directory exists
@@ -88,12 +89,14 @@ export class SecurityAuditLogger {
 
 }
 
-// Singleton instance
+// Singleton instance (keyed by workingDir to support multiple projects)
 let auditLogger: SecurityAuditLogger | null = null;
+let auditLoggerWorkingDir: string | undefined;
 
-export function getAuditLogger(): SecurityAuditLogger {
-  if (!auditLogger) {
-    auditLogger = new SecurityAuditLogger();
+export function getAuditLogger(workingDir?: string): SecurityAuditLogger {
+  if (!auditLogger || (workingDir && workingDir !== auditLoggerWorkingDir)) {
+    auditLogger = new SecurityAuditLogger(workingDir);
+    auditLoggerWorkingDir = workingDir;
   }
   return auditLogger;
 }
@@ -113,7 +116,8 @@ export function logBouncerDecision(
   const validDecisions = ['allow', 'deny', 'warn_allow'];
   const normalizedDecision = validDecisions.includes(safeDecision) ? safeDecision : 'deny';
 
-  const logger = getAuditLogger();
+  const workingDir = metadata?.context?.workingDirectory;
+  const logger = getAuditLogger(workingDir);
   logger.logDecision(operation, normalizedDecision as 'allow' | 'deny' | 'warn_allow', confidence, reasoning, metadata);
 
   // Also log to console for real-time monitoring

package/server/mcp/security-patterns.ts

@@ -125,6 +125,9 @@ export const SAFE_OPERATIONS: SecurityPattern[] = [
   // Write/Edit to temp directories - ephemeral, low risk
   { pattern: /^(Write|Edit):\s*\/tmp\//i },
   { pattern: /^(Write|Edit):\s*\/var\/tmp\//i },
+
+  // Side-effect-free tools - no dangerous operations possible
+  { pattern: /^(ExitPlanMode|EnterPlanMode|TodoWrite|AskUserQuestion):/i },
 ];
 
 /**
@@ -201,8 +204,11 @@ export function requiresAIReview(operation: string): boolean {
     return !SAFE_RM_PATTERNS.some(p => p.test(operation));
   }
 
-  if (/\$\{.*\}|\$\(.*\)/.test(operation) || /\*\*?/.test(operation)) return true;
-  if (/^Bash:\s*\.\//.test(operation)) return true;
+  // Variable expansion and glob patterns are only concerning in Bash commands
+  if (/^Bash:/.test(operation)) {
+    if (/\$\{.*\}|\$\(.*\)/.test(operation) || /\*\*?/.test(operation)) return true;
+    if (/^Bash:\s*\.\//.test(operation)) return true;
+  }
 
   return false;
 }

package/server/routes/improvise.ts

@@ -15,20 +15,20 @@ export function createImproviseRoutes(workingDir: string) {
 
   routes.get('/sessions', async (c) => {
     try {
-      const sessionsDir = join(workingDir, '.mstro', 'improvise')
+      const sessionsDir = join(workingDir, '.mstro', 'history')
       const { readdirSync, existsSync, readFileSync } = await import('node:fs')
 
       if (!existsSync(sessionsDir)) {
         return c.json({ sessions: [] })
       }
 
-      // Look for history-*.json files in the improvise directory
+      // Look for *.json files in the history directory
       const historyFiles = readdirSync(sessionsDir)
-        .filter((name: string) => name.startsWith('history-') && name.endsWith('.json'))
+        .filter((name: string) => name.endsWith('.json'))
         .sort((a: string, b: string) => {
           // Sort by timestamp in filename (newer first)
-          const timestampA = parseInt(a.replace('history-', '').replace('.json', ''), 10)
-          const timestampB = parseInt(b.replace('history-', '').replace('.json', ''), 10)
+          const timestampA = parseInt(a.replace('.json', ''), 10)
+          const timestampB = parseInt(b.replace('.json', ''), 10)
           return timestampB - timestampA
         })
 
@@ -64,7 +64,7 @@ export function createImproviseRoutes(workingDir: string) {
       const { sessionId } = c.req.param()
       // Extract timestamp from sessionId (e.g., "improv-1234567890" -> "1234567890")
       const timestamp = sessionId.replace('improv-', '')
-      const historyPath = join(workingDir, '.mstro', 'improvise', `history-${timestamp}.json`)
+      const historyPath = join(workingDir, '.mstro', 'history', `${timestamp}.json`)
       const { existsSync, readFileSync } = await import('node:fs')
 
       if (!existsSync(historyPath)) {

package/server/services/analytics.ts

@@ -109,11 +109,15 @@ export async function initAnalytics(): Promise<void> {
   }
 
   client = new PostHog(analyticsConfig.posthogKey, {
-    host: analyticsConfig.posthogHost,
-    // Flush events every 10 seconds or 20 events
+    // Route through platform server proxy (like web/ does) to avoid
+    // direct PostHog DNS lookups and ad-blocker/firewall issues
+    host: `${PLATFORM_URL}/a`,
     flushAt: 20,
     flushInterval: 10000,
   })
+
+  // Silently swallow analytics errors — never surface to user terminal
+  client.on('error', () => {})
 }
 
 /**
@@ -122,7 +126,11 @@ export async function initAnalytics(): Promise<void> {
  */
 export async function shutdownAnalytics(): Promise<void> {
   if (client) {
-    await client.shutdown()
+    try {
+      await client.shutdown()
+    } catch {
+      // Ignore shutdown errors (network may be unavailable)
+    }
     client = null
   }
 }
@@ -263,6 +271,8 @@ export const AnalyticsEvents = {
   IMPROVISE_MOVEMENT_ERROR: 'improvise_movement_error',
   IMPROVISE_SESSION_ENDED: 'improvise_session_ended',
   IMPROVISE_ABORTED: 'improvise_aborted',
+  IMPROVISE_TOOL_TIMEOUT: 'improvise_tool_timeout',
+  IMPROVISE_AUTO_RETRY: 'improvise_auto_retry',
 
   // Terminal events
   TERMINAL_SESSION_CREATED: 'terminal_session_created',

package/server/services/platform.test.ts

@@ -31,10 +31,6 @@ const mockClientId = {
   getClientId: vi.fn(),
 }
 
-const mockTmux = {
-  isTmuxAvailable: vi.fn(),
-}
-
 // Mock fetch globally
 global.fetch = vi.fn()
 
@@ -115,7 +111,6 @@ vi.mock('fs', () => mockFs)
 vi.mock('os', () => mockOs)
 vi.mock('path', () => mockPath)
 vi.mock('./client-id.js', () => mockClientId)
-vi.mock('./terminal/tmux-manager.js', () => mockTmux)
 
 // Mock undici WebSocket for Node 18-20 compatibility
 vi.mock('undici', () => ({
@@ -150,8 +145,6 @@ describe('Platform Connection Service', () => {
     mockOs.type.mockReturnValue('Linux')
     mockOs.arch.mockReturnValue('x64')
     mockClientId.getClientId.mockReturnValue('test-client-id-123')
-    mockTmux.isTmuxAvailable.mockReturnValue(true)
-
     // Mock process.version
     Object.defineProperty(process, 'version', {
       value: 'v22.0.0',
@@ -410,14 +403,11 @@ describe('Platform Connection Service', () => {
           })
         )
 
-        mockTmux.isTmuxAvailable.mockReturnValue(true)
-
         const connection = new PlatformConnection('/test/dir')
         connection.connect()
 
         const wsUrl = WebSocketConstructor.mock.calls[0][0]
         expect(wsUrl).toContain('capabilities=')
-        expect(wsUrl).toContain('tmux')
       })
 
       it('should use custom platform URL when provided', () => {

package/server/services/platform.ts

@@ -20,7 +20,6 @@ import { basename, join } from 'node:path'
 import { AnalyticsEvents, trackEvent } from './analytics.js'
 import { getClientId } from './client-id.js'
 import { captureException } from './sentry.js'
-import { isTmuxAvailable } from './terminal/tmux-manager.js'
 
 const MSTRO_DIR = join(homedir(), '.mstro')
 const CREDENTIALS_FILE = join(MSTRO_DIR, 'credentials.json')
@@ -242,9 +241,6 @@ export class PlatformConnection {
       return
     }
 
-    // Check for tmux availability (for persistent terminals)
-    const hasTmux = isTmuxAvailable()
-
     // Build URL params WITHOUT the auth token — token is sent post-connection
     // to avoid leaking it in proxy logs, browser history, and server access logs
     const params = new URLSearchParams({
@@ -256,7 +252,7 @@ export class PlatformConnection {
       nodeVersion,
       osType,
       cpuArch,
-      capabilities: JSON.stringify({ tmux: hasTmux })
+      capabilities: JSON.stringify({})
     })
 
     const wsUrl = `${this.platformUrl.replace(/^http/, 'ws')}/ws/client?${params}`
@@ -284,7 +280,7 @@ export class PlatformConnection {
 
     this.ws.onopen = () => {
       clearTimeout(connectionTimeout)
-      console.log(`🌐 Connected to platform`)
+      // Platform WebSocket open — auth will follow
 
       // Send auth token as first message instead of URL param
       this.ws!.send(JSON.stringify({ type: 'auth', token: authToken }))
@@ -332,7 +328,7 @@ export class PlatformConnection {
           return
         }
 
-        console.log('Disconnected from platform, reconnecting...')
+        console.log('Disconnected, reconnecting...')
         this.callbacks.onDisconnected?.()
         trackEvent(AnalyticsEvents.PLATFORM_DISCONNECTED)
         this.scheduleReconnect()
@@ -349,20 +345,18 @@ export class PlatformConnection {
       case 'paired':
         this.isConnected = true
         this.connectionId = message.connectionId
-        console.log(`⚡ Connected to mstro.app!`)
+        // Connection status printed by onConnected callback
         // Start heartbeat to keep server-side TTL refreshed
         this.startHeartbeat()
         this.callbacks.onConnected?.(message.connectionId)
         break
 
       case 'web_connected':
-        console.log('🔗 Web client connected')
         this.callbacks.onWebConnected?.()
         trackEvent(AnalyticsEvents.WEB_CLIENT_CONNECTED)
         break
 
       case 'web_disconnected':
-        console.log('🔗 Web client disconnected')
         this.callbacks.onWebDisconnected?.()
         trackEvent(AnalyticsEvents.WEB_CLIENT_DISCONNECTED)
         break

package/server/services/sandbox-utils.ts

@@ -0,0 +1,78 @@
+// Copyright (c) 2025-present Mstro, Inc. All rights reserved.
+// Licensed under the MIT License. See LICENSE file for details.
+
+/**
+ * Sandbox Utilities
+ *
+ * Environment sanitization for sandboxed shared sessions.
+ * Used by both PTY manager (terminal) and Claude invoker (prompts)
+ * to restrict shared users to the project directory.
+ */
+
+/** Env var prefixes that may contain secrets or grant access outside the project */
+const BLOCKED_PREFIXES = [
+  'AWS_',
+  'GITHUB_',
+  'GH_',
+  'NPM_',
+  'DOCKER_',
+  'SSH_',
+  'GPG_',
+  'AZURE_',
+  'GCP_',
+  'GOOGLE_',
+  'OPENAI_',
+  'ANTHROPIC_',
+  'STRIPE_',
+  'TWILIO_',
+  'SENDGRID_',
+  'DATADOG_',
+  'SENTRY_',
+  'SLACK_',
+  'DISCORD_',
+];
+
+/** Specific env vars that may contain secrets or sensitive paths */
+const BLOCKED_KEYS = new Set([
+  'HISTFILE',
+  'LESSHISTFILE',
+  'MYSQL_PWD',
+  'PGPASSWORD',
+  'PGPASSFILE',
+  'REDIS_URL',
+  'DATABASE_URL',
+  'MONGO_URI',
+  'MONGODB_URI',
+  'SECRET_KEY',
+  'API_KEY',
+  'API_SECRET',
+  'ACCESS_TOKEN',
+  'REFRESH_TOKEN',
+  'PRIVATE_KEY',
+  'JWT_SECRET',
+]);
+
+/**
+ * Create a sanitized environment for sandboxed execution.
+ * Strips sensitive env vars and sets HOME to the project directory.
+ */
+export function sanitizeEnvForSandbox(
+  env: NodeJS.ProcessEnv,
+  workingDir: string
+): Record<string, string> {
+  const result: Record<string, string> = {};
+
+  for (const [key, value] of Object.entries(env)) {
+    if (!value) continue;
+    if (BLOCKED_KEYS.has(key)) continue;
+    if (BLOCKED_PREFIXES.some(p => key.startsWith(p))) continue;
+    result[key] = value;
+  }
+
+  // Override HOME to project directory so `cd ~` stays sandboxed
+  result.HOME = workingDir;
+  // Marker so scripts can detect sandboxed execution
+  result.MSTRO_SANDBOXED = '1';
+
+  return result;
+}

package/server/services/settings.ts

@@ -26,6 +26,8 @@ export interface MstroSettings {
    * - Any other string is passed as --model <value>
    */
   model: string
+  /** Per-repo preferred PR base branch, keyed by normalized remote URL */
+  prBaseBranches?: Record<string, string>
 }
 
 const DEFAULT_SETTINGS: MstroSettings = {
@@ -87,3 +89,26 @@ export function setModel(model: string): void {
   settings.model = model
   saveSettings(settings)
 }
+
+/** Normalize a remote URL into a stable key (e.g. "github.com/owner/repo") */
+function normalizeRemoteUrl(remoteUrl: string): string {
+  return remoteUrl
+    .replace(/^(https?:\/\/|git@)/, '')
+    .replace(/\.git$/, '')
+    .replace(/:/, '/')
+}
+
+/** Get the preferred PR base branch for a repo */
+export function getPrBaseBranch(remoteUrl: string): string | null {
+  const settings = getSettings()
+  const key = normalizeRemoteUrl(remoteUrl)
+  return settings.prBaseBranches?.[key] ?? null
+}
+
+/** Save the preferred PR base branch for a repo */
+export function setPrBaseBranch(remoteUrl: string, branch: string): void {
+  const settings = getSettings()
+  if (!settings.prBaseBranches) settings.prBaseBranches = {}
+  settings.prBaseBranches[normalizeRemoteUrl(remoteUrl)] = branch
+  saveSettings(settings)
+}

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
@@ -156,41 +147,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 +169,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,28 +199,30 @@ 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,
@@ -271,9 +230,9 @@ export class PTYManager extends EventEmitter {
       };
       this.terminals.set(terminalId, session);
 
-      // Handle data output - store in scrollback and emit
+      // Handle data output
       ptyProcess.onData((data: string) => {
-        this.addToScrollback(session, data);
+        session.lastActivityAt = Date.now();
         this.emit('output', terminalId, data);
       });
 
@@ -381,76 +340,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