mstro-app 0.1.54 → 0.1.57

package/server/cli/improvisation-session-manager.ts

@@ -11,6 +11,7 @@
 import { EventEmitter } from 'node:events';
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
+import { AnalyticsEvents, trackEvent } from '../services/analytics.js';
 import { HeadlessRunner } from './headless/index.js';
 
 export interface ImprovisationOptions {
@@ -20,6 +21,8 @@ export interface ImprovisationOptions {
   maxSessions: number;
   verbose: boolean;
   noColor: boolean;
+  /** Claude model for main execution (e.g., 'opus', 'sonnet'). 'default' = no --model flag. */
+  model?: string;
 }
 
 // File attachment for multimodal prompts (images)
@@ -82,12 +85,17 @@ export class ImprovisationSessionManager extends EventEmitter {
   private isResumedSession: boolean = false; // Track if this is a resumed historical session
   accumulatedKnowledge: string = '';
 
+  /** Whether a prompt is currently executing */
+  private _isExecuting: boolean = false;
+  /** Buffered events during current execution, for replay on reconnect */
+  private executionEventLog: Array<{ type: string; data: any; timestamp: number }> = [];
+
   /**
    * Resume from a historical session.
    * Creates a new session manager that continues the conversation from a previous session.
    * The first prompt will include context from the historical session.
    */
-  static resumeFromHistory(workingDir: string, historicalSessionId: string): ImprovisationSessionManager {
+  static resumeFromHistory(workingDir: string, historicalSessionId: string, overrides?: Partial<ImprovisationOptions>): ImprovisationSessionManager {
     const improviseDir = join(workingDir, '.mstro', 'improvise');
 
     // Extract timestamp from session ID (format: improv-1234567890123 or just 1234567890123)
@@ -105,7 +113,8 @@ export class ImprovisationSessionManager extends EventEmitter {
     // This ensures we continue writing to the same history file
     const manager = new ImprovisationSessionManager({
       workingDir,
-      sessionId: historyData.sessionId
+      sessionId: historyData.sessionId,
+      ...overrides,
     });
 
     // Load the historical data
@@ -138,7 +147,8 @@ export class ImprovisationSessionManager extends EventEmitter {
       tokenBudgetThreshold: options.tokenBudgetThreshold || 170000,
       maxSessions: options.maxSessions || 10,
       verbose: options.verbose || false,
-      noColor: options.noColor || false
+      noColor: options.noColor || false,
+      model: options.model,
     };
 
     this.sessionId = this.options.sessionId;
@@ -218,11 +228,31 @@ export class ImprovisationSessionManager extends EventEmitter {
   async executePrompt(userPrompt: string, attachments?: FileAttachment[]): Promise<MovementRecord> {
     const _execStart = Date.now();
 
+    // Start execution event log for reconnect replay
+    this._isExecuting = true;
+    this.executionEventLog = [];
+
     this.emit('onMovementStart', this.history.movements.length + 1, userPrompt);
+    trackEvent(AnalyticsEvents.IMPROVISE_PROMPT_RECEIVED, {
+      prompt_length: userPrompt.length,
+      has_attachments: !!(attachments && attachments.length > 0),
+      attachment_count: attachments?.length || 0,
+      image_attachment_count: attachments?.filter(a => a.isImage).length || 0,
+      sequence_number: this.history.movements.length + 1,
+      is_resumed_session: this.isResumedSession,
+      model: this.options.model || 'default',
+    });
 
     try {
       const sequenceNumber = this.history.movements.length + 1;
 
+      // Log the movement start event
+      this.executionEventLog.push({
+        type: 'movementStart',
+        data: { sequenceNumber, prompt: userPrompt, timestamp: Date.now() },
+        timestamp: Date.now(),
+      });
+
       // DEBUG: Removed "Executing prompt..." message - it serves no purpose now that system responds fast
       // this.queueOutput(`\n🎵 Executing prompt...\n`);
       // this.flushOutputQueue();
@@ -245,19 +275,23 @@ export class ImprovisationSessionManager extends EventEmitter {
         maxSessions: this.options.maxSessions,
         verbose: this.options.verbose,
         noColor: this.options.noColor,
+        model: this.options.model,
         improvisationMode: true,
         movementNumber: sequenceNumber,
         continueSession: !this.isFirstPrompt, // Used as fallback only if claudeSessionId is missing
         claudeSessionId: this.claudeSessionId, // Resume specific session for tab isolation
         outputCallback: (text: string) => {
+          this.executionEventLog.push({ type: 'output', data: { text, timestamp: Date.now() }, timestamp: Date.now() });
           this.queueOutput(text);
           this.flushOutputQueue();
         },
         thinkingCallback: (text: string) => {
+          this.executionEventLog.push({ type: 'thinking', data: { text }, timestamp: Date.now() });
           this.emit('onThinking', text);
           this.flushOutputQueue();
         },
         toolUseCallback: (event) => {
+          this.executionEventLog.push({ type: 'toolUse', data: { ...event, timestamp: Date.now() }, timestamp: Date.now() });
           this.emit('onToolUse', event);
           this.flushOutputQueue();
         },
@@ -334,14 +368,32 @@ export class ImprovisationSessionManager extends EventEmitter {
       // this.queueOutput(`\n✓ Complete (tokens: ${result.totalTokens.toLocaleString()})\n`);
       // this.flushOutputQueue();
 
+      this._isExecuting = false;
+      this.executionEventLog = [];
+
       this.emit('onMovementComplete', movement);
+      trackEvent(AnalyticsEvents.IMPROVISE_MOVEMENT_COMPLETED, {
+        tokens_used: movement.tokensUsed,
+        duration_ms: Date.now() - _execStart,
+        sequence_number: sequenceNumber,
+        tool_count: result.toolUseHistory?.length || 0,
+        model: this.options.model || 'default',
+      });
       this.emit('onSessionUpdate', this.getHistory());
 
       return movement;
 
     } catch (error: any) {
+      this._isExecuting = false;
+      this.executionEventLog = [];
       this.currentRunner = null;
       this.emit('onMovementError', error);
+      trackEvent(AnalyticsEvents.IMPROVISE_MOVEMENT_ERROR, {
+        error_message: error.message?.slice(0, 200),
+        sequence_number: this.history.movements.length + 1,
+        duration_ms: Date.now() - _execStart,
+        model: this.options.model || 'default',
+      });
       this.queueOutput(`\n❌ Error: ${error.message}\n`);
       this.flushOutputQueue();
       throw error;
@@ -508,12 +560,27 @@ export class ImprovisationSessionManager extends EventEmitter {
     };
   }
 
+  /**
+   * Whether a prompt is currently executing
+   */
+  get isExecuting(): boolean {
+    return this._isExecuting;
+  }
+
+  /**
+   * Get buffered execution events for replay on reconnect.
+   * Only meaningful while isExecuting is true.
+   */
+  getExecutionEventLog(): Array<{ type: string; data: any; timestamp: number }> {
+    return this.executionEventLog;
+  }
+
   /**
    * Start a new session with fresh context
    * Creates a completely new session manager with isFirstPrompt=true and no claudeSessionId,
    * ensuring the next prompt starts a fresh Claude conversation (proper tab isolation)
    */
-  startNewSession(): ImprovisationSessionManager {
+  startNewSession(overrides?: Partial<ImprovisationOptions>): ImprovisationSessionManager {
     // Save current session
     this.saveHistory();
 
@@ -523,7 +590,8 @@ export class ImprovisationSessionManager extends EventEmitter {
     // This means the first prompt will start a completely fresh Claude conversation
     const newSession = new ImprovisationSessionManager({
       ...this.options,
-      sessionId: `improv-${Date.now()}`
+      sessionId: `improv-${Date.now()}`,
+      ...overrides,
     });
 
     return newSession;

package/server/index.ts

@@ -348,7 +348,10 @@ async function startServer() {
   console.log(`Framework: Hono`)
 
   // Track server started event
-  trackEvent(AnalyticsEvents.SERVER_STARTED, { port: PORT })
+  trackEvent(AnalyticsEvents.SERVER_STARTED, {
+    port: PORT,
+    working_dir_basename: basename(WORKING_DIR),
+  })
 
   // Create a virtual WebSocket context for platform relay
   // This allows messages from the web (via platform) to use the same wsHandler

package/server/mcp/bouncer-integration.ts

@@ -33,6 +33,7 @@
  */
 
 import { spawn } from 'node:child_process';
+import { AnalyticsEvents, trackEvent } from '../services/analytics.js';
 import { captureException } from '../services/sentry.js';
 import {
   CRITICAL_THREATS,
@@ -275,6 +276,13 @@ export async function reviewOperation(request: BouncerReviewRequest): Promise<Bo
       decision.reasoning,
       { context: request.context, threatLevel: decision.threatLevel, layer: 'pattern-safe', latencyMs }
     );
+    trackEvent(AnalyticsEvents.BOUNCER_TOOL_ALLOWED, {
+      layer: 'pattern-safe',
+      operation_length: operation.length,
+      threat_level: 'low',
+      confidence: 95,
+      latency_ms: latencyMs,
+    });
 
     return decision;
   }
@@ -302,6 +310,13 @@ export async function reviewOperation(request: BouncerReviewRequest): Promise<Bo
       decision.reasoning,
       { context: request.context, threatLevel: decision.threatLevel, layer: 'pattern-critical', latencyMs }
     );
+    trackEvent(AnalyticsEvents.BOUNCER_TOOL_DENIED, {
+      layer: 'pattern-critical',
+      operation_length: operation.length,
+      threat_level: 'critical',
+      confidence: 99,
+      latency_ms: latencyMs,
+    });
 
     return decision;
   }
@@ -330,6 +345,13 @@ export async function reviewOperation(request: BouncerReviewRequest): Promise<Bo
       decision.reasoning,
       { context: request.context, threatLevel: decision.threatLevel, layer: 'pattern-default', latencyMs }
     );
+    trackEvent(AnalyticsEvents.BOUNCER_TOOL_ALLOWED, {
+      layer: 'pattern-default',
+      operation_length: operation.length,
+      threat_level: 'low',
+      confidence: 80,
+      latency_ms: latencyMs,
+    });
 
     return decision;
   }
@@ -360,6 +382,9 @@ export async function reviewOperation(request: BouncerReviewRequest): Promise<Bo
   }
 
   console.error('[Bouncer] 🤖 Invoking Haiku for AI analysis...');
+  trackEvent(AnalyticsEvents.BOUNCER_HAIKU_REVIEW, {
+    operation_length: operation.length,
+  });
 
   // Get Claude command and working directory from context or use defaults
   const claudeCommand = process.env.CLAUDE_COMMAND || 'claude';
@@ -378,6 +403,13 @@ export async function reviewOperation(request: BouncerReviewRequest): Promise<Bo
       decision.reasoning,
       { context: request.context, threatLevel: decision.threatLevel, layer: 'haiku-ai', latencyMs }
     );
+    trackEvent(decision.decision === 'deny' ? AnalyticsEvents.BOUNCER_TOOL_DENIED : AnalyticsEvents.BOUNCER_TOOL_ALLOWED, {
+      layer: 'haiku-ai',
+      operation_length: operation.length,
+      threat_level: decision.threatLevel,
+      confidence: decision.confidence,
+      latency_ms: latencyMs,
+    });
 
     return decision;
 

package/server/services/platform.ts

@@ -17,6 +17,7 @@
 import { existsSync, readFileSync, writeFileSync } from 'node:fs'
 import { arch, homedir, hostname, type } from 'node:os'
 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'
@@ -93,15 +94,13 @@ export function getMachineIdentifier(): string {
   return `${machineHostname} @ node-${nodeVersion} ${osType} (${cpuArch})`
 }
 
-// Get WebSocket class - use global if available (Bun, Node 21+), otherwise import from undici (Node 18-20)
+// Get WebSocket class - use global if available (Bun, Node 21+), otherwise use ws (Node 18-20)
 let WebSocketImpl: typeof WebSocket
 if (typeof WebSocket !== 'undefined') {
   WebSocketImpl = WebSocket
 } else {
-  // Node 18-20: use undici's WebSocket (bundled with Node.js but not typed)
-  // @ts-expect-error undici is bundled with Node.js but lacks type declarations
-  const { WebSocket: UndiciWS } = await import('undici')
-  WebSocketImpl = UndiciWS as unknown as typeof WebSocket
+  const { default: WS } = await import('ws')
+  WebSocketImpl = WS as unknown as typeof WebSocket
 }
 
 const DEFAULT_PLATFORM_URL = process.env.PLATFORM_URL || 'https://api.mstro.app'
@@ -295,6 +294,7 @@ export class PlatformConnection {
       // Start periodic refresh checks
       this.startTokenRefreshCheck()
       this.reconnectAttempts = 0
+      trackEvent(AnalyticsEvents.PLATFORM_CONNECTED)
     }
 
     this.ws.onmessage = (event) => {
@@ -334,6 +334,7 @@ export class PlatformConnection {
 
         console.log('Disconnected from platform, reconnecting...')
         this.callbacks.onDisconnected?.()
+        trackEvent(AnalyticsEvents.PLATFORM_DISCONNECTED)
         this.scheduleReconnect()
       }
     }
@@ -357,11 +358,13 @@ export class PlatformConnection {
       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
 
       case 'pong':

package/server/services/settings.ts

@@ -0,0 +1,89 @@
+// Copyright (c) 2025-present Mstro, Inc. All rights reserved.
+// Licensed under the MIT License. See LICENSE file for details.
+
+/**
+ * Settings Service
+ *
+ * Manages persistent machine-wide settings stored in ~/.mstro/settings.json
+ *
+ * Structure:
+ * {
+ *   "model": "opus"
+ * }
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+
+const MSTRO_DIR = join(homedir(), '.mstro')
+const SETTINGS_FILE = join(MSTRO_DIR, 'settings.json')
+
+export interface MstroSettings {
+  /**
+   * Claude model to use for main execution.
+   * - 'default' means don't pass --model (let Claude Code decide)
+   * - Any other string is passed as --model <value>
+   */
+  model: string
+}
+
+const DEFAULT_SETTINGS: MstroSettings = {
+  model: 'opus'
+}
+
+/**
+ * Ensure the ~/.mstro directory exists
+ */
+function ensureMstroDir(): void {
+  if (!existsSync(MSTRO_DIR)) {
+    mkdirSync(MSTRO_DIR, { recursive: true, mode: 0o700 })
+  }
+}
+
+/**
+ * Get current settings, merged with defaults for any missing fields
+ */
+export function getSettings(): MstroSettings {
+  if (!existsSync(SETTINGS_FILE)) {
+    return { ...DEFAULT_SETTINGS }
+  }
+
+  try {
+    const content = readFileSync(SETTINGS_FILE, 'utf-8')
+    const stored = JSON.parse(content)
+    return {
+      ...DEFAULT_SETTINGS,
+      ...stored,
+    }
+  } catch (err) {
+    console.warn('Failed to read settings file, using defaults:', err)
+    return { ...DEFAULT_SETTINGS }
+  }
+}
+
+/**
+ * Save full settings to disk
+ */
+export function saveSettings(settings: MstroSettings): void {
+  ensureMstroDir()
+  writeFileSync(SETTINGS_FILE, JSON.stringify(settings, null, 2), {
+    mode: 0o600
+  })
+}
+
+/**
+ * Get the current model setting
+ */
+export function getModel(): string {
+  return getSettings().model
+}
+
+/**
+ * Update just the model setting
+ */
+export function setModel(model: string): void {
+  const settings = getSettings()
+  settings.model = model
+  saveSettings(settings)
+}

package/server/services/websocket/autocomplete.ts

@@ -46,22 +46,26 @@ function compareAutocompleteResults(a: ScoredMatch, b: ScoredMatch): number {
 function extractFuseMatchIndices(
   result: FuseResult<FileMetadata>
 ): Array<[number, number]> {
-  const matchedIndices: Array<[number, number]> = [];
-  if (!result.matches) return matchedIndices;
-
-  for (const match of result.matches) {
-    if (!match.indices) continue;
-    for (const [start, end] of match.indices) {
-      if (match.key === 'fileName') {
-        const filenameStart = result.item.relativePath.lastIndexOf('/') + 1;
-        matchedIndices.push([filenameStart + start, filenameStart + end + 1]);
-      } else {
-        matchedIndices.push([start, end + 1]);
-      }
-    }
+  if (!result.matches) return [];
+
+  // Prefer fileName matches (95% weight) over relativePath to avoid duplicates.
+  // Using both keys produces overlapping index ranges that garble the display.
+  const fileNameMatch = result.matches.find(m => m.key === 'fileName');
+  if (fileNameMatch?.indices) {
+    const filenameStart = result.item.relativePath.lastIndexOf('/') + 1;
+    return fileNameMatch.indices.map(([start, end]) =>
+      [filenameStart + start, filenameStart + end + 1] as [number, number]
+    );
+  }
+
+  const pathMatch = result.matches.find(m => m.key === 'relativePath');
+  if (pathMatch?.indices) {
+    return pathMatch.indices.map(([start, end]) =>
+      [start, end + 1] as [number, number]
+    );
   }
 
-  return matchedIndices;
+  return [];
 }
 
 function scoreFileMatch(