mstro-app 0.3.6 → 0.3.8

package/server/services/platform.ts

@@ -117,6 +117,9 @@ interface ConnectionCallbacks {
 /**
  * Platform WebSocket connection with token-based authentication
  */
+/** Number of missed pongs before treating connection as dead */
+const MAX_MISSED_PONGS = 2
+
 export class PlatformConnection {
   private ws: WebSocket | null = null
   private reconnectTimeout: ReturnType<typeof setTimeout> | null = null
@@ -130,6 +133,7 @@ export class PlatformConnection {
   private isConnected = false
   private tokenRefreshInterval: ReturnType<typeof setInterval> | null = null
   private heartbeatInterval: ReturnType<typeof setInterval> | null = null
+  private missedPongs = 0
 
   constructor(
     workingDirectory: string,
@@ -184,19 +188,33 @@ export class PlatformConnection {
   }
 
   /**
-   * Start heartbeat to keep connection alive and refresh server-side TTL
+   * Start heartbeat to keep connection alive and refresh server-side TTL.
+   * Tracks missed pongs — if the server doesn't respond to MAX_MISSED_PONGS
+   * consecutive pings, the connection is considered dead and force-closed
+   * to trigger reconnection.
    */
   private startHeartbeat(): void {
+    this.missedPongs = 0
     // Send ping every 2 minutes (server TTL is 5 minutes)
-    this.heartbeatInterval = setInterval(() => {
-      if (this.ws && this.isConnected) {
-        try {
-          this.ws.send(JSON.stringify({ type: 'ping' }))
-        } catch {
-          // Ignore send errors - will reconnect if disconnected
-        }
-      }
-    }, 2 * 60 * 1000)
+    this.heartbeatInterval = setInterval(() => this.heartbeatTick(), 2 * 60 * 1000)
+  }
+
+  private heartbeatTick(): void {
+    if (!this.ws || !this.isConnected) return
+
+    if (this.missedPongs >= MAX_MISSED_PONGS) {
+      console.log(`[Platform] ${this.missedPongs} pongs missed — forcing reconnect`)
+      this.missedPongs = 0
+      this.stopHeartbeat()
+      try { this.ws.close() } catch { /* ignore */ }
+      return
+    }
+    this.missedPongs++
+    try {
+      this.ws.send(JSON.stringify({ type: 'ping' }))
+    } catch {
+      // Send failed — onclose will handle reconnect
+    }
   }
 
   /**
@@ -363,7 +381,7 @@ export class PlatformConnection {
         break
 
       case 'pong':
-        // Heartbeat response, ignore
+        this.missedPongs = 0
         break
 
       default:

package/server/services/terminal/pty-manager.ts

@@ -312,7 +312,9 @@ export class PTYManager extends EventEmitter {
       // wraps echoed chars in multi-part ANSI sequences (RPROMPT, syntax highlighting).
       // A longer window on macOS ensures these multi-part sequences arrive as one chunk,
       // which the browser's predictive echo can match correctly.
-      const OUTPUT_COALESCE_MS = platform() === 'darwin' ? 24 : 8;
+      // 32ms on macOS captures full zsh redraw cycles (RPROMPT + syntax highlighting)
+      // that 24ms often split across coalesce boundaries.
+      const OUTPUT_COALESCE_MS = platform() === 'darwin' ? 32 : 8;
       // High-water mark: flush immediately when buffer exceeds this size
       // to prevent unbounded memory growth during high-output commands (e.g. `yes`)
       const OUTPUT_HIGH_WATER = 64 * 1024; // 64KB

package/server/services/websocket/handler.ts

@@ -19,6 +19,7 @@ import { handleFileExplorerMessage, handleFileMessage } from './file-explorer-ha
 import { FileUploadHandler } from './file-upload-handler.js';
 import { handleGitMessage } from './git-handlers.js';
 import type { HandlerContext, UsageReporter } from './handler-context.js';
+import { handleQualityMessage } from './quality-handlers.js';
 import { handleHistoryMessage, handleSessionMessage, initializeTab, resumeHistoricalSession } from './session-handlers.js';
 import { SessionRegistry } from './session-registry.js';
 import { generateNotificationSummary, handleGetSettings, handleUpdateSettings } from './settings-handlers.js';
@@ -220,6 +221,12 @@ export class WebSocketImproviseHandler implements HandlerContext {
         return handleRemoveTab(this, ws, tabId, workingDir);
       case 'markTabViewed':
         return handleMarkTabViewed(this, ws, tabId, workingDir);
+      // Quality messages
+      case 'qualityDetectTools':
+      case 'qualityScan':
+      case 'qualityInstallTools':
+      case 'qualityCodeReview':
+        return handleQualityMessage(this, ws, msg, tabId, workingDir);
       // Settings messages
       case 'getSettings':
         return handleGetSettings(this, ws);
@@ -291,6 +298,4 @@ export class WebSocketImproviseHandler implements HandlerContext {
     this.sessions.delete(sessionId);
   }
 
-  cleanupStaleSessions(): void {
-  }
 }

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

@@ -0,0 +1,140 @@
+// Copyright (c) 2025-present Mstro, Inc. All rights reserved.
+// Licensed under the MIT License. See LICENSE file for details.
+
+import { join } from 'node:path';
+import type { HandlerContext } from './handler-context.js';
+import { detectTools, installTools, runQualityScan } from './quality-service.js';
+import type { WebSocketMessage, WSContext } from './types.js';
+
+export function handleQualityMessage(
+  ctx: HandlerContext,
+  ws: WSContext,
+  msg: WebSocketMessage,
+  _tabId: string,
+  workingDir: string,
+): void {
+  const handlers: Record<string, () => void> = {
+    qualityDetectTools: () => handleDetectTools(ctx, ws, msg, workingDir),
+    qualityScan: () => handleScan(ctx, ws, msg, workingDir),
+    qualityInstallTools: () => handleInstallTools(ctx, ws, msg, workingDir),
+    qualityCodeReview: () => handleCodeReview(ctx, ws, msg, workingDir),
+  };
+
+  const handler = handlers[msg.type];
+  if (!handler) return;
+
+  try {
+    handler();
+  } catch (error) {
+    const errMsg = error instanceof Error ? error.message : String(error);
+    ctx.send(ws, {
+      type: 'qualityError',
+      data: { path: msg.data?.path || workingDir, error: errMsg },
+    });
+  }
+}
+
+function resolvePath(workingDir: string, dirPath?: string): string {
+  if (!dirPath || dirPath === '.' || dirPath === './') return workingDir;
+  if (dirPath.startsWith('/')) return dirPath;
+  return join(workingDir, dirPath);
+}
+
+async function handleDetectTools(
+  ctx: HandlerContext,
+  ws: WSContext,
+  msg: WebSocketMessage,
+  workingDir: string,
+): Promise<void> {
+  const dirPath = resolvePath(workingDir, msg.data?.path);
+  try {
+    const { tools, ecosystem } = await detectTools(dirPath);
+    ctx.send(ws, {
+      type: 'qualityToolsDetected',
+      data: { path: msg.data?.path || '.', tools, ecosystem },
+    });
+  } catch (error) {
+    ctx.send(ws, {
+      type: 'qualityError',
+      data: { path: msg.data?.path || '.', error: error instanceof Error ? error.message : String(error) },
+    });
+  }
+}
+
+async function handleScan(
+  ctx: HandlerContext,
+  ws: WSContext,
+  msg: WebSocketMessage,
+  workingDir: string,
+): Promise<void> {
+  const dirPath = resolvePath(workingDir, msg.data?.path);
+  const reportPath = msg.data?.path || '.';
+
+  try {
+    const results = await runQualityScan(dirPath, (progress) => {
+      ctx.send(ws, {
+        type: 'qualityScanProgress',
+        data: { path: reportPath, progress },
+      });
+    });
+    ctx.send(ws, {
+      type: 'qualityScanResults',
+      data: { path: reportPath, results },
+    });
+  } catch (error) {
+    ctx.send(ws, {
+      type: 'qualityError',
+      data: { path: reportPath, error: error instanceof Error ? error.message : String(error) },
+    });
+  }
+}
+
+async function handleInstallTools(
+  ctx: HandlerContext,
+  ws: WSContext,
+  msg: WebSocketMessage,
+  workingDir: string,
+): Promise<void> {
+  const dirPath = resolvePath(workingDir, msg.data?.path);
+  const reportPath = msg.data?.path || '.';
+  const toolNames: string[] | undefined = msg.data?.tools;
+
+  try {
+    ctx.send(ws, {
+      type: 'qualityInstallProgress',
+      data: { path: reportPath, installing: true },
+    });
+
+    const { tools, ecosystem } = await installTools(dirPath, toolNames);
+
+    ctx.send(ws, {
+      type: 'qualityInstallComplete',
+      data: { path: reportPath, tools, ecosystem },
+    });
+  } catch (error) {
+    ctx.send(ws, {
+      type: 'qualityError',
+      data: { path: reportPath, error: error instanceof Error ? error.message : String(error) },
+    });
+  }
+}
+
+async function handleCodeReview(
+  ctx: HandlerContext,
+  ws: WSContext,
+  msg: WebSocketMessage,
+  _workingDir: string,
+): Promise<void> {
+  const reportPath = msg.data?.path || '.';
+
+  // Code review via headless Claude will be implemented in a follow-up.
+  // For now, send an empty result to unblock the UI.
+  ctx.send(ws, {
+    type: 'qualityCodeReview',
+    data: {
+      path: reportPath,
+      findings: [],
+      summary: 'Code review requires a Claude Code session. Run from the Chat view for a detailed code review.',
+    },
+  });
+}