mstro-app 0.5.1 → 0.5.6

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

@@ -63,38 +63,52 @@ async function redirectToWorktreeIfBranchCheckedOut(
 
 export async function handleGitCheckout(ctx: HandlerContext, ws: WSContext, msg: WebSocketMessage, tabId: string, workingDir: string, rootWorkingDir: string): Promise<void> {
   try {
-    const { branch, create, startPoint } = msg.data || {};
+    const { branch, create, startPoint, worktreePath } = msg.data || {};
     if (!branch) {
       ctx.send(ws, { type: 'gitError', tabId, data: { error: 'Branch name is required' } });
       return;
     }
 
+    // `worktreePath` lets the caller target a specific working directory
+    // (typically the main repo) regardless of which tab is active. Used by
+    // the "Base branch" dropdown so checkout always lands on main, not on
+    // whichever worktree the user happened to be inspecting.
+    const targetDir = typeof worktreePath === 'string' && worktreePath.length > 0
+      ? worktreePath
+      : workingDir;
+
     // Skip the worktree redirect for `create` — a name collision there is a real user error.
-    if (!create && await redirectToWorktreeIfBranchCheckedOut(ctx, ws, tabId, branch, workingDir, rootWorkingDir)) {
+    if (!create && await redirectToWorktreeIfBranchCheckedOut(ctx, ws, tabId, branch, targetDir, rootWorkingDir)) {
       return;
     }
 
-    const statusResult = await executeGitCommand(['status', '--porcelain'], workingDir);
+    const statusResult = await executeGitCommand(['status', '--porcelain'], targetDir);
     if (statusResult.stdout.trim()) {
       ctx.send(ws, { type: 'gitError', tabId, data: { error: 'Commit or stash changes before switching branches' } });
       return;
     }
 
-    const prevResult = await executeGitCommand(['rev-parse', '--abbrev-ref', 'HEAD'], workingDir);
+    const prevResult = await executeGitCommand(['rev-parse', '--abbrev-ref', 'HEAD'], targetDir);
     const previous = prevResult.stdout.trim();
 
     const args = create
       ? ['checkout', '-b', branch, ...(startPoint ? [startPoint] : [])]
       : ['checkout', branch];
 
-    const result = await executeGitCommand(args, workingDir);
+    const result = await executeGitCommand(args, targetDir);
     if (result.exitCode !== 0) {
       ctx.send(ws, { type: 'gitError', tabId, data: { error: result.stderr || 'Failed to checkout branch' } });
       return;
     }
 
     ctx.send(ws, { type: 'gitCheckedOut', tabId, data: { branch, previous } });
-    // Re-fetch status after checkout - import handleGitStatus at call site
+    // Re-fetch status for the *tab's* dir (`workingDir`), not `targetDir`. When
+    // the caller targets a different directory via `worktreePath` (e.g. the
+    // main repo from a worktree-anchored tab), sending main-repo status keyed
+    // to the tab id would clobber the tab's worktree-scoped status display.
+    // The web side fires a fresh `gitStatus` + `gitWorktreeList` on the
+    // `gitCheckedOut` handler, so the main-repo branch update propagates via
+    // the worktree list refresh.
     const { handleGitStatus } = await import('./git-handlers.js');
     handleGitStatus(ctx, ws, tabId, workingDir);
   } catch (error: unknown) {

package/server/services/websocket/handler.ts

@@ -12,8 +12,10 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
 import type { ImprovisationSessionManager } from '../../cli/improvisation-session-manager.js';
+import type { InstanceRegistry } from '../instances.js';
 import { captureException } from '../sentry.js';
 import { getPTYManager } from '../terminal/pty-manager.js';
+import { resolvePendingQuestion } from './ask-user-question-bridge.js';
 import { AutocompleteService } from './autocomplete.js';
 import { FileDownloadHandler } from './file-download-handler.js';
 import { handleFileExplorerMessage, handleFileMessage } from './file-explorer-handlers.js';
@@ -30,7 +32,7 @@ import { generateNotificationSummary, handleGetSettings, handleUpdateSettings }
 import { handleListSkills } from './skill-handlers.js';
 import { SkillsWatcher } from './skill-watcher.js';
 import { TabEventBufferRegistry } from './tab-event-buffer.js';
-import { handleCreateTab, handleGetActiveTabs, handleMarkTabViewed, handleRemoveTab, handleReorderTabs, handleSyncTabMeta } from './tab-handlers.js';
+import { handleCreateTab, handleGetActiveTabs, handleMarkTabViewed, handleRemoveTab, handleReorderTabs, handleSetTabEngine, handleSyncTabMeta } from './tab-handlers.js';
 import { cleanupTerminalSubscribers, handleTerminalMessage } from './terminal-handlers.js';
 import type { FrecencyData, WebSocketMessage, WebSocketResponse, WSContext } from './types.js';
 
@@ -55,11 +57,14 @@ export class WebSocketImproviseHandler implements HandlerContext {
   skillsWatcher: SkillsWatcher | null = null;
   tabEventBuffers: TabEventBufferRegistry = new TabEventBufferRegistry();
   msgIdTracker: MsgIdTracker = new MsgIdTracker();
+  private instanceRegistry: InstanceRegistry | null;
+  private shutdownInProgress = false;
 
-  constructor() {
+  constructor(instanceRegistry: InstanceRegistry | null = null) {
     this.frecencyPath = join(homedir(), '.mstro', 'autocomplete-frecency.json');
     const frecencyData = this.loadFrecencyData();
     this.autocompleteService = new AutocompleteService(frecencyData);
+    this.instanceRegistry = instanceRegistry;
     process.on('exit', () => {
       if (this.frecencySaveTimer) {
         clearTimeout(this.frecencySaveTimer);
@@ -201,6 +206,9 @@ export class WebSocketImproviseHandler implements HandlerContext {
         return handleRemoveTab(this, ws, tabId, workingDir);
       case 'markTabViewed':
         return handleMarkTabViewed(this, ws, tabId, workingDir);
+      case 'setTabEngine':
+        if (permission === 'view') return;
+        return handleSetTabEngine(this, ws, msg, tabId, workingDir);
       case 'getSettings':
         return handleGetSettings(this, ws);
       case 'updateSettings':
@@ -208,6 +216,11 @@ export class WebSocketImproviseHandler implements HandlerContext {
         return handleUpdateSettings(this, ws, msg);
       case 'listSkills':
         return handleListSkills(this, ws, workingDir);
+      case 'shutdownInstance':
+        return this.handleShutdownInstance(ws, permission);
+      case 'askUserQuestionResponse':
+        if (permission === 'view') return;
+        return this.handleAskUserQuestionResponse(msg, tabId);
     }
 
     // Dispatch table lookup for domain handlers
@@ -382,4 +395,78 @@ export class WebSocketImproviseHandler implements HandlerContext {
     this.sessions.delete(sessionId);
   }
 
+  /**
+   * Resolve a pending AskUserQuestion call with the user's answers. The
+   * bouncer subprocess is awaiting on the bridge promise; calling
+   * `resolvePendingQuestion` releases it so Claude resumes with the answers.
+   * Stale toolUseIds are no-ops — likely the question already timed out or
+   * was cancelled, and a stale web client is replaying its submission.
+   */
+  private handleAskUserQuestionResponse(msg: WebSocketMessage, tabId: string): void {
+    const data = msg.data as { toolUseId?: unknown; answers?: unknown } | undefined;
+    const toolUseId = typeof data?.toolUseId === 'string' ? data.toolUseId : '';
+    const answersIn = data?.answers;
+    if (!toolUseId) return;
+
+    // Only accept a flat string-string map; coerce safely so a malformed
+    // payload doesn't crash the bridge.
+    const answers: Record<string, string> = {};
+    if (answersIn && typeof answersIn === 'object' && !Array.isArray(answersIn)) {
+      for (const [k, v] of Object.entries(answersIn as Record<string, unknown>)) {
+        if (typeof v === 'string') answers[k] = v;
+      }
+    }
+
+    void tabId; // tabId is informational; the toolUseId is the unique key
+    resolvePendingQuestion(toolUseId, answers);
+  }
+
+  /**
+   * Handle a `shutdownInstance` control message from a web client.
+   *
+   * Authorization: only the orchestra owner may shut down. The relay tags
+   * shared (view-only) users with `_permission: 'view'`; absence means the
+   * requester is the owner whose CLI this is. View-only requests are
+   * rejected with a `forbidden` error rather than silently dropped so the
+   * UI can surface "you're not the owner" to non-owners.
+   *
+   * Idempotency: a shutdown already in progress is acked (broadcast +
+   * exit timer were already scheduled) but does not stack a second timer.
+   */
+  private handleShutdownInstance(ws: WSContext, permission: 'view' | undefined): void {
+    if (permission === 'view') {
+      console.log('[WebSocketImproviseHandler] Rejecting shutdownInstance from view-only user');
+      this.send(ws, {
+        type: 'error',
+        data: {
+          code: 'forbidden',
+          message: 'Only the owner can shut down this instance.'
+        }
+      });
+      return;
+    }
+
+    if (this.shutdownInProgress) {
+      console.log('[WebSocketImproviseHandler] shutdownInstance already in progress — ignoring duplicate request');
+      return;
+    }
+    this.shutdownInProgress = true;
+
+    // The CLI knows the request came from the owner (the relay only forwards
+    // owner traffic without a `_permission` tag), but does not receive the
+    // owner's userId on the wire. Logged as 'owner' for the audit trail.
+    console.log('[WebSocketImproviseHandler] shutdownInstance requested by owner — broadcasting shuttingDown and exiting');
+
+    this.broadcastToAll({ type: 'shuttingDown', data: { reason: 'user-requested' } });
+
+    // Mirrors the HTTP /api/shutdown route's 100ms delay so the broadcast
+    // has a chance to flush before process.exit tears down the socket.
+    setTimeout(() => {
+      if (this.instanceRegistry) {
+        this.instanceRegistry.unregister();
+      }
+      process.exit(0);
+    }, 100);
+  }
+
 }

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

@@ -1,7 +1,7 @@
 // Copyright (c) 2025-present Mstro, Inc. All rights reserved.
 
 import { extname, relative } from 'node:path';
-import { chunkFileList, filesByExt, runCommand, type SourceFile } from './quality-tools.js';
+import { chunkFileList, filesByExt, isTestFile, runCommand, type SourceFile } from './quality-tools.js';
 import { biomeDiagToFinding, type Ecosystem, FUNCTION_LENGTH_THRESHOLD, isBiomeComplexityDiagnostic, isEslintComplexityRule, type QualityFinding } from './quality-types.js';
 
 const NODE_COMPLEXITY_EXTS = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'];
@@ -16,6 +16,26 @@ interface FunctionInfo {
   file: string;
   startLine: number;
   lines: number;
+  /** Approximate cyclomatic complexity (count of decision points). */
+  branches: number;
+}
+
+/**
+ * Decision-point keywords that approximate cyclomatic complexity. We count
+ * occurrences as a cheap proxy — McCabe's exact metric requires AST parsing,
+ * but the keyword count is highly correlated and good enough to distinguish
+ * "long but linear" (a flat sequence of statements) from "long and branchy"
+ * (deeply nested control flow).
+ *
+ * The user's task 2 requirement: "a 1000 line file might be just fine, not
+ * a violation at all, while another 1000 line file might be a severe mix of
+ * concerns" — same applies to functions. A long config-builder with one
+ * return statement is fine; a long monster with 40 if-branches is not.
+ */
+const BRANCH_KEYWORDS = /\b(?:if|else if|elif|for|while|case|catch|\?\s*\w|&&|\|\||\?\?)\b/g;
+
+function countBranches(body: string): number {
+  return (body.match(BRANCH_KEYWORDS) || []).length;
 }
 
 const JS_FUNC_PATTERN = /^(\s*)(export\s+)?(async\s+)?function\s+(\w+)|^(\s*)(export\s+)?(const|let|var)\s+(\w+)\s*=\s*(async\s+)?\(|^(\s*)(public|private|protected)?\s*(async\s+)?(\w+)\s*\(/;
@@ -56,11 +76,15 @@ function extractJsFunctions(file: SourceFile): FunctionInfo[] {
     braceDepth += countBraceDeltas(lines[i]);
 
     if (currentFunc && braceDepth <= funcStartBraceDepth && i > currentFunc.startLine - 1) {
+      const startLine = currentFunc.startLine;
+      const endLine = i + 1;
+      const body = lines.slice(startLine - 1, endLine).join('\n');
       functions.push({
         name: currentFunc.name,
         file: file.relativePath,
-        startLine: currentFunc.startLine,
-        lines: i + 1 - currentFunc.startLine + 1,
+        startLine,
+        lines: endLine - startLine + 1,
+        branches: countBranches(body),
       });
       currentFunc = null;
     }
@@ -75,35 +99,29 @@ function extractPyFunctions(file: SourceFile): FunctionInfo[] {
   const defPattern = /^(\s*)(async\s+)?def\s+(\w+)/;
   let currentFunc: { name: string; startLine: number; indent: number } | null = null;
 
+  const recordFunction = (name: string, startLine: number, endLine: number) => {
+    const body = lines.slice(startLine - 1, endLine).join('\n');
+    functions.push({
+      name,
+      file: file.relativePath,
+      startLine,
+      lines: endLine - startLine + 1,
+      branches: countBranches(body),
+    });
+  };
+
   for (let i = 0; i < lines.length; i++) {
     const match = defPattern.exec(lines[i]);
     if (match) {
-      if (currentFunc) {
-        functions.push({
-          name: currentFunc.name,
-          file: file.relativePath,
-          startLine: currentFunc.startLine,
-          lines: i - currentFunc.startLine + 1,
-        });
-      }
+      if (currentFunc) recordFunction(currentFunc.name, currentFunc.startLine, i);
       currentFunc = { name: match[3], startLine: i + 1, indent: match[1].length };
     } else if (currentFunc && lines[i].trim() && !lines[i].startsWith(' '.repeat(currentFunc.indent + 1)) && !lines[i].startsWith('\t')) {
-      functions.push({
-        name: currentFunc.name,
-        file: file.relativePath,
-        startLine: currentFunc.startLine,
-        lines: i - currentFunc.startLine + 1,
-      });
+      recordFunction(currentFunc.name, currentFunc.startLine, i);
       currentFunc = null;
     }
   }
   if (currentFunc) {
-    functions.push({
-      name: currentFunc.name,
-      file: file.relativePath,
-      startLine: currentFunc.startLine,
-      lines: lines.length - currentFunc.startLine + 1,
-    });
+    recordFunction(currentFunc.name, currentFunc.startLine, lines.length);
   }
 
   return functions;
@@ -116,9 +134,37 @@ function extractFunctions(file: SourceFile): FunctionInfo[] {
   return [];
 }
 
+/**
+ * Map a function's branch density (decision points per N lines) to a
+ * severity level for the function-length finding. Returns `null` to suppress
+ * the finding for a long but linear function — e.g., a config-builder with
+ * one return statement and 200 lines of property assignments.
+ *
+ * Heuristic: McCabe's cyclomatic complexity threshold is ~10. Above that,
+ * functions are hard to test. We grade severity by branches-per-50-lines so
+ * a 100-line function with 5 branches looks the same as a 50-line function
+ * with 5 branches (both ~industry "consider refactoring" zone).
+ *
+ * Functions absurdly long (>5x threshold) emit a finding regardless of
+ * branchiness — a 250-line function is too much to read in one sitting even
+ * if it's "linear."
+ */
+function severityFromBranchiness(branches: number, lines: number): QualityFinding['severity'] | null {
+  const branchesPer50 = (branches * 50) / Math.max(1, lines);
+  const isAbsurd = lines > FUNCTION_LENGTH_THRESHOLD * 5;
+  if (branchesPer50 < 3 && !isAbsurd) return null; // Long but linear — not really a violation.
+  if (branchesPer50 < 6) return 'low';
+  if (branchesPer50 < 10) return 'medium';
+  return 'high';
+}
+
 export function analyzeFunctionLength(files: SourceFile[]): { score: number; findings: QualityFinding[]; issueCount: number } {
   const allFunctions: FunctionInfo[] = [];
   for (const file of files) {
+    // Test files are exempt: a long `it()`/`describe()` body is normal and
+    // splitting it produces churn without improving readability. Linting
+    // and other quality checks still apply — only structural-length defers.
+    if (isTestFile(file.relativePath)) continue;
     allFunctions.push(...extractFunctions(file));
   }
 
@@ -133,13 +179,21 @@ export function analyzeFunctionLength(files: SourceFile[]): { score: number; fin
     totalScore += funcScore;
 
     if (func.lines > FUNCTION_LENGTH_THRESHOLD) {
+      const severity = severityFromBranchiness(func.branches, func.lines);
+      if (!severity) continue; // Long but linear — not flagged.
+
       findings.push({
-        severity: func.lines > FUNCTION_LENGTH_THRESHOLD * 3 ? 'high' : func.lines > FUNCTION_LENGTH_THRESHOLD * 2 ? 'medium' : 'low',
+        severity,
         category: 'function-length',
         file: func.file,
         line: func.startLine,
-        title: `${func.name}() has ${func.lines} lines (threshold: ${FUNCTION_LENGTH_THRESHOLD})`,
-        description: `Function "${func.name}" exceeds the recommended length by ${func.lines - FUNCTION_LENGTH_THRESHOLD} lines.`,
+        title: `${func.name}() has ${func.lines} lines, ~${func.branches} branches`,
+        description:
+          `Function "${func.name}" exceeds the ${FUNCTION_LENGTH_THRESHOLD}-line threshold by ${func.lines - FUNCTION_LENGTH_THRESHOLD} lines ` +
+          `with approximately ${func.branches} decision points (cyclomatic complexity proxy). ` +
+          (severity === 'high'
+            ? 'High branchiness makes this hard to test and review — extract sub-functions or simplify control flow.'
+            : 'Long but with manageable branching — consider extracting helpers if the function does multiple things.'),
       });
     }
   }

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

@@ -0,0 +1,155 @@
+// Copyright (c) 2025-present Mstro, Inc. All rights reserved.
+
+/**
+ * Quality ETA — duration estimation for scan + AI review operations.
+ *
+ * Uses persisted history when available (most accurate), falls back to a
+ * simple heuristic derived from file count + line count when there is no
+ * history yet (cold start).
+ *
+ * Estimates are intentionally conservative: better to over-estimate by a bit
+ * and have the bar finish "early" than to under-estimate and have the bar
+ * sit at 100% while work continues — the latter destroys trust in the ETA.
+ */
+
+import type { QualityHistoryEntry } from './quality-persistence.js';
+
+// ── Heuristic constants ──────────────────────────────────────
+//
+// Numbers tuned against typical TypeScript codebases (mstro cli/server/web)
+// observed in the wild — see history.json for the corpus. Treat them as
+// reasonable defaults that the history-based path will quickly correct once
+// real durations land in storage.
+
+/** Per-file overhead for a CLI scan (linting, formatting, file/function-length checks). */
+const SCAN_PER_FILE_MS = 250;
+/** Per-1000-LOC overhead for a CLI scan, dominated by `tsc --noEmit` on TS projects. */
+const SCAN_PER_KLOC_MS = 800;
+/** Fixed overhead per scan: tool detection, file collection, score computation. */
+const SCAN_FIXED_MS = 8_000;
+/** Floor — the smallest "I'm doing something" we should ever show. */
+const SCAN_MIN_MS = 5_000;
+
+/** Per-file overhead for the AI code-review agent (Claude Read calls, validation). */
+const REVIEW_PER_FILE_MS = 1_200;
+/** Per-1000-LOC overhead for the AI code-review agent. */
+const REVIEW_PER_KLOC_MS = 2_500;
+/** Fixed overhead per review: Claude spawn, prompt building, persistence. */
+const REVIEW_FIXED_MS = 25_000;
+/** Floor for the review estimate. */
+const REVIEW_MIN_MS = 30_000;
+
+// ── History smoothing ────────────────────────────────────────
+//
+// Use the last few real durations for the same directory and weight them by
+// recency. A single one-off slow run shouldn't dominate the estimate, but
+// fresh data should outweigh stale data (codebase grew, machine got faster,
+// etc.).
+const MAX_HISTORY_SAMPLES = 5;
+
+interface HistoryEntryWithTimings extends QualityHistoryEntry {
+  scanDurationMs?: number;
+  reviewDurationMs?: number;
+}
+
+function recentDurations(
+  history: HistoryEntryWithTimings[],
+  dirPath: string,
+  field: 'scanDurationMs' | 'reviewDurationMs',
+): number[] {
+  const values: number[] = [];
+  // Walk newest → oldest; only consider entries that actually touched this directory.
+  for (let i = history.length - 1; i >= 0 && values.length < MAX_HISTORY_SAMPLES; i--) {
+    const entry = history[i];
+    if (!entry.directories.some((d) => d.path === dirPath)) continue;
+    const v = entry[field];
+    if (typeof v === 'number' && v > 0) values.push(v);
+  }
+  return values;
+}
+
+/**
+ * Weighted average favouring newer samples. Weights are 1, 2, 3, 4, 5 for the
+ * 5 most-recent runs (newest first → highest weight) — a "this run mostly
+ * matters" curve that still smooths over a single anomaly.
+ */
+function weightedRecentAverage(values: number[]): number | null {
+  if (values.length === 0) return null;
+  let weightSum = 0;
+  let valueSum = 0;
+  // values[0] is newest, so its weight is `values.length`.
+  for (let i = 0; i < values.length; i++) {
+    const w = values.length - i;
+    valueSum += values[i] * w;
+    weightSum += w;
+  }
+  return weightSum > 0 ? valueSum / weightSum : null;
+}
+
+// ── Public API ────────────────────────────────────────────────
+
+export interface CodebaseSize {
+  /** Number of source files the scan/review will analyse. */
+  files: number;
+  /** Total lines across those files. */
+  lines: number;
+}
+
+/**
+ * Heuristic estimate for a CLI scan when we have no history. Combines a fixed
+ * floor with per-file + per-KLOC components — `tsc --noEmit` and lint scale
+ * with codebase size, so scaling on both files and lines maps reality better
+ * than scaling on either alone.
+ */
+export function heuristicScanMs({ files, lines }: CodebaseSize): number {
+  const kloc = Math.max(0, lines) / 1_000;
+  const raw = SCAN_FIXED_MS + files * SCAN_PER_FILE_MS + kloc * SCAN_PER_KLOC_MS;
+  return Math.max(SCAN_MIN_MS, Math.round(raw));
+}
+
+/** Heuristic estimate for the AI review agent when we have no history. */
+export function heuristicReviewMs({ files, lines }: CodebaseSize): number {
+  const kloc = Math.max(0, lines) / 1_000;
+  const raw = REVIEW_FIXED_MS + files * REVIEW_PER_FILE_MS + kloc * REVIEW_PER_KLOC_MS;
+  return Math.max(REVIEW_MIN_MS, Math.round(raw));
+}
+
+/**
+ * Best-available ETA for a CLI scan. Prefers a weighted average of recent
+ * durations for this exact directory; falls back to the heuristic when no
+ * timing history exists.
+ */
+export function estimateScanMs(
+  size: CodebaseSize,
+  history: HistoryEntryWithTimings[],
+  dirPath: string,
+): number {
+  const recent = recentDurations(history, dirPath, 'scanDurationMs');
+  const fromHistory = weightedRecentAverage(recent);
+  if (fromHistory !== null) return Math.max(SCAN_MIN_MS, Math.round(fromHistory));
+  return heuristicScanMs(size);
+}
+
+/** Best-available ETA for the AI code-review agent. Same fallback shape as `estimateScanMs`. */
+export function estimateReviewMs(
+  size: CodebaseSize,
+  history: HistoryEntryWithTimings[],
+  dirPath: string,
+): number {
+  const recent = recentDurations(history, dirPath, 'reviewDurationMs');
+  const fromHistory = weightedRecentAverage(recent);
+  if (fromHistory !== null) return Math.max(REVIEW_MIN_MS, Math.round(fromHistory));
+  return heuristicReviewMs(size);
+}
+
+/**
+ * Estimate codebase size from a directory using the same fast traversal the
+ * scan itself uses. Pulled out as a thin wrapper so the handler can call it
+ * before kicking off the scan to compute an initial ETA.
+ */
+export async function estimateCodebaseSize(dirPath: string): Promise<CodebaseSize> {
+  const { collectSourceFiles } = await import('./quality-tools.js');
+  const files = await collectSourceFiles(dirPath, dirPath);
+  const lines = files.reduce((sum, f) => sum + f.lines, 0);
+  return { files: files.length, lines };
+}