mstro-app 0.4.52 → 0.5.0

package/server/services/websocket/handler.ts

@@ -14,20 +14,24 @@ import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
 import type { ImprovisationSessionManager } from '../../cli/improvisation-session-manager.js';
 import { captureException } from '../sentry.js';
+import { getPTYManager } from '../terminal/pty-manager.js';
 import { AutocompleteService } from './autocomplete.js';
+import { FileDownloadHandler } from './file-download-handler.js';
 import { handleFileExplorerMessage, handleFileMessage } from './file-explorer-handlers.js';
 import { FileUploadHandler } from './file-upload-handler.js';
 import { handleGitMessage } from './git-handlers.js';
 import { GitHeadWatcher } from './git-head-watcher.js';
 import type { HandlerContext, UsageReporter } from './handler-context.js';
+import { MsgIdTracker } from './msg-id-tracker.js';
 import { handlePlanMessage } from './plan-handlers.js';
 import { handleQualityMessage } from './quality-handlers.js';
-import { handleHistoryMessage, handleSessionMessage, initializeTab, resumeHistoricalSession } from './session-handlers.js';
+import { handleHistoryMessage, handleSessionMessage, initializeTab, restoreWorktreeFromRegistry, resumeHistoricalSession } from './session-handlers.js';
 import { SessionRegistry } from './session-registry.js';
 import { generateNotificationSummary, handleGetSettings, handleUpdateSettings } from './settings-handlers.js';
 import { handleListSkills } from './skill-handlers.js';
 import { SkillsWatcher } from './skill-watcher.js';
-import { handleCreateTab, handleGetActiveTabs, handleMarkTabViewed, handleRemoveTab, handleReorderTabs, handleSyncPromptText, handleSyncTabMeta } from './tab-handlers.js';
+import { TabEventBufferRegistry } from './tab-event-buffer.js';
+import { handleCreateTab, handleGetActiveTabs, handleMarkTabViewed, handleRemoveTab, handleReorderTabs, handleSyncTabMeta } from './tab-handlers.js';
 import { cleanupTerminalSubscribers, handleTerminalMessage } from './terminal-handlers.js';
 import type { FrecencyData, WebSocketMessage, WebSocketResponse, WSContext } from './types.js';
 
