mstro-app 0.4.52 → 0.5.0

package/server/server-setup.ts

@@ -9,8 +9,13 @@
  */
 
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import type { IncomingMessage } from 'node:http'
 import { basename, join } from 'node:path'
-import type { WebSocket as NodeWebSocket } from 'ws'
+import type { WebSocket as NodeWebSocket, WebSocketServer } from 'ws'
+import type { AuthService } from './services/auth.js'
+import { PlatformConnection } from './services/platform.js'
+import { captureException } from './services/sentry.js'
+import type { WebSocketImproviseHandler } from './services/websocket/index.js'
 import type { WSContext } from './services/websocket/types.js'
 
 /**
@@ -112,3 +117,123 @@ export function createPlatformRelayContext(
     _isPlatformRelay: true
   } as WSContext
 }
+
+/** Strip the privileged `_permission` field from inbound local messages. */
+function sanitizeLocalMessage(raw: Buffer | string): string {
+  const message = typeof raw === 'string' ? raw : raw.toString('utf-8')
+  if (!message.includes('_permission')) return message
+  try {
+    const parsed = JSON.parse(message)
+    if ('_permission' in parsed) {
+      delete parsed._permission
+      return JSON.stringify(parsed)
+    }
+  } catch { /* not JSON — pass through */ }
+  return message
+}
+
+/** Attach the local WebSocket connection handler to the WebSocketServer. */
+export function attachLocalWebSocketRouting(opts: {
+  wss: WebSocketServer
+  port: number
+  workingDir: string
+  authService: AuthService
+  wsHandler: WebSocketImproviseHandler
+}): void {
+  const { wss, port, workingDir, authService, wsHandler } = opts
+
+  wss.on('connection', (ws: NodeWebSocket, req: IncomingMessage) => {
+    const url = new URL(req.url || '/', `http://localhost:${port}`)
+    if (url.pathname !== '/ws') {
+      ws.close(1008, 'Invalid WebSocket path')
+      return
+    }
+
+    const wsToken = url.searchParams.get('token')
+    if (!wsToken || !authService.validateLocalToken(wsToken)) {
+      ws.close(4001, 'Unauthorized')
+      return
+    }
+
+    const wrappedWs = wrapWebSocket(ws, workingDir)
+    wsHandler.handleConnection(wrappedWs, workingDir)
+
+    ws.on('message', (data: Buffer | string) => {
+      wsHandler.handleMessage(wrappedWs, sanitizeLocalMessage(data), workingDir)
+    })
+    ws.on('close', () => wsHandler.handleClose(wrappedWs))
+    ws.on('error', (error: Error) => {
+      console.error('[WebSocket] Error:', error)
+      captureException(error, { context: 'websocket.connection' })
+    })
+  })
+}
+
+/** Connect to the platform relay and wire up message bridging to the local wsHandler. */
+export function createPlatformRelay(workingDir: string, wsHandler: WebSocketImproviseHandler): PlatformConnection {
+  let platformRelayContext: WSContext | null = null
+  let pendingRelayMessages: unknown[] = []
+
+  const platformConnection = new PlatformConnection(workingDir, {
+    onConnected: () => {
+      console.log(`Connected: https://mstro.app`)
+      wsHandler.setUsageReporter((report) => {
+        platformConnection.send({ type: 'reportUsage', data: report })
+      })
+    },
+    onDisconnected: () => {
+      if (platformRelayContext) {
+        wsHandler.handleClose(platformRelayContext)
+        platformRelayContext = null
+      }
+      pendingRelayMessages = []
+    },
+    onWebConnected: () => {
+      if (platformRelayContext) {
+        wsHandler.handleClose(platformRelayContext)
+      }
+      platformRelayContext = createPlatformRelayContext(
+        (message) => platformConnection.send(message),
+        workingDir
+      )
+      wsHandler.handleConnection(platformRelayContext, workingDir)
+      if (pendingRelayMessages.length > 0) {
+        for (const message of pendingRelayMessages) {
+          wsHandler.handleMessage(platformRelayContext, JSON.stringify(message), workingDir)
+        }
+        pendingRelayMessages = []
+      }
+    },
+    onWebDisconnected: () => {
+      if (platformRelayContext) {
+        wsHandler.handleClose(platformRelayContext)
+        platformRelayContext = null
+      }
+      pendingRelayMessages = []
+    },
+    onRelayedMessage: (message) => {
+      if (platformRelayContext) {
+        wsHandler.handleMessage(platformRelayContext, JSON.stringify(message), workingDir)
+      } else {
+        // Cap pending messages to prevent unbounded memory growth while disconnected
+        if (pendingRelayMessages.length < 100) {
+          pendingRelayMessages.push(message)
+        }
+      }
+    }
+  })
+  platformConnection.connect()
+  return platformConnection
+}
+
+/** Install process-level error handlers that capture to Sentry. */
+export function registerProcessErrorHandlers(): void {
+  process.on('uncaughtException', (err) => {
+    console.error('[Server] Uncaught exception:', err)
+    captureException(err, { context: 'uncaughtException' })
+  })
+  process.on('unhandledRejection', (reason) => {
+    console.error('[Server] Unhandled rejection:', reason)
+    captureException(reason instanceof Error ? reason : new Error(String(reason)), { context: 'unhandledRejection' })
+  })
+}

