mstro-app 0.3.5 → 0.3.7

package/server/services/websocket/git-worktree-handlers.ts

@@ -6,10 +6,11 @@ import { executeGitCommand, handleGitStatus, spawnWithOutput } from './git-handl
 import type { HandlerContext } from './handler-context.js';
 import type { WebSocketMessage, WorktreeInfo, WSContext } from './types.js';
 
-export function handleGitWorktreeMessage(ctx: HandlerContext, ws: WSContext, msg: WebSocketMessage, tabId: string, gitDir: string, workingDir: string): void {
-  const handlers: Record<string, () => void> = {
+export async function handleGitWorktreeMessage(ctx: HandlerContext, ws: WSContext, msg: WebSocketMessage, tabId: string, gitDir: string, workingDir: string): Promise<void> {
+  const handlers: Record<string, () => Promise<void>> = {
     gitWorktreeList: () => handleGitWorktreeList(ctx, ws, tabId, gitDir),
     gitWorktreeCreate: () => handleGitWorktreeCreate(ctx, ws, msg, tabId, gitDir),
+    gitWorktreeCreateAndAssign: () => handleGitWorktreeCreateAndAssign(ctx, ws, msg, tabId, gitDir, workingDir),
     gitWorktreeRemove: () => handleGitWorktreeRemove(ctx, ws, msg, tabId, gitDir),
     tabWorktreeSwitch: () => handleTabWorktreeSwitch(ctx, ws, msg, tabId, workingDir),
     gitWorktreePush: () => handleGitWorktreePush(ctx, ws, msg, tabId, gitDir),
@@ -19,7 +20,7 @@ export function handleGitWorktreeMessage(ctx: HandlerContext, ws: WSContext, msg
     gitMergeAbort: () => handleGitMergeAbort(ctx, ws, tabId, gitDir),
     gitMergeComplete: () => handleGitMergeComplete(ctx, ws, msg, tabId, gitDir),
   };
-  handlers[msg.type]?.();
+  await handlers[msg.type]?.();
 }
 
 function applyWorktreePorcelainLine(line: string, worktrees: WorktreeInfo[], current: Partial<WorktreeInfo>): Partial<WorktreeInfo> {
@@ -90,6 +91,44 @@ async function handleGitWorktreeCreate(ctx: HandlerContext, ws: WSContext, msg:
   }
 }
 
+async function handleGitWorktreeCreateAndAssign(ctx: HandlerContext, ws: WSContext, msg: WebSocketMessage, tabId: string, gitDir: string, workingDir: string): Promise<void> {
+  try {
+    const { branchName, baseBranch, path: worktreePath } = msg.data || {};
+    if (!branchName) {
+      ctx.send(ws, { type: 'gitError', tabId, data: { error: 'Branch name is required' } });
+      return;
+    }
+
+    const repoName = gitDir.split('/').pop() || 'repo';
+    const wtPath = worktreePath || join(dirname(gitDir), `${repoName}-worktrees`, branchName);
+
+    const args = ['worktree', 'add', wtPath, '-b', branchName, ...(baseBranch ? [baseBranch] : [])];
+    const result = await executeGitCommand(args, gitDir);
+    if (result.exitCode !== 0) {
+      ctx.send(ws, { type: 'gitError', tabId, data: { error: result.stderr || 'Failed to create worktree' } });
+      return;
+    }
+
+    const headResult = await executeGitCommand(['rev-parse', '--short', 'HEAD'], wtPath);
+
+    // Assign to tab
+    ctx.gitDirectories.set(tabId, wtPath);
+    ctx.gitBranches.set(tabId, branchName);
+    const registry = ctx.getRegistry(workingDir);
+    registry.updateTabWorktree(tabId, wtPath, branchName);
+
+    ctx.send(ws, {
+      type: 'gitWorktreeCreatedAndAssigned',
+      tabId,
+      data: { tabId, path: wtPath, branch: branchName, head: headResult.stdout.trim() },
+    });
+
+    handleGitStatus(ctx, ws, tabId, wtPath);
+  } catch (error: unknown) {
+    ctx.send(ws, { type: 'gitError', tabId, data: { error: error instanceof Error ? error.message : String(error) } });
+  }
+}
+
 async function handleGitWorktreeRemove(ctx: HandlerContext, ws: WSContext, msg: WebSocketMessage, tabId: string, workingDir: string): Promise<void> {
   try {
     const { path: wtPath, force, deleteBranch } = msg.data || {};
@@ -127,8 +166,11 @@ async function handleTabWorktreeSwitch(ctx: HandlerContext, ws: WSContext, msg:
   try {
     const { tabId: targetTabId, worktreePath } = msg.data || {};
     const resolvedTabId = targetTabId || tabId;
+    const registry = ctx.getRegistry(workingDir);
     if (!worktreePath) {
       ctx.gitDirectories.delete(resolvedTabId);
+      ctx.gitBranches.delete(resolvedTabId);
+      registry.updateTabWorktree(resolvedTabId, null, null);
       ctx.send(ws, { type: 'tabWorktreeSwitched', tabId: resolvedTabId, data: { tabId: resolvedTabId, worktreePath: workingDir, branch: '' } });
       handleGitStatus(ctx, ws, resolvedTabId, workingDir);
       return;
@@ -138,6 +180,8 @@ async function handleTabWorktreeSwitch(ctx: HandlerContext, ws: WSContext, msg:
 
     const branchResult = await executeGitCommand(['rev-parse', '--abbrev-ref', 'HEAD'], worktreePath);
     const branch = branchResult.stdout.trim();
+    ctx.gitBranches.set(resolvedTabId, branch);
+    registry.updateTabWorktree(resolvedTabId, worktreePath, branch);
 
     ctx.send(ws, { type: 'tabWorktreeSwitched', tabId: resolvedTabId, data: { tabId: resolvedTabId, worktreePath, branch } });
     handleGitStatus(ctx, ws, resolvedTabId, worktreePath);

package/server/services/websocket/handler-context.ts

@@ -4,6 +4,7 @@
 import type { ChildProcess } from 'node:child_process';
 import type { ImprovisationSessionManager } from '../../cli/improvisation-session-manager.js';
 import type { AutocompleteService } from './autocomplete.js';
+import type { FileUploadHandler } from './file-upload-handler.js';
 import type { SessionRegistry } from './session-registry.js';
 import type { WebSocketResponse, WSContext } from './types.js';
 
@@ -25,11 +26,13 @@ export interface HandlerContext {
   connections: Map<WSContext, Map<string, string>>;
   allConnections: Set<WSContext>;
   gitDirectories: Map<string, string>;
+  gitBranches: Map<string, string>;
   activeSearches: Map<string, ChildProcess>;
   terminalSubscribers: Map<string, Set<WSContext>>;
   terminalListenerCleanups: Map<string, () => void>;
   autocompleteService: AutocompleteService;
   usageReporter: UsageReporter | null;
+  fileUploadHandler: FileUploadHandler | null;
 
   // Registry access
   getRegistry(workingDir: string): SessionRegistry;

package/server/services/websocket/handler.ts

@@ -16,6 +16,7 @@ import type { ImprovisationSessionManager } from '../../cli/improvisation-sessio
 import { captureException } from '../sentry.js';
 import { AutocompleteService } from './autocomplete.js';
 import { handleFileExplorerMessage, handleFileMessage } from './file-explorer-handlers.js';
+import { FileUploadHandler } from './file-upload-handler.js';
 import { handleGitMessage } from './git-handlers.js';
 import type { HandlerContext, UsageReporter } from './handler-context.js';
 import { handleHistoryMessage, handleSessionMessage, initializeTab, resumeHistoricalSession } from './session-handlers.js';
@@ -34,11 +35,13 @@ export class WebSocketImproviseHandler implements HandlerContext {
   private frecencyPath: string;
   usageReporter: UsageReporter | null = null;
   gitDirectories: Map<string, string> = new Map();
+  gitBranches: Map<string, string> = new Map();
   private sessionRegistry: SessionRegistry | null = null;
   allConnections: Set<WSContext> = new Set();
   activeSearches: Map<string, ChildProcess> = new Map();
   terminalListenerCleanups: Map<string, () => void> = new Map();
   terminalSubscribers: Map<string, Set<WSContext>> = new Map();
+  fileUploadHandler: FileUploadHandler | null = null;
 
   constructor() {
     this.frecencyPath = join(homedir(), '.mstro', 'autocomplete-frecency.json');
@@ -192,6 +195,7 @@ export class WebSocketImproviseHandler implements HandlerContext {
       case 'gitPushTag':
       case 'gitWorktreeList':
       case 'gitWorktreeCreate':
+      case 'gitWorktreeCreateAndAssign':
       case 'gitWorktreeRemove':
       case 'tabWorktreeSwitch':
       case 'gitWorktreePush':
@@ -221,11 +225,40 @@ export class WebSocketImproviseHandler implements HandlerContext {
         return handleGetSettings(this, ws);
       case 'updateSettings':
         return handleUpdateSettings(this, ws, msg);
+      // File upload messages (chunked remote uploads)
+      case 'fileUploadStart':
+      case 'fileUploadChunk':
+      case 'fileUploadComplete':
+      case 'fileUploadCancel':
+        return this.handleFileUploadMessage(ws, msg, tabId, workingDir);
       default:
         throw new Error(`Unknown message type: ${msg.type}`);
     }
   }
 
+  private handleFileUploadMessage(ws: WSContext, msg: WebSocketMessage, tabId: string, workingDir: string): void {
+    if (!this.fileUploadHandler) {
+      this.fileUploadHandler = new FileUploadHandler(workingDir);
+    }
+    const handler = this.fileUploadHandler;
+    const send = this.send.bind(this);
+
+    switch (msg.type) {
+      case 'fileUploadStart':
+        handler.handleUploadStart(ws, send, tabId, msg.data);
+        break;
+      case 'fileUploadChunk':
+        handler.handleUploadChunk(ws, send, tabId, msg.data);
+        break;
+      case 'fileUploadComplete':
+        handler.handleUploadComplete(ws, send, tabId, msg.data);
+        break;
+      case 'fileUploadCancel':
+        handler.handleUploadCancel(ws, send, tabId, msg.data);
+        break;
+    }
+  }
+
   handleClose(ws: WSContext): void {
     this.connections.delete(ws);
     this.allConnections.delete(ws);

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

@@ -3,7 +3,7 @@
 
 import { existsSync, readdirSync, readFileSync, unlinkSync } from 'node:fs';
 import { join } from 'node:path';
-import { ImprovisationSessionManager } from '../../cli/improvisation-session-manager.js';
+import { type FileAttachment, ImprovisationSessionManager } from '../../cli/improvisation-session-manager.js';
 import { getModel } from '../settings.js';
 import type { HandlerContext } from './handler-context.js';
 import type { SessionRegistry } from './session-registry.js';
@@ -128,6 +128,29 @@ export function setupSessionListeners(ctx: HandlerContext, session: Improvisatio
   });
 }
 
+/** Merge pre-uploaded files (from chunked upload) with any inline attachments */
+function mergePreUploadedAttachments(ctx: HandlerContext, tabId: string, inlineAttachments?: FileAttachment[]): FileAttachment[] | undefined {
+  if (!ctx.fileUploadHandler) return inlineAttachments;
+  const preUploaded = ctx.fileUploadHandler.getAndClearCompletedUploads(tabId);
+  if (preUploaded.length === 0) return inlineAttachments;
+
+  const merged: (FileAttachment & { _preUploaded?: boolean })[] = [...(inlineAttachments || [])];
+  for (const upload of preUploaded) {
+    const alreadyIncluded = merged.some(a => a.fileName === upload.fileName);
+    if (!alreadyIncluded) {
+      merged.push({
+        fileName: upload.fileName,
+        filePath: upload.filePath,
+        content: '',
+        isImage: upload.isImage,
+        mimeType: upload.mimeType,
+        _preUploaded: true,
+      });
+    }
+  }
+  return merged;
+}
+
 export function handleSessionMessage(ctx: HandlerContext, ws: WSContext, msg: WebSocketMessage, tabId: string, permission?: 'control' | 'view'): void {
   switch (msg.type) {
     case 'execute': {
@@ -135,7 +158,8 @@ export function handleSessionMessage(ctx: HandlerContext, ws: WSContext, msg: We
       const session = requireSession(ctx, ws, tabId);
       const sandboxed = permission === 'control' || permission === 'view';
       const worktreeDir = ctx.gitDirectories.get(tabId);
-      session.executePrompt(msg.data.prompt, msg.data.attachments, { sandboxed, workingDir: worktreeDir });
+      const attachments = mergePreUploadedAttachments(ctx, tabId, msg.data.attachments);
+      session.executePrompt(msg.data.prompt, attachments, { sandboxed, workingDir: worktreeDir });
       break;
     }
     case 'cancel': {
@@ -206,6 +230,47 @@ export function handleHistoryMessage(ctx: HandlerContext, ws: WSContext, msg: We
   }
 }
 
+function tryResumeFromDisk(
+  ctx: HandlerContext,
+  ws: WSContext,
+  tabId: string,
+  workingDir: string,
+  registrySessionId: string,
+  tabMap: Map<string, string> | undefined,
+  registry: SessionRegistry
+): boolean {
+  try {
+    const diskSession = ImprovisationSessionManager.resumeFromHistory(workingDir, registrySessionId);
+    setupSessionListeners(ctx, diskSession, ws, tabId);
+    const diskSessionId = diskSession.getSessionInfo().sessionId;
+    ctx.sessions.set(diskSessionId, diskSession);
+    if (tabMap) tabMap.set(tabId, diskSessionId);
+    registry.touchTab(tabId);
+
+    // Restore worktree state from registry
+    const regTab = registry.getTab(tabId);
+    if (regTab?.worktreePath && !ctx.gitDirectories.has(tabId)) {
+      ctx.gitDirectories.set(tabId, regTab.worktreePath);
+      if (regTab.worktreeBranch) ctx.gitBranches.set(tabId, regTab.worktreeBranch);
+    }
+    const worktreePath = ctx.gitDirectories.get(tabId);
+    const worktreeBranch = ctx.gitBranches.get(tabId);
+
+    ctx.send(ws, {
+      type: 'tabInitialized',
+      tabId,
+      data: {
+        ...diskSession.getSessionInfo(),
+        outputHistory: buildOutputHistory(diskSession),
+        ...(worktreePath ? { worktreePath, worktreeBranch } : {}),
+      }
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 export async function initializeTab(ctx: HandlerContext, ws: WSContext, tabId: string, workingDir: string, tabName?: string): Promise<void> {
   const tabMap = ctx.connections.get(ws);
   const registry = ctx.getRegistry(workingDir);
@@ -229,25 +294,8 @@ export async function initializeTab(ctx: HandlerContext, ws: WSContext, tabId: s
       return;
     }
 
-    try {
-      const diskSession = ImprovisationSessionManager.resumeFromHistory(workingDir, registrySessionId);
-      setupSessionListeners(ctx, diskSession, ws, tabId);
-      const diskSessionId = diskSession.getSessionInfo().sessionId;
-      ctx.sessions.set(diskSessionId, diskSession);
-      if (tabMap) tabMap.set(tabId, diskSessionId);
-      registry.touchTab(tabId);
-
-      ctx.send(ws, {
-        type: 'tabInitialized',
-        tabId,
-        data: {
-          ...diskSession.getSessionInfo(),
-          outputHistory: buildOutputHistory(diskSession),
-        }
-      });
+    if (tryResumeFromDisk(ctx, ws, tabId, workingDir, registrySessionId, tabMap, registry)) {
       return;
-    } catch {
-      // Disk session not found — fall through to create new
     }
   }
 
@@ -352,12 +400,22 @@ function reattachSession(
   if (tabMap) tabMap.set(tabId, sessionId);
   registry.touchTab(tabId);
 
+  // Restore worktree state from registry if not already in memory
+  const regTab = registry.getTab(tabId);
+  if (regTab?.worktreePath && !ctx.gitDirectories.has(tabId)) {
+    ctx.gitDirectories.set(tabId, regTab.worktreePath);
+    if (regTab.worktreeBranch) ctx.gitBranches.set(tabId, regTab.worktreeBranch);
+  }
+
   const outputHistory = buildOutputHistory(session);
 
   const executionEvents = session.isExecuting
     ? session.getExecutionEventLog()
     : undefined;
 
+  const worktreePath = ctx.gitDirectories.get(tabId);
+  const worktreeBranch = ctx.gitBranches.get(tabId);
+
   ctx.send(ws, {
     type: 'tabInitialized',
     tabId,
@@ -367,6 +425,7 @@ function reattachSession(
       isExecuting: session.isExecuting,
       executionEvents,
       ...(session.isExecuting && session.executionStartTimestamp ? { executionStartTimestamp: session.executionStartTimestamp } : {}),
+      ...(worktreePath ? { worktreePath, worktreeBranch } : {}),
     }
   });
 }

package/server/services/websocket/session-registry.ts

@@ -21,6 +21,8 @@ export interface RegisteredTab {
   lastActivityAt: string
   order: number
   hasUnviewedCompletion: boolean
+  worktreePath?: string
+  worktreeBranch?: string
 }
 
 interface RegistryData {
@@ -167,6 +169,22 @@ export class SessionRegistry {
     }
   }
 
+  /**
+   * Update worktree assignment for a tab. Pass null to clear.
+   */
+  updateTabWorktree(tabId: string, worktreePath: string | null, worktreeBranch: string | null): void {
+    if (this.data.tabs[tabId]) {
+      if (worktreePath) {
+        this.data.tabs[tabId].worktreePath = worktreePath
+        this.data.tabs[tabId].worktreeBranch = worktreeBranch || undefined
+      } else {
+        delete this.data.tabs[tabId].worktreePath
+        delete this.data.tabs[tabId].worktreeBranch
+      }
+      this.save()
+    }
+  }
+
   /**
    * Reorder tabs. Accepts an ordered array of tabIds and reassigns order values.
    */

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

@@ -7,6 +7,43 @@ import type { HandlerContext } from './handler-context.js';
 import { buildOutputHistory, setupSessionListeners } from './session-handlers.js';
 import type { WebSocketMessage, WSContext } from './types.js';
 
+function buildActiveTabData(
+  regTab: { tabName: string; createdAt: string; order: number; hasUnviewedCompletion?: boolean; sessionId: string },
+  session: ImprovisationSessionManager,
+  worktreePath: string | undefined,
+  worktreeBranch: string | undefined,
+): Record<string, unknown> {
+  return {
+    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 } : {}),
+    ...(worktreePath ? { worktreePath, worktreeBranch } : {}),
+  };
+}
+
+function buildInactiveTabData(
+  regTab: { tabName: string; createdAt: string; order: number; hasUnviewedCompletion?: boolean; sessionId: string },
+  worktreePath: string | undefined,
+  worktreeBranch: string | undefined,
+): Record<string, unknown> {
+  return {
+    tabName: regTab.tabName,
+    createdAt: regTab.createdAt,
+    order: regTab.order,
+    hasUnviewedCompletion: regTab.hasUnviewedCompletion,
+    sessionId: regTab.sessionId,
+    isExecuting: false,
+    outputHistory: [],
+    ...(worktreePath ? { worktreePath, worktreeBranch } : {}),
+  };
+}
+
 export function handleGetActiveTabs(ctx: HandlerContext, ws: WSContext, workingDir: string): void {
   const registry = ctx.getRegistry(workingDir);
   const allTabs = registry.getAllTabs();
@@ -14,29 +51,11 @@ export function handleGetActiveTabs(ctx: HandlerContext, ws: WSContext, workingD
   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: [],
-      };
-    }
+    const worktreePath = ctx.gitDirectories.get(tabId);
+    const worktreeBranch = ctx.gitBranches.get(tabId);
+    tabs[tabId] = session
+      ? buildActiveTabData(regTab, session, worktreePath, worktreeBranch)
+      : buildInactiveTabData(regTab, worktreePath, worktreeBranch);
   }
 
   ctx.send(ws, { type: 'activeTabs', data: { tabs } });
@@ -65,6 +84,8 @@ export function handleSyncPromptText(ctx: HandlerContext, _ws: WSContext, msg: W
 export function handleRemoveTab(ctx: HandlerContext, _ws: WSContext, tabId: string, workingDir: string): void {
   const registry = ctx.getRegistry(workingDir);
   registry.unregisterTab(tabId);
+  ctx.gitDirectories.delete(tabId);
+  ctx.gitBranches.delete(tabId);
 
   ctx.broadcastToAll({
     type: 'tabRemoved',

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

@@ -1,6 +1,7 @@
 // Copyright (c) 2025-present Mstro, Inc. All rights reserved.
 // Licensed under the MIT License. See LICENSE file for details.
 
+import { platform } from 'node:os';
 import { AnalyticsEvents, trackEvent } from '../analytics.js';
 import { getPTYManager } from '../terminal/pty-manager.js';
 import type { HandlerContext } from './handler-context.js';
@@ -58,7 +59,7 @@ function handleTerminalInit(
   setupTerminalBroadcastListeners(ctx, terminalId);
 
   try {
-    const { shell, cwd, isReconnect } = ptyManager.create(
+    const { shell, cwd, isReconnect, platform } = ptyManager.create(
       terminalId,
       workingDir,
       cols || 80,
@@ -77,8 +78,17 @@ function handleTerminalInit(
     ctx.send(ws, {
       type: 'terminalReady',
       terminalId,
-      data: { shell, cwd, isReconnect }
+      data: { shell, cwd, isReconnect, platform }
     });
+
+    // Send scrollback buffer so reconnecting clients see prior output
+    if (isReconnect) {
+      const scrollback = ptyManager.getScrollback(terminalId);
+      if (scrollback) {
+        ctx.send(ws, { type: 'terminalScrollback', terminalId, data: { scrollback } });
+      }
+    }
+
     trackEvent(AnalyticsEvents.TERMINAL_SESSION_CREATED, {
       shell,
       is_reconnect: isReconnect,
@@ -116,10 +126,17 @@ function handleTerminalReconnect(ctx: HandlerContext, ws: WSContext, terminalId:
     data: {
       shell: sessionInfo.shell,
       cwd: sessionInfo.cwd,
-      isReconnect: true
+      isReconnect: true,
+      platform: platform(),
     }
   });
 
+  // Send scrollback buffer so reconnecting clients see prior output
+  const scrollback = ptyManager.getScrollback(terminalId);
+  if (scrollback) {
+    ctx.send(ws, { type: 'terminalScrollback', terminalId, data: { scrollback } });
+  }
+
   ptyManager.resize(terminalId, sessionInfo.cols, sessionInfo.rows);
 }
 
@@ -269,9 +286,28 @@ function setupTerminalBroadcastListeners(ctx: HandlerContext, terminalId: string
 /**
  * Clean up terminal subscribers for a disconnected WS context.
  * Called from handler.ts handleClose().
+ *
+ * After removing the ws, also cleans up any subscriber Sets that are now empty
+ * and their associated PTY event listeners — preventing stale state accumulation
+ * across repeated connect/disconnect cycles (WebSocket hiccups).
  */
 export function cleanupTerminalSubscribers(ctx: HandlerContext, ws: WSContext): void {
-  for (const subs of ctx.terminalSubscribers.values()) {
+  const emptyTerminals: string[] = [];
+
+  for (const [terminalId, subs] of ctx.terminalSubscribers) {
     subs.delete(ws);
+    if (subs.size === 0) {
+      emptyTerminals.push(terminalId);
+    }
+  }
+
+  // Clean up empty subscriber sets and their PTY event listeners
+  for (const terminalId of emptyTerminals) {
+    ctx.terminalSubscribers.delete(terminalId);
+    const cleanup = ctx.terminalListenerCleanups.get(terminalId);
+    if (cleanup) {
+      cleanup();
+      ctx.terminalListenerCleanups.delete(terminalId);
+    }
   }
 }

package/server/services/websocket/types.ts

@@ -86,6 +86,7 @@ export interface WebSocketMessage {
     // Worktree operations
     | 'gitWorktreeList'
     | 'gitWorktreeCreate'
+    | 'gitWorktreeCreateAndAssign'
     | 'gitWorktreeRemove'
     | 'tabWorktreeSwitch'
     | 'gitWorktreePush'
@@ -105,7 +106,12 @@ export interface WebSocketMessage {
     | 'markTabViewed'
     // Settings message types
     | 'getSettings'
-    | 'updateSettings';
+    | 'updateSettings'
+    // File upload message types (chunked remote uploads)
+    | 'fileUploadStart'
+    | 'fileUploadChunk'
+    | 'fileUploadComplete'
+    | 'fileUploadCancel';
   tabId?: string;
   terminalId?: string;
   // biome-ignore lint/suspicious/noExplicitAny: message envelope carries heterogeneous payloads
@@ -158,6 +164,7 @@ export interface WebSocketResponse {
     | 'contentSearchError'
     | 'definitionResult'
     | 'fileError'
+    | 'terminalScrollback'
     // Terminal sync response types
     | 'terminalCreated'
     | 'terminalClosed'
@@ -190,6 +197,7 @@ export interface WebSocketResponse {
     // Worktree response types
     | 'gitWorktreeListResult'
     | 'gitWorktreeCreated'
+    | 'gitWorktreeCreatedAndAssigned'
     | 'gitWorktreeRemoved'
     | 'tabWorktreeSwitched'
     | 'gitWorktreePushed'
@@ -210,7 +218,11 @@ export interface WebSocketResponse {
     | 'tabStateChanged'
     // Settings response types
     | 'settings'
-    | 'settingsUpdated';
+    | 'settingsUpdated'
+    // File upload response types
+    | 'fileUploadAck'
+    | 'fileUploadReady'
+    | 'fileUploadError';
   tabId?: string;
   terminalId?: string;
   // biome-ignore lint/suspicious/noExplicitAny: message envelope carries heterogeneous payloads