mstro-app 0.2.0 → 0.3.1

package/server/services/websocket/settings-handlers.ts

@@ -0,0 +1,150 @@
+// Copyright (c) 2025-present Mstro, Inc. All rights reserved.
+// Licensed under the MIT License. See LICENSE file for details.
+
+import { spawn } from 'node:child_process';
+import { existsSync, mkdirSync, unlinkSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { getSettings, setModel } from '../settings.js';
+import type { HandlerContext } from './handler-context.js';
+import type { WebSocketMessage, WSContext } from './types.js';
+
+export function handleGetSettings(ctx: HandlerContext, ws: WSContext): void {
+  ctx.send(ws, { type: 'settings', data: getSettings() });
+}
+
+export function handleUpdateSettings(ctx: HandlerContext, _ws: WSContext, msg: WebSocketMessage): void {
+  if (msg.data?.model !== undefined) {
+    setModel(msg.data.model);
+  }
+  ctx.broadcastToAll({ type: 'settingsUpdated', data: getSettings() });
+}
+
+export async function generateNotificationSummary(
+  ctx: HandlerContext,
+  ws: WSContext,
+  tabId: string,
+  userPrompt: string,
+  output: string,
+  workingDir: string
+): Promise<void> {
+  try {
+    const tempDir = join(workingDir, '.mstro', 'tmp');
+    if (!existsSync(tempDir)) {
+      mkdirSync(tempDir, { recursive: true });
+    }
+
+    let truncatedOutput = output;
+    if (output.length > 4000) {
+      const firstPart = output.slice(0, 2000);
+      const lastPart = output.slice(-1500);
+      truncatedOutput = `${firstPart}\n\n... [output truncated] ...\n\n${lastPart}`;
+    }
+
+    const summaryPrompt = `You are generating a SHORT browser notification summary for a completed task.
+The user ran a task and wants a brief notification to remind them what happened.
+
+USER'S ORIGINAL PROMPT:
+"${userPrompt}"
+
+TASK OUTPUT (may be truncated):
+${truncatedOutput}
+
+Generate a notification summary following these rules:
+1. Maximum 100 characters (this is a browser notification)
+2. Focus on the OUTCOME, not the process
+3. Be specific about what was accomplished
+4. Use past tense (e.g., "Fixed bug in auth.ts", "Added 3 new tests")
+5. If there was an error, mention it briefly
+6. No emojis, no markdown, just plain text
+
+Respond with ONLY the summary text, nothing else.`;
+
+    const promptFile = join(tempDir, `notif-summary-${Date.now()}.txt`);
+    writeFileSync(promptFile, summaryPrompt);
+
+    const systemPrompt = 'You are a notification summary assistant. Respond with only the summary text, no preamble or explanation.';
+
+    const args = [
+      '--print',
+      '--model', 'haiku',
+      '--system-prompt', systemPrompt,
+      promptFile
+    ];
+
+    const claude = spawn('claude', args, {
+      cwd: workingDir,
+      stdio: ['ignore', 'pipe', 'pipe']
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    claude.stdout?.on('data', (data: Buffer) => {
+      stdout += data.toString();
+    });
+
+    claude.stderr?.on('data', (data: Buffer) => {
+      stderr += data.toString();
+    });
+
+    claude.on('close', (code: number | null) => {
+      try {
+        unlinkSync(promptFile);
+      } catch {
+        // Ignore cleanup errors
+      }
+
+      let summary: string;
+      if (code === 0 && stdout.trim()) {
+        summary = stdout.trim().slice(0, 150);
+      } else {
+        console.error('[WebSocketImproviseHandler] Claude error:', stderr || 'Unknown error');
+        summary = createFallbackSummary(userPrompt);
+      }
+
+      ctx.send(ws, {
+        type: 'notificationSummary',
+        tabId,
+        data: { summary }
+      });
+    });
+
+    claude.on('error', (err: Error) => {
+      console.error('[WebSocketImproviseHandler] Failed to spawn Claude:', err);
+      const summary = createFallbackSummary(userPrompt);
+      ctx.send(ws, {
+        type: 'notificationSummary',
+        tabId,
+        data: { summary }
+      });
+    });
+
+    // Timeout after 10 seconds
+    setTimeout(() => {
+      claude.kill();
+      const summary = createFallbackSummary(userPrompt);
+      ctx.send(ws, {
+        type: 'notificationSummary',
+        tabId,
+        data: { summary }
+      });
+    }, 10000);
+
+  } catch (error) {
+    console.error('[WebSocketImproviseHandler] Error generating summary:', error);
+    const summary = createFallbackSummary(userPrompt);
+    ctx.send(ws, {
+      type: 'notificationSummary',
+      tabId,
+      data: { summary }
+    });
+  }
+}
+
+function createFallbackSummary(userPrompt: string): string {
+  const truncated = userPrompt.slice(0, 60);
+  if (userPrompt.length > 60) {
+    return `Completed: "${truncated}..."`;
+  }
+  return `Completed: "${truncated}"`;
+}

package/server/services/websocket/tab-handlers.ts

@@ -0,0 +1,150 @@
+// Copyright (c) 2025-present Mstro, Inc. All rights reserved.
+// Licensed under the MIT License. See LICENSE file for details.
+
+import { ImprovisationSessionManager } from '../../cli/improvisation-session-manager.js';
+import { getModel } from '../settings.js';
+import type { HandlerContext } from './handler-context.js';
+import { buildOutputHistory, setupSessionListeners } from './session-handlers.js';
+import type { WebSocketMessage, WSContext } from './types.js';
+
+export function handleGetActiveTabs(ctx: HandlerContext, ws: WSContext, workingDir: string): void {
+  const registry = ctx.getRegistry(workingDir);
+  const allTabs = registry.getAllTabs();
+
+  const tabs: Record<string, unknown> = {};
+  for (const [tabId, regTab] of Object.entries(allTabs)) {
+    const session = ctx.sessions.get(regTab.sessionId);
+    if (session) {
+      tabs[tabId] = {
+        tabName: regTab.tabName,
+        createdAt: regTab.createdAt,
+        order: regTab.order,
+        hasUnviewedCompletion: regTab.hasUnviewedCompletion,
+        sessionInfo: session.getSessionInfo(),
+        isExecuting: session.isExecuting,
+        outputHistory: buildOutputHistory(session),
+        executionEvents: session.isExecuting ? session.getExecutionEventLog() : undefined,
+        ...(session.isExecuting && session.executionStartTimestamp ? { executionStartTimestamp: session.executionStartTimestamp } : {}),
+      };
+    } else {
+      tabs[tabId] = {
+        tabName: regTab.tabName,
+        createdAt: regTab.createdAt,
+        order: regTab.order,
+        hasUnviewedCompletion: regTab.hasUnviewedCompletion,
+        sessionId: regTab.sessionId,
+        isExecuting: false,
+        outputHistory: [],
+      };
+    }
+  }
+
+  ctx.send(ws, { type: 'activeTabs', data: { tabs } });
+}
+
+export function handleSyncTabMeta(ctx: HandlerContext, _ws: WSContext, msg: WebSocketMessage, tabId: string, workingDir: string): void {
+  const registry = ctx.getRegistry(workingDir);
+  if (msg.data?.tabName) {
+    registry.updateTabName(tabId, msg.data.tabName);
+    ctx.broadcastToAll({
+      type: 'tabRenamed',
+      data: { tabId, tabName: msg.data.tabName }
+    });
+  }
+}
+
+export function handleSyncPromptText(ctx: HandlerContext, _ws: WSContext, msg: WebSocketMessage, tabId: string): void {
+  if (typeof msg.data?.text !== 'string') return;
+  ctx.broadcastToAll({
+    type: 'promptTextSync',
+    tabId,
+    data: { tabId, text: msg.data.text }
+  });
+}
+
+export function handleRemoveTab(ctx: HandlerContext, _ws: WSContext, tabId: string, workingDir: string): void {
+  const registry = ctx.getRegistry(workingDir);
+  registry.unregisterTab(tabId);
+
+  ctx.broadcastToAll({
+    type: 'tabRemoved',
+    data: { tabId }
+  });
+}
+
+export function handleMarkTabViewed(ctx: HandlerContext, _ws: WSContext, tabId: string, workingDir: string): void {
+  const registry = ctx.getRegistry(workingDir);
+  registry.markTabViewed(tabId);
+
+  ctx.broadcastToAll({
+    type: 'tabViewed',
+    data: { tabId }
+  });
+}
+
+export async function handleCreateTab(ctx: HandlerContext, ws: WSContext, workingDir: string, tabName?: string, optimisticTabId?: string): Promise<void> {
+  const registry = ctx.getRegistry(workingDir);
+
+  const tabId = optimisticTabId || `tab-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+
+  const existingSession = registry.getTabSession(tabId);
+  if (existingSession) {
+    const regTab = registry.getTab(tabId);
+    ctx.broadcastToAll({
+      type: 'tabCreated',
+      data: {
+        tabId,
+        tabName: regTab?.tabName || 'Chat',
+        createdAt: regTab?.createdAt,
+        order: regTab?.order,
+        sessionInfo: ctx.sessions.get(existingSession)?.getSessionInfo(),
+      }
+    });
+    return;
+  }
+
+  const session = new ImprovisationSessionManager({ workingDir, model: getModel() });
+  setupSessionListeners(ctx, session, ws, tabId);
+
+  const sessionId = session.getSessionInfo().sessionId;
+  ctx.sessions.set(sessionId, session);
+
+  const tabMap = ctx.connections.get(ws);
+  if (tabMap) tabMap.set(tabId, sessionId);
+
+  registry.registerTab(tabId, sessionId, tabName);
+  const registeredTab = registry.getTab(tabId);
+
+  ctx.broadcastToAll({
+    type: 'tabCreated',
+    data: {
+      tabId,
+      tabName: registeredTab?.tabName || 'Chat',
+      createdAt: registeredTab?.createdAt,
+      order: registeredTab?.order,
+      sessionInfo: session.getSessionInfo(),
+    }
+  });
+
+  ctx.send(ws, {
+    type: 'tabInitialized',
+    tabId,
+    data: session.getSessionInfo()
+  });
+}
+
+export function handleReorderTabs(ctx: HandlerContext, _ws: WSContext, workingDir: string, tabOrder?: string[]): void {
+  if (!Array.isArray(tabOrder)) return;
+  const registry = ctx.getRegistry(workingDir);
+  registry.reorderTabs(tabOrder);
+
+  const allTabs = registry.getAllTabs();
+  const orderMap = tabOrder
+    .filter((id) => allTabs[id])
+    .map((id) => ({ tabId: id, order: allTabs[id].order }));
+
+  ctx.broadcastToAll({
+    type: 'tabsReordered',
+    data: { tabOrder: orderMap }
+  });
+}

package/server/services/websocket/terminal-handlers.ts

@@ -0,0 +1,277 @@
+// Copyright (c) 2025-present Mstro, Inc. All rights reserved.
+// Licensed under the MIT License. See LICENSE file for details.
+
+import { AnalyticsEvents, trackEvent } from '../analytics.js';
+import { getPTYManager } from '../terminal/pty-manager.js';
+import type { HandlerContext } from './handler-context.js';
+import type { WebSocketMessage, WSContext } from './types.js';
+
+export function handleTerminalMessage(ctx: HandlerContext, ws: WSContext, msg: WebSocketMessage, tabId: string, workingDir: string, permission?: 'control' | 'view'): void {
+  const termId = msg.terminalId || tabId;
+  switch (msg.type) {
+    case 'terminalInit':
+      handleTerminalInit(ctx, ws, termId, workingDir, msg.data?.shell, msg.data?.cols, msg.data?.rows, permission);
+      break;
+    case 'terminalReconnect':
+      handleTerminalReconnect(ctx, ws, termId);
+      break;
+    case 'terminalList':
+      handleTerminalList(ctx, ws);
+      break;
+    case 'terminalInput':
+      handleTerminalInput(ctx, ws, termId, msg.data?.input);
+      break;
+    case 'terminalResize':
+      handleTerminalResize(ctx, termId, msg.data?.cols, msg.data?.rows);
+      break;
+    case 'terminalClose':
+      handleTerminalClose(ctx, ws, termId);
+      break;
+  }
+}
+
+function handleTerminalInit(
+  ctx: HandlerContext,
+  ws: WSContext,
+  terminalId: string,
+  workingDir: string,
+  requestedShell?: string,
+  cols?: number,
+  rows?: number,
+  permission?: 'control' | 'view'
+): void {
+  const ptyManager = getPTYManager();
+
+  if (!ptyManager.isPtyAvailable()) {
+    ctx.send(ws, {
+      type: 'terminalError',
+      terminalId,
+      data: {
+        error: 'PTY_NOT_AVAILABLE',
+        instructions: ptyManager.getPtyInstallInstructions()
+      }
+    });
+    return;
+  }
+
+  addTerminalSubscriber(ctx, terminalId, ws);
+  setupTerminalBroadcastListeners(ctx, terminalId);
+
+  try {
+    const { shell, cwd, isReconnect } = ptyManager.create(
+      terminalId,
+      workingDir,
+      cols || 80,
+      rows || 24,
+      requestedShell,
+      { sandboxed: permission === 'control' || permission === 'view' }
+    );
+
+    if (!isReconnect) {
+      ctx.broadcastToOthers(ws, {
+        type: 'terminalCreated',
+        data: { terminalId, shell, cwd }
+      });
+    }
+
+    ctx.send(ws, {
+      type: 'terminalReady',
+      terminalId,
+      data: { shell, cwd, isReconnect }
+    });
+    trackEvent(AnalyticsEvents.TERMINAL_SESSION_CREATED, {
+      shell,
+      is_reconnect: isReconnect,
+    });
+  } catch (error: unknown) {
+    console.error(`[WebSocketImproviseHandler] Failed to create terminal:`, error);
+    ctx.send(ws, {
+      type: 'terminalError',
+      terminalId,
+      data: { error: (error instanceof Error ? error.message : String(error)) || 'Failed to create terminal' }
+    });
+    removeTerminalSubscriber(ctx, terminalId, ws);
+  }
+}
+
+function handleTerminalReconnect(ctx: HandlerContext, ws: WSContext, terminalId: string): void {
+  const ptyManager = getPTYManager();
+
+  const sessionInfo = ptyManager.getSessionInfo(terminalId);
+  if (!sessionInfo) {
+    ctx.send(ws, {
+      type: 'terminalError',
+      terminalId,
+      data: { error: 'Terminal session not found', sessionNotFound: true }
+    });
+    return;
+  }
+
+  addTerminalSubscriber(ctx, terminalId, ws);
+  setupTerminalBroadcastListeners(ctx, terminalId);
+
+  ctx.send(ws, {
+    type: 'terminalReady',
+    terminalId,
+    data: {
+      shell: sessionInfo.shell,
+      cwd: sessionInfo.cwd,
+      isReconnect: true
+    }
+  });
+
+  ptyManager.resize(terminalId, sessionInfo.cols, sessionInfo.rows);
+}
+
+function handleTerminalList(ctx: HandlerContext, ws: WSContext): void {
+  const ptyManager = getPTYManager();
+  const terminalIds = ptyManager.getActiveTerminals();
+
+  const terminals = terminalIds.map(id => {
+    const info = ptyManager.getSessionInfo(id);
+    return info ? { id, ...info } : null;
+  }).filter(Boolean);
+
+  ctx.send(ws, {
+    type: 'terminalList',
+    data: { terminals }
+  });
+}
+
+function handleTerminalInput(
+  ctx: HandlerContext,
+  ws: WSContext,
+  terminalId: string,
+  input?: string
+): void {
+  if (!input) return;
+
+  const ptyManager = getPTYManager();
+  const success = ptyManager.write(terminalId, input);
+
+  if (!success) {
+    ctx.send(ws, {
+      type: 'terminalError',
+      terminalId,
+      data: { error: 'Terminal not found or write failed' }
+    });
+  }
+}
+
+function handleTerminalResize(
+  _ctx: HandlerContext,
+  terminalId: string,
+  cols?: number,
+  rows?: number
+): void {
+  if (!cols || !rows) return;
+
+  const ptyManager = getPTYManager();
+  ptyManager.resize(terminalId, cols, rows);
+}
+
+function handleTerminalClose(ctx: HandlerContext, ws: WSContext, terminalId: string): void {
+  trackEvent(AnalyticsEvents.TERMINAL_SESSION_CLOSED);
+
+  const listenerCleanup = ctx.terminalListenerCleanups.get(terminalId);
+  if (listenerCleanup) {
+    listenerCleanup();
+    ctx.terminalListenerCleanups.delete(terminalId);
+  }
+
+  const ptyManager = getPTYManager();
+  ptyManager.close(terminalId);
+
+  ctx.terminalSubscribers.delete(terminalId);
+
+  ctx.broadcastToOthers(ws, {
+    type: 'terminalClosed',
+    data: { terminalId }
+  });
+}
+
+function addTerminalSubscriber(ctx: HandlerContext, terminalId: string, ws: WSContext): void {
+  let subs = ctx.terminalSubscribers.get(terminalId);
+  if (!subs) {
+    subs = new Set();
+    ctx.terminalSubscribers.set(terminalId, subs);
+  }
+  subs.add(ws);
+}
+
+function removeTerminalSubscriber(ctx: HandlerContext, terminalId: string, ws: WSContext): void {
+  const subs = ctx.terminalSubscribers.get(terminalId);
+  if (!subs) return;
+  subs.delete(ws);
+  if (subs.size > 0) return;
+  ctx.terminalSubscribers.delete(terminalId);
+  const cleanup = ctx.terminalListenerCleanups.get(terminalId);
+  if (cleanup) {
+    cleanup();
+    ctx.terminalListenerCleanups.delete(terminalId);
+  }
+}
+
+function setupTerminalBroadcastListeners(ctx: HandlerContext, terminalId: string): void {
+  if (ctx.terminalListenerCleanups.has(terminalId)) return;
+
+  const ptyManager = getPTYManager();
+
+  const onOutput = (tid: string, data: string) => {
+    if (tid === terminalId) {
+      const subs = ctx.terminalSubscribers.get(terminalId);
+      if (subs) {
+        for (const ws of subs) {
+          ctx.send(ws, { type: 'terminalOutput', terminalId, data: { output: data } });
+        }
+      }
+    }
+  };
+
+  const onExit = (tid: string, exitCode: number) => {
+    if (tid === terminalId) {
+      const subs = ctx.terminalSubscribers.get(terminalId);
+      if (subs) {
+        for (const ws of subs) {
+          ctx.send(ws, { type: 'terminalExit', terminalId, data: { exitCode } });
+        }
+      }
+      ptyManager.off('output', onOutput);
+      ptyManager.off('exit', onExit);
+      ptyManager.off('error', onError);
+      ctx.terminalListenerCleanups.delete(terminalId);
+      ctx.terminalSubscribers.delete(terminalId);
+    }
+  };
+
+  const onError = (tid: string, error: string) => {
+    if (tid === terminalId) {
+      const subs = ctx.terminalSubscribers.get(terminalId);
+      if (subs) {
+        for (const ws of subs) {
+          ctx.send(ws, { type: 'terminalError', terminalId, data: { error } });
+        }
+      }
+    }
+  };
+
+  ptyManager.on('output', onOutput);
+  ptyManager.on('exit', onExit);
+  ptyManager.on('error', onError);
+
+  ctx.terminalListenerCleanups.set(terminalId, () => {
+    ptyManager.off('output', onOutput);
+    ptyManager.off('exit', onExit);
+    ptyManager.off('error', onError);
+  });
+}
+
+/**
+ * Clean up terminal subscribers for a disconnected WS context.
+ * Called from handler.ts handleClose().
+ */
+export function cleanupTerminalSubscribers(ctx: HandlerContext, ws: WSContext): void {
+  for (const subs of ctx.terminalSubscribers.values()) {
+    subs.delete(ws);
+  }
+}