package/server/services/plan/agents/assess-stall.md

@@ -1,10 +1,10 @@
 ---
 name: assess-stall
-description: "Process health monitor that determines if a Claude Code subprocess is working or stalled based on silence duration, tool activity, and task context. Internal Haiku assessment."
+description: "Process health monitor that determines if a Claude Code subprocess is working or stalled based on silence duration, total elapsed runtime, tool activity, and task complexity. Internal Haiku assessment."
 user-invocable: false
 ---
 
-You are a process health monitor. A Claude Code subprocess has been silent (no stdout) and you must determine if it is working or stalled.
+You are a process health monitor. A Claude Code subprocess has gone silent (no stdout) and you must determine if it is working or stalled.
 
 Silent for: {{silenceMin}} minutes
 Total runtime: {{totalMin}} minutes
@@ -15,7 +15,14 @@ Total tool calls this session: {{totalToolCalls}}
 {{tokenLine}}
 Task being executed: {{promptPreview}}
 
+Weigh BOTH silence and total runtime against task complexity.
+
+- Simple tasks (single Read/Write, one-liner edit, `ls` a directory, trivial greps) should finish in a minute or two. If total runtime has already far exceeded what the task should need, verdict STALLED even if silence is short — something has clearly gone wrong.
+- Complex tasks (agent teams with subagents, multi-step migrations, large refactors, dependency installs, board implementations) can legitimately run for hours. Extend generously when pending tool activity, subagents, or the prompt itself justify a long run.
+- Recent token activity (see token line above) = process is alive and streaming; strongly favor WORKING.
+- Absence of any tool calls + long runtime + no token activity = strong STALLED signal.
+
 Respond in EXACTLY this format (3 lines, no extra text):
 VERDICT: WORKING or STALLED
-MINUTES: <number 5-30, only if WORKING, how many more minutes to allow>
-REASON: <brief one-line explanation>
+MINUTES: <integer 5-180, only if WORKING, how many more minutes to allow>
+REASON: <brief one-line explanation that references task complexity vs elapsed time>

package/server/services/plan/board-config.ts