@@ -47,8 +51,11 @@ export class WebSocketImproviseHandler implements HandlerContext {
   terminalListenerCleanups: Map<string, () => void> = new Map();
   terminalSubscribers: Map<string, Set<WSContext>> = new Map();
   fileUploadHandler: FileUploadHandler | null = null;
+  fileDownloadHandler: FileDownloadHandler | null = null;
   gitHeadWatcher: GitHeadWatcher | null = null;
   skillsWatcher: SkillsWatcher | null = null;
+  tabEventBuffers: TabEventBufferRegistry = new TabEventBufferRegistry();
+  msgIdTracker: MsgIdTracker = new MsgIdTracker();
 
   constructor() {
     this.frecencyPath = join(homedir(), '.mstro', 'autocomplete-frecency.json');
@@ -146,7 +153,7 @@ export class WebSocketImproviseHandler implements HandlerContext {
   }
 
   /** Dispatch table mapping message types to domain handlers. Built once, looked up per message. */
-  private static readonly DISPATCH: Record<string, 'session' | 'history' | 'file' | 'terminal' | 'fileExplorer' | 'git' | 'quality' | 'plan' | 'fileUpload'> = {
+  private static readonly DISPATCH: Record<string, 'session' | 'history' | 'file' | 'terminal' | 'fileExplorer' | 'git' | 'quality' | 'plan' | 'fileUpload' | 'fileDownload'> = {
     // Session
     execute: 'session', cancel: 'session', getHistory: 'session', new: 'session', approve: 'session', reject: 'session',
     // History
@@ -165,6 +172,8 @@ export class WebSocketImproviseHandler implements HandlerContext {
     planInit: 'plan', planGetState: 'plan', planListIssues: 'plan', planGetIssue: 'plan', planGetSprint: 'plan', planGetMilestone: 'plan', planCreateIssue: 'plan', planUpdateIssue: 'plan', planDeleteIssue: 'plan', planScaffold: 'plan', planPrompt: 'plan', planExecute: 'plan', planExecuteEpic: 'plan', planPause: 'plan', planStop: 'plan', planResume: 'plan', planCreateBoard: 'plan', planUpdateBoard: 'plan', planArchiveBoard: 'plan', planGetBoard: 'plan', planGetBoardState: 'plan', planReorderBoards: 'plan', planSetActiveBoard: 'plan', planGetBoardArtifacts: 'plan', planCreateSprint: 'plan', planActivateSprint: 'plan', planCompleteSprint: 'plan', planGetSprintArtifacts: 'plan', chatToBoard: 'plan',
     // File upload
     fileUploadStart: 'fileUpload', fileUploadChunk: 'fileUpload', fileUploadComplete: 'fileUpload', fileUploadCancel: 'fileUpload',
+    // File download (chunked streaming for large binaries)
+    fileDownloadStart: 'fileDownload', fileDownloadCancel: 'fileDownload',
   };
 
   private async dispatchMessage(ws: WSContext, msg: WebSocketMessage, tabId: string, workingDir: string, permission?: 'view'): Promise<void> {
@@ -174,10 +183,10 @@ export class WebSocketImproviseHandler implements HandlerContext {
         this.send(ws, { type: 'pong', tabId });
         return;
       case 'initTab':
-        return void await initializeTab(this, ws, tabId, workingDir, msg.data?.tabName);
+        return void await initializeTab(this, ws, tabId, workingDir, msg.data?.tabName, msg.data);
       case 'resumeSession':
         if (!msg.data?.historicalSessionId) throw new Error('Historical session ID is required');
-        return void await resumeHistoricalSession(this, ws, tabId, workingDir, msg.data.historicalSessionId);
+        return void await resumeHistoricalSession(this, ws, tabId, workingDir, msg.data.historicalSessionId, msg.data);
       case 'requestNotificationSummary':
         if (!msg.data?.prompt || !msg.data?.output) throw new Error('Prompt and output are required for notification summary');
         return void await generateNotificationSummary(this, ws, tabId, msg.data.prompt, msg.data.output, workingDir);
@@ -189,8 +198,6 @@ export class WebSocketImproviseHandler implements HandlerContext {
         return handleReorderTabs(this, ws, workingDir, msg.data?.tabOrder);
       case 'syncTabMeta':
         return handleSyncTabMeta(this, ws, msg, tabId, workingDir);
-      case 'syncPromptText':
-        return handleSyncPromptText(this, ws, msg, tabId);
       case 'removeTab':
         return handleRemoveTab(this, ws, tabId, workingDir);
       case 'markTabViewed':
@@ -208,6 +215,14 @@ export class WebSocketImproviseHandler implements HandlerContext {
     const domain = WebSocketImproviseHandler.DISPATCH[msg.type];
     if (!domain) throw new Error(`Unknown message type: ${msg.type}`);
 
+    // Hydrate worktree state from the registry before any domain handler
+    // reads it, so git/file/autocomplete ops route to the tab's worktree
+    // even when they arrive before the initTab handshake completes. The
+    // registry is authoritative; the in-memory Map is just a cache.
+    if (msg.tabId && !this.gitDirectories.has(tabId)) {
+      restoreWorktreeFromRegistry(this, this.getRegistry(workingDir), tabId);
+    }
+
     // Resolve effective working directory: use worktree path if tab is on a worktree
     const effectiveDir = this.gitDirectories.get(tabId) || workingDir;
 
@@ -221,6 +236,24 @@ export class WebSocketImproviseHandler implements HandlerContext {
       case 'quality':    return handleQualityMessage(this, ws, msg, tabId, workingDir, permission);
       case 'plan':       return handlePlanMessage(this, ws, msg, tabId, workingDir, permission);
       case 'fileUpload': return this.handleFileUploadMessage(ws, msg, tabId, workingDir, permission);
+      case 'fileDownload': return this.handleFileDownloadMessage(ws, msg, tabId, effectiveDir);
+    }
+  }
+
+  private handleFileDownloadMessage(ws: WSContext, msg: WebSocketMessage, tabId: string, workingDir: string): void {
+    if (!this.fileDownloadHandler) {
+      this.fileDownloadHandler = new FileDownloadHandler(workingDir);
+    }
+    const handler = this.fileDownloadHandler;
+    const send = this.send.bind(this);
+
+    switch (msg.type) {
+      case 'fileDownloadStart':
+        handler.handleDownloadStart(ws, send, tabId, msg.data);
+        break;
+      case 'fileDownloadCancel':
+        handler.handleDownloadCancel(ws, send, tabId, msg.data);
+        break;
     }
   }
 
@@ -262,6 +295,10 @@ export class WebSocketImproviseHandler implements HandlerContext {
         this.fileUploadHandler.destroy();
         this.fileUploadHandler = null;
       }
+      if (this.fileDownloadHandler) {
+        this.fileDownloadHandler.destroy();
+        this.fileDownloadHandler = null;
+      }
       if (this.gitHeadWatcher) {
         this.gitHeadWatcher.stop();
         this.gitHeadWatcher = null;
@@ -270,18 +307,45 @@ export class WebSocketImproviseHandler implements HandlerContext {
         this.skillsWatcher.stop();
         this.skillsWatcher = null;
       }
+
+      // Close orphan PTYs when no web client is watching any more.
+      //
+      // Prior behavior: PTYs survived until the user typed `exit` or the
+      // CLI process died. A page refresh / browser tab close / view-switch
+      // would leak the pty, and after a few of these the user would have
+      // tens of zombie shells competing for I/O bandwidth, which manifests
+      // as the app feeling "unresponsive" — interactive operations starve
+      // because the relay socket is saturated streaming output for ptys
+      // that no UI is rendering.
+      //
+      // The active-session preservation in `cleanupConnectionResources`
+      // above is intentionally separate: improvise sessions can produce
+      // useful work while the browser is closed (Claude Code keeps running
+      // in the background); a shell process can't, by construction. So we
+      // preserve the former and reap the latter.
+      const ptyManager = getPTYManager();
+      const activeTerminals = ptyManager.getActiveTerminals();
+      if (activeTerminals.length > 0) {
+        console.log(`[handler] No web subscribers — closing ${activeTerminals.length} orphan PTY${activeTerminals.length === 1 ? '' : 's'}`);
+        ptyManager.closeAll();
+      }
     }
   }
 
   private cleanupConnectionResources(tabMap: Map<string, string>): void {
-    // Destroy sessions owned by this connection
+    // Preserve actively-executing sessions across web reconnects. The runner
+    // is still producing output, and the new web connection will re-attach
+    // via session-handlers.ts::getSession (or initializeTab → reattachSession)
+    // which rebinds listeners and replays executionEventLog. Destroying the
+    // session here would orphan the runner and silently drop all streamed
+    // output for the rest of the prompt.
     const sessionIds = new Set(tabMap.values());
     for (const sessionId of sessionIds) {
       const session = this.sessions.get(sessionId);
-      if (session) {
-        session.destroy();
-        this.sessions.delete(sessionId);
-      }
+      if (!session) continue;
+      if (session.isExecuting) continue;
+      session.destroy();
+      this.sessions.delete(sessionId);
     }
     // Kill search processes owned by this connection's tabs
     for (const tabId of tabMap.keys()) {

package/server/services/websocket/msg-id-tracker.ts

@@ -0,0 +1,84 @@
+// Copyright (c) 2025-present Mstro, Inc. All rights reserved.
+// Licensed under the MIT License. See LICENSE file for details.
+
+/**
+ * Idempotency tracker for client-sent message IDs.
+ *
+ * The web client assigns a UUID `msgId` to every `execute` message and
+ * stores it in a persistent outbox until an `executeAck` arrives. If the
+ * web reconnects before the ack lands it replays the same `msgId`; without
+ * dedupe the CLI would run the prompt twice (burning tokens, confusing
+ * the user). This tracker gives handlers an atomic
+ * "first time we've seen this msgId?" check with a bounded TTL so old
+ * ids don't leak forever.
+ *
+ * Design notes:
+ *   - TTL (not LRU) — web promises to stop replaying once it gets an ack
+ *     or times out the outbox, so a fixed window covers the realistic
+ *     replay horizon. 15 minutes matches `tab-event-buffer.ts`.
+ *   - Per-tab partitioning so a tab removal can cheaply clear that tab's
+ *     history without scanning the whole map.
+ *   - Lazy eviction on every check — no timers, cheap in the hot path.
+ */
+
+const DEFAULT_TTL_MS = 15 * 60 * 1000;
+const DEFAULT_MAX_PER_TAB = 512;
+
+interface TabEntry {
+  ids: Map<string, number>;
+}
+
+export class MsgIdTracker {
+  private readonly tabs = new Map<string, TabEntry>();
+
+  constructor(
+    private readonly ttlMs: number = DEFAULT_TTL_MS,
+    private readonly maxPerTab: number = DEFAULT_MAX_PER_TAB,
+    private readonly now: () => number = Date.now,
+  ) {}
+
+  /**
+   * Returns `true` if `msgId` is being recorded for the first time on
+   * `tabId`, `false` if it was already seen inside the TTL window. Callers
+   * should skip re-execution when this returns `false` but still re-ack
+   * so the client's outbox drains.
+   */
+  recordIfFirst(tabId: string, msgId: string): boolean {
+    const entry = this.tabs.get(tabId) ?? { ids: new Map<string, number>() };
+    this.evictExpired(entry);
+    if (entry.ids.has(msgId)) {
+      // Refresh the timestamp so a long stall still counts as "seen".
+      entry.ids.set(msgId, this.now());
+      return false;
+    }
+    entry.ids.set(msgId, this.now());
+    this.enforceSizeCap(entry);
+    this.tabs.set(tabId, entry);
+    return true;
+  }
+
+  /** Drop all msgIds for a removed tab. */
+  forget(tabId: string): void {
+    this.tabs.delete(tabId);
+  }
+
+  /** Test helper — visible for unit tests only. */
+  size(tabId: string): number {
+    return this.tabs.get(tabId)?.ids.size ?? 0;
+  }
+
+  private evictExpired(entry: TabEntry): void {
+    const cutoff = this.now() - this.ttlMs;
+    for (const [id, ts] of entry.ids) {
+      if (ts < cutoff) entry.ids.delete(id);
+    }
+  }
+
+  private enforceSizeCap(entry: TabEntry): void {
+    while (entry.ids.size > this.maxPerTab) {
+      const firstKey = entry.ids.keys().next().value;
+      if (firstKey === undefined) break;
+      entry.ids.delete(firstKey);
+    }
+  }
+}

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

@@ -173,6 +173,15 @@ async function handleSaveDirectories(
     }
 
     persistence.saveConfig(directories);
+
+    // Broadcast the updated set so every paired web (on any Fly instance)
+    // reflects the change. This is how Quality subdirectory tabs stay in
+    // sync across devices — the type is listed in the cross-instance
+    // set in `server/src/relay/handlers/clientHandlers.ts`.
+    ctx.broadcastToAll({
+      type: 'qualityDirectoriesUpdated',
+      data: { directories },
+    });
   } catch (error) {
     ctx.send(ws, {
       type: 'qualityError',
@@ -245,9 +254,11 @@ async function handleScan(
 
     const resultData = { path: reportPath, results };
     try {
-      ctx.send(ws, { type: 'qualityScanResults', data: resultData });
+      // Broadcast so every device sees the new scan — the Quality view on
+      // another device otherwise stays stuck on the previous scan results.
+      ctx.broadcastToAll({ type: 'qualityScanResults', data: resultData });
     } catch {
-      // WebSocket closed — save as pending for delivery on reconnect
+      // Broadcast failed — save as pending for delivery on reconnect
       persistence.addPendingResult({
         type: 'scanResults',
         path: reportPath,
@@ -288,7 +299,9 @@ async function handleInstallTools(
 
     const { tools, ecosystem } = await installTools(dirPath, toolNames);
 
-    ctx.send(ws, {
+    // Broadcast so every device sees the install result (status of tools
+    // changes orchestra-wide once installed on the machine).
+    ctx.broadcastToAll({
       type: 'qualityInstallComplete',
       data: { path: reportPath, tools, ecosystem },
     });

package/server/services/websocket/quality-review-agent.ts

@@ -428,7 +428,7 @@ async function runVerificationPass(
       policy: 'STANDARD',
       stallWarningMs: 300_000,
       stallKillMs: 900_000,
-      stallHardCapMs: 1_200_000,
+      stallHardCapMs: 3_600_000,
       toolUseCallback: makeToolCallback(send, 'Verifying: '),
       logLabel: 'code-review-verify',
     });
@@ -505,7 +505,7 @@ export async function handleCodeReview(
       policy: 'STANDARD',
       stallWarningMs: 300_000,
       stallKillMs: 1_200_000,
-      stallHardCapMs: 1_800_000,
+      stallHardCapMs: 7_200_000,
       toolUseCallback: makeToolCallback(send),
       logLabel: 'code-review',
     });