@@ -0,0 +1,122 @@
+// Copyright (c) 2025-present Mstro, Inc. All rights reserved.
+// Licensed under the MIT License. See LICENSE file for details.
+
+/**
+ * Board configuration helpers: read board.md + workspace.json settings
+ * used by the plan executor (max parallel agents, review criteria,
+ * active board resolution, board activation/completion).
+ */
+
+import { existsSync, readFileSync } from 'node:fs';
+import { readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { replaceFrontMatterField } from './front-matter.js';
+
+/** Emits a warning message — caller typically maps this to executor 'output' events. */
+export type WarnFn = (message: string) => void;
+
+export const DEFAULT_MAX_PARALLEL_AGENTS = 3;
+
+/** Read the board's maxParallelAgents setting, falling back to default. */
+export async function getBoardMaxParallelAgents(
+  pmDir: string | null,
+  boardId: string | null,
+  warn: WarnFn,
+): Promise<number> {
+  if (!pmDir || !boardId) return DEFAULT_MAX_PARALLEL_AGENTS;
+  const boardMdPath = join(pmDir, 'boards', boardId, 'board.md');
+  if (!existsSync(boardMdPath)) return DEFAULT_MAX_PARALLEL_AGENTS;
+  try {
+    const content = await readFile(boardMdPath, 'utf-8');
+    const match = content.match(/^max_parallel_agents:\s*(\d+)/m);
+    return match ? Math.max(1, Math.min(Number(match[1]), 10)) : DEFAULT_MAX_PARALLEL_AGENTS;
+  } catch (err) {
+    warn(`Warning: failed to read board max_parallel_agents: ${errMsg(err)}`);
+    return DEFAULT_MAX_PARALLEL_AGENTS;
+  }
+}
+
+/** Read the board's custom review criteria, if set. */
+export async function getBoardReviewCriteria(
+  pmDir: string | null,
+  boardId: string | null,
+  warn: WarnFn,
+): Promise<string | undefined> {
+  if (!pmDir || !boardId) return undefined;
+  const boardMdPath = join(pmDir, 'boards', boardId, 'board.md');
+  if (!existsSync(boardMdPath)) return undefined;
+  try {
+    const content = await readFile(boardMdPath, 'utf-8');
+    const match = content.match(/^review_criteria:\s*"(.+)"/m);
+    if (!match) return undefined;
+    const raw = match[1].replace(/\\"/g, '"').replace(/\\n/g, '\n').trim();
+    return raw || undefined;
+  } catch (err) {
+    warn(`Warning: failed to read board review criteria: ${errMsg(err)}`);
+    return undefined;
+  }
+}
+
+/** Read workspace.json to find the currently active board. */
+export function resolveActiveBoardId(pmDir: string | null): string | null {
+  if (!pmDir) return null;
+  try {
+    const workspacePath = join(pmDir, 'workspace.json');
+    if (!existsSync(workspacePath)) return null;
+    const workspace = JSON.parse(readFileSync(workspacePath, 'utf-8'));
+    return workspace.activeBoardId ?? null;
+  } catch {
+    return null;
+  }
+}
+
+/** Resolve the active board's directory path. */
+export function resolveBoardDir(pmDir: string | null, boardId: string | null): string | null {
+  if (!pmDir) return null;
+  const effective = boardId ?? resolveActiveBoardId(pmDir);
+  if (!effective) return null;
+  const boardDir = join(pmDir, 'boards', effective);
+  return existsSync(boardDir) ? boardDir : null;
+}
+
+/** Activate a draft board by updating its status in board.md. */
+export async function activateBoard(pmDir: string, boardId: string, warn: WarnFn): Promise<void> {
+  const boardMdPath = join(pmDir, 'boards', boardId, 'board.md');
+  if (!existsSync(boardMdPath)) return;
+  try {
+    const content = await readFile(boardMdPath, 'utf-8');
+    await writeFile(boardMdPath, replaceFrontMatterField(content, 'status', 'active'), 'utf-8');
+  } catch (err) {
+    warn(`Warning: failed to activate board ${boardId}: ${errMsg(err)}`);
+  }
+}
+
+/**
+ * Mark a board as completed iff all its issues are `done` or `cancelled`.
+ * No-op when the board is not fully complete.
+ */
+export async function tryCompleteBoardIfDone(
+  pmDir: string,
+  boardId: string,
+  issues: { status: string }[],
+  warn: WarnFn,
+): Promise<void> {
+  const allDone = issues.length > 0 && issues.every(i => i.status === 'done' || i.status === 'cancelled');
+  if (!allDone) return;
+
+  const boardMdPath = join(pmDir, 'boards', boardId, 'board.md');
+  if (!existsSync(boardMdPath)) return;
+
+  try {
+    let content = await readFile(boardMdPath, 'utf-8');
+    content = replaceFrontMatterField(content, 'status', 'completed');
+    content = replaceFrontMatterField(content, 'completed_at', `"${new Date().toISOString()}"`);
+    await writeFile(boardMdPath, content, 'utf-8');
+  } catch (err) {
+    warn(`Warning: failed to mark board ${boardId} as completed: ${errMsg(err)}`);
+  }
+}
+
+function errMsg(err: unknown): string {
+  return err instanceof Error ? err.message : String(err);
+}

package/server/services/plan/composer.ts

@@ -156,7 +156,7 @@ Backlog directory: ${pmDir}/boards/${effectiveBoardId}/backlog/\n`;
 
 export async function handlePlanPrompt(
   ctx: HandlerContext,
-  ws: WSContext,
+  _ws: WSContext,
   userPrompt: string,
   workingDir: string,
   boardId?: string,
@@ -301,11 +301,13 @@ User request: ${userPrompt}`;
       policy: 'STANDARD',
       stallWarningMs: 300_000,
       stallKillMs: 900_000,
-      stallHardCapMs: 1_800_000,
+      stallHardCapMs: 7_200_000,
       verbose: true,
       imageAttachments,
       outputCallback: (text: string) => {
-        ctx.send(ws, {
+        // Broadcast (not ctx.send) so the stream survives a relay reconnect
+        // and reaches every paired web client; mirrors session-handlers.ts.
+        ctx.broadcastToAll({
           type: 'planPromptStreaming',
           data: { token: text, boardId: streamBoardId },
         });
@@ -338,7 +340,7 @@ User request: ${userPrompt}`;
       data: { message: 'Finalizing project plan...', boardId: streamBoardId },
     });
 
-    ctx.send(ws, {
+    ctx.broadcastToAll({
       type: 'planPromptResponse',
       data: {
         response: result.completed ? 'Prompt executed successfully.' : (result.error || 'Unknown error'),
@@ -354,7 +356,7 @@ User request: ${userPrompt}`;
       ctx.broadcastToAll({ type: 'planStateUpdated', data: updatedState });
     }
   } catch (error) {
-    ctx.send(ws, {
+    ctx.broadcastToAll({
       type: 'planError',
       data: { error: error instanceof Error ? error.message : String(error), boardId: streamBoardId },
     });