mstro-app 0.4.32 → 0.4.34

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

@@ -1,11 +1,35 @@
 // Copyright (c) 2025-present Mstro, Inc. All rights reserved.
 // Licensed under the MIT License. See LICENSE file for details.
 
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
+import { resolvePmDir } from '../plan/parser.js';
+import type { Workspace } from '../plan/types.js';
 import { executeGitCommand, handleGitStatus, spawnWithOutput } from './git-handlers.js';
 import type { HandlerContext } from './handler-context.js';
 import type { WebSocketMessage, WorktreeInfo, WSContext } from './types.js';
 
+function persistBoardWorktree(workingDir: string, boardId: string, worktreePath: string | null, branch: string | null): void {
+  const pmDir = resolvePmDir(workingDir);
+  if (!pmDir) return;
+  const wsPath = join(pmDir, 'workspace.json');
+  if (!existsSync(wsPath)) return;
+  try {
+    const workspace: Workspace = JSON.parse(readFileSync(wsPath, 'utf-8'));
+    if (!workspace.boardWorktrees) workspace.boardWorktrees = {};
+    if (worktreePath && branch) {
+      workspace.boardWorktrees[boardId] = { path: worktreePath, branch };
+    } else {
+      delete workspace.boardWorktrees[boardId];
+    }
+    writeFileSync(wsPath, JSON.stringify(workspace, null, 2), 'utf-8');
+  } catch { /* non-fatal */ }
+}
+
+function isBoardId(id: string): boolean {
+  return id.startsWith('BOARD-');
+}
+
 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),
@@ -116,6 +140,9 @@ async function handleGitWorktreeCreateAndAssign(ctx: HandlerContext, ws: WSConte
     ctx.gitBranches.set(tabId, branchName);
     const registry = ctx.getRegistry(workingDir);
     registry.updateTabWorktree(tabId, wtPath, branchName);
+    if (isBoardId(tabId)) {
+      persistBoardWorktree(workingDir, tabId, wtPath, branchName);
+    }
 
     ctx.send(ws, {
       type: 'gitWorktreeCreatedAndAssigned',
@@ -129,6 +156,17 @@ async function handleGitWorktreeCreateAndAssign(ctx: HandlerContext, ws: WSConte
   }
 }
 
+function cleanupWorktreeReferences(ctx: HandlerContext, workingDir: string, wtPath: string): void {
+  const resolvedWtPath = join(wtPath);
+  for (const [tid, dir] of ctx.gitDirectories) {
+    if (dir === resolvedWtPath || dir === wtPath) {
+      ctx.gitDirectories.delete(tid);
+      ctx.gitBranches.delete(tid);
+      if (isBoardId(tid)) persistBoardWorktree(workingDir, tid, null, null);
+    }
+  }
+}
+
 async function handleGitWorktreeRemove(ctx: HandlerContext, ws: WSContext, msg: WebSocketMessage, tabId: string, workingDir: string): Promise<void> {
   try {
     const { path: wtPath, force, deleteBranch } = msg.data || {};
@@ -155,15 +193,7 @@ async function handleGitWorktreeRemove(ctx: HandlerContext, ws: WSContext, msg:
     }
 
     await executeGitCommand(['worktree', 'prune'], workingDir);
-
-    // Clean up gitDirectories entries for any tabs referencing the removed worktree
-    const resolvedWtPath = join(wtPath); // normalize
-    for (const [tid, dir] of ctx.gitDirectories) {
-      if (dir === resolvedWtPath || dir === wtPath) {
-        ctx.gitDirectories.delete(tid);
-        ctx.gitBranches.delete(tid);
-      }
-    }
+    cleanupWorktreeReferences(ctx, workingDir, wtPath);
 
     ctx.send(ws, { type: 'gitWorktreeRemoved', tabId, data: { path: wtPath } });
   } catch (error: unknown) {
@@ -180,6 +210,9 @@ async function handleTabWorktreeSwitch(ctx: HandlerContext, ws: WSContext, msg:
       ctx.gitDirectories.delete(resolvedTabId);
       ctx.gitBranches.delete(resolvedTabId);
       registry.updateTabWorktree(resolvedTabId, null, null);
+      if (isBoardId(resolvedTabId)) {
+        persistBoardWorktree(workingDir, resolvedTabId, null, null);
+      }
       ctx.send(ws, { type: 'tabWorktreeSwitched', tabId: resolvedTabId, data: { tabId: resolvedTabId, worktreePath: workingDir, branch: '' } });
       handleGitStatus(ctx, ws, resolvedTabId, workingDir);
       return;
@@ -191,6 +224,9 @@ async function handleTabWorktreeSwitch(ctx: HandlerContext, ws: WSContext, msg:
     const branch = branchResult.stdout.trim();
     ctx.gitBranches.set(resolvedTabId, branch);
     registry.updateTabWorktree(resolvedTabId, worktreePath, branch);
+    if (isBoardId(resolvedTabId)) {
+      persistBoardWorktree(workingDir, 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.ts

@@ -25,6 +25,7 @@ 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';
+import { handleListSkills } from './skill-handlers.js';
 import { handleCreateTab, handleGetActiveTabs, handleMarkTabViewed, handleRemoveTab, handleReorderTabs, handleSyncPromptText, handleSyncTabMeta } from './tab-handlers.js';
 import { cleanupTerminalSubscribers, handleTerminalMessage } from './terminal-handlers.js';
 import type { FrecencyData, WebSocketMessage, WebSocketResponse, WSContext } from './types.js';
@@ -53,6 +54,9 @@ export class WebSocketImproviseHandler implements HandlerContext {
   }
 
   getRegistry(workingDir: string): SessionRegistry {
+    if (!this.sessionRegistry && workingDir) {
+      this.sessionRegistry = new SessionRegistry(workingDir);
+    }
     if (!this.sessionRegistry) {
       this.sessionRegistry = new SessionRegistry(workingDir);
     }
@@ -87,9 +91,16 @@ export class WebSocketImproviseHandler implements HandlerContext {
     }
   }
 
+  private frecencySaveTimer: ReturnType<typeof setTimeout> | null = null;
+
   recordFileSelection(filePath: string): void {
     this.autocompleteService.recordFileSelection(filePath);
-    this.saveFrecencyData();
+    if (!this.frecencySaveTimer) {
+      this.frecencySaveTimer = setTimeout(() => {
+        this.frecencySaveTimer = null;
+        this.saveFrecencyData();
+      }, 2000);
+    }
   }
 
   handleConnection(ws: WSContext, _workingDir: string): void {
@@ -175,6 +186,8 @@ export class WebSocketImproviseHandler implements HandlerContext {
         return handleGetSettings(this, ws);
       case 'updateSettings':
         return handleUpdateSettings(this, ws, msg);
+      case 'listSkills':
+        return handleListSkills(this, ws, workingDir);
     }
 
     // Dispatch table lookup for domain handlers
@@ -222,28 +235,14 @@ export class WebSocketImproviseHandler implements HandlerContext {
   }
 
   handleClose(ws: WSContext): void {
-    // Destroy sessions owned by this connection to free interval timers
     const tabMap = this.connections.get(ws);
     if (tabMap) {
-      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);
-        }
-      }
+      this.cleanupConnectionResources(tabMap);
     }
     this.connections.delete(ws);
     this.allConnections.delete(ws);
     cleanupTerminalSubscribers(this, ws);
 
-    // Kill any active search processes to prevent resource leaks
-    for (const [key, process] of this.activeSearches) {
-      try { process.kill(); } catch { /* ignore */ }
-      this.activeSearches.delete(key);
-    }
-
     // Clean up file upload handler when no connections remain
     if (this.allConnections.size === 0 && this.fileUploadHandler) {
       this.fileUploadHandler.destroy();
@@ -251,6 +250,26 @@ export class WebSocketImproviseHandler implements HandlerContext {
     }
   }
 
+  private cleanupConnectionResources(tabMap: Map<string, string>): void {
+    // Destroy sessions owned by this connection
+    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);
+      }
+    }
+    // Kill search processes owned by this connection's tabs
+    for (const tabId of tabMap.keys()) {
+      const searchProcess = this.activeSearches.get(tabId);
+      if (searchProcess) {
+        try { searchProcess.kill(); } catch { /* ignore */ }
+        this.activeSearches.delete(tabId);
+      }
+    }
+  }
+
   send(ws: WSContext, response: WebSocketResponse): void {
     try {
       ws.send(JSON.stringify(response));

package/server/services/websocket/plan-execution-handlers.ts

@@ -24,7 +24,8 @@ export function handlePrompt(
     ctx.send(ws, { type: 'planError', data: { error: 'Prompt required' } });
     return;
   }
-  handlePlanPrompt(ctx, ws, prompt, workingDir, boardId).catch(error => {
+  const executionDir = boardId ? ctx.gitDirectories.get(boardId) : undefined;
+  handlePlanPrompt(ctx, ws, prompt, workingDir, boardId, executionDir).catch(error => {
     ctx.send(ws, {
       type: 'planError',
       data: { error: error instanceof Error ? error.message : String(error) },
@@ -109,8 +110,9 @@ export function handleExecute(
   wireExecutorEvents(executor, ctx, workingDir);
 
   const boardId = msg.data?.boardId as string | undefined;
+  const executionDir = boardId ? ctx.gitDirectories.get(boardId) : undefined;
   ctx.send(ws, { type: 'planExecutionStarted', data: { status: 'executing', boardId } });
-  const startPromise = boardId ? executor.startBoard(boardId) : executor.start();
+  const startPromise = boardId ? executor.startBoard(boardId, executionDir) : executor.start();
   startPromise.catch(error => {
     ctx.send(ws, {
       type: 'planExecutionError',

package/server/services/websocket/plan-issue-handlers.ts

@@ -26,6 +26,16 @@ export function handlePlanInit(ctx: HandlerContext, ws: WSContext, workingDir: s
     return;
   }
 
+  // Restore board worktree assignments into runtime maps
+  if (fullState.workspace?.boardWorktrees) {
+    for (const [boardId, entry] of Object.entries(fullState.workspace.boardWorktrees)) {
+      if (!ctx.gitDirectories.has(boardId)) {
+        ctx.gitDirectories.set(boardId, entry.path);
+        ctx.gitBranches.set(boardId, entry.branch);
+      }
+    }
+  }
+
   ctx.send(ws, { type: 'planState', data: fullState });
 
   const watcher = getWatcher(workingDir, ctx);

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

@@ -2,6 +2,7 @@
 // Licensed under the MIT License. See LICENSE file for details.
 
 import { existsSync, readdirSync, readFileSync, unlinkSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import type { HandlerContext } from './handler-context.js';
 import type { WebSocketMessage, WSContext } from './types.js';
@@ -9,8 +10,9 @@ import type { WebSocketMessage, WSContext } from './types.js';
 export function handleHistoryMessage(ctx: HandlerContext, ws: WSContext, msg: WebSocketMessage, tabId: string, workingDir: string): void {
   switch (msg.type) {
     case 'getSessions': {
-      const result = getSessionsList(workingDir, msg.data?.limit ?? 20, msg.data?.offset ?? 0);
-      ctx.send(ws, { type: 'sessions', tabId, data: result });
+      getSessionsList(workingDir, msg.data?.limit ?? 20, msg.data?.offset ?? 0).then(result => {
+        ctx.send(ws, { type: 'sessions', tabId, data: result });
+      });
       break;
     }
     case 'getSessionsCount':
@@ -42,7 +44,7 @@ function getSessionsCount(workingDir: string): number {
   return readdirSync(sessionsDir).filter((name: string) => name.endsWith('.json')).length;
 }
 
-function getSessionsList(workingDir: string, limit: number = 20, offset: number = 0): { sessions: Array<Record<string, unknown> | null>; total: number; hasMore: boolean } {
+async function getSessionsList(workingDir: string, limit: number = 20, offset: number = 0): Promise<{ sessions: Array<Record<string, unknown> | null>; total: number; hasMore: boolean }> {
   const sessionsDir = join(workingDir, '.mstro', 'history');
 
   if (!existsSync(sessionsDir)) {
@@ -60,17 +62,17 @@ function getSessionsList(workingDir: string, limit: number = 20, offset: number
   const total = historyFiles.length;
   const pageFiles = historyFiles.slice(offset, offset + limit);
 
-  const sessions = pageFiles.map((filename: string) => {
+  const sessions = await Promise.all(pageFiles.map(async (filename: string) => {
     const historyPath = join(sessionsDir, filename);
     try {
-      const historyData = JSON.parse(readFileSync(historyPath, 'utf-8'));
-      return buildSessionSummary(historyData);
+      const raw = await readFile(historyPath, 'utf-8');
+      return buildSessionSummary(JSON.parse(raw));
     } catch {
       return null;
     }
-  }).filter(Boolean);
+  }));
 
-  return { sessions, total, hasMore: offset + limit < total };
+  return { sessions: sessions.filter(Boolean), total, hasMore: offset + limit < total };
 }
 
 function getSessionById(workingDir: string, sessionId: string): Record<string, unknown> | null {

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

@@ -0,0 +1,90 @@
+// Copyright (c) 2025-present Mstro, Inc. All rights reserved.
+// Licensed under the MIT License. See LICENSE file for details.
+
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { findSkillsDir } from '../../utils/paths.js';
+import type { HandlerContext } from './handler-context.js';
+import type { SkillEntry, WSContext } from './types.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const SYSTEM_AGENTS_DIR = join(__dirname, '..', 'plan', 'agents');
+
+function parseFrontmatter(content: string): Record<string, string> {
+	if (!content.startsWith('---')) return {};
+	const endIdx = content.indexOf('---', 3);
+	if (endIdx === -1) return {};
+	const yaml = content.slice(3, endIdx).trim();
+	const result: Record<string, string> = {};
+	for (const line of yaml.split('\n')) {
+		const colonIdx = line.indexOf(':');
+		if (colonIdx === -1) continue;
+		const key = line.slice(0, colonIdx).trim();
+		let val = line.slice(colonIdx + 1).trim();
+		if ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith("'") && val.endsWith("'"))) {
+			val = val.slice(1, -1);
+		}
+		result[key] = val;
+	}
+	return result;
+}
+
+function scanProjectSkills(skillsDir: string): SkillEntry[] {
+	if (!existsSync(skillsDir)) return [];
+	const entries: SkillEntry[] = [];
+	for (const name of readdirSync(skillsDir, { withFileTypes: true })) {
+		if (!name.isDirectory()) continue;
+		const skillFile = join(skillsDir, name.name, 'SKILL.md');
+		if (!existsSync(skillFile)) continue;
+		try {
+			const content = readFileSync(skillFile, 'utf-8');
+			const fm = parseFrontmatter(content);
+			if (fm['user-invocable'] === 'false') continue;
+			entries.push({
+				name: fm.name || name.name,
+				displayName: `/${fm.name || name.name}`,
+				description: fm.description || '',
+				source: 'project',
+			});
+		} catch { /* skip unreadable files */ }
+	}
+	return entries;
+}
+
+function scanSystemAgents(agentsDir: string, seen: Set<string>): SkillEntry[] {
+	if (!existsSync(agentsDir)) return [];
+	const entries: SkillEntry[] = [];
+	for (const file of readdirSync(agentsDir)) {
+		if (!file.endsWith('.md')) continue;
+		const name = file.replace(/\.md$/, '');
+		if (seen.has(name)) continue;
+		try {
+			const content = readFileSync(join(agentsDir, file), 'utf-8');
+			const fm = parseFrontmatter(content);
+			if (fm['user-invocable'] === 'false') continue;
+			entries.push({
+				name: fm.name || name,
+				displayName: `/${fm.name || name}`,
+				description: fm.description || '',
+				source: 'system',
+			});
+		} catch { /* skip unreadable files */ }
+	}
+	return entries;
+}
+
+export function handleListSkills(ctx: HandlerContext, ws: WSContext, workingDir: string): void {
+	const skills: SkillEntry[] = [];
+
+	const projectSkillsDir = findSkillsDir(workingDir);
+	if (projectSkillsDir) {
+		skills.push(...scanProjectSkills(projectSkillsDir));
+	}
+
+	const seen = new Set(skills.map(s => s.name));
+	skills.push(...scanSystemAgents(SYSTEM_AGENTS_DIR, seen));
+
+	skills.sort((a, b) => a.name.localeCompare(b.name));
+	ctx.send(ws, { type: 'skillsList', data: { skills } });
+}

package/server/services/websocket/types.ts

@@ -168,7 +168,9 @@ export interface WebSocketMessage {
     | 'deployHttpRequest'
     // Deploy usage/health message types (cli→server)
     | 'deployUsageReport'
-    | 'deployAiHealthUpdate';
+    | 'deployAiHealthUpdate'
+    // Skill discovery
+    | 'listSkills';
   tabId?: string;
   terminalId?: string;
   // biome-ignore lint/suspicious/noExplicitAny: message envelope carries heterogeneous payloads
@@ -346,7 +348,9 @@ export interface WebSocketResponse {
     | 'deployHttpResponseChunk'
     | 'deployStatus'
     | 'deployUsageReportAck'
-    | 'deployAiHealthAck';
+    | 'deployAiHealthAck'
+    // Skill discovery response types
+    | 'skillsList';
   tabId?: string;
   terminalId?: string;
   // biome-ignore lint/suspicious/noExplicitAny: message envelope carries heterogeneous payloads
@@ -358,6 +362,13 @@ export interface ConnectionData {
   workingDir: string;
 }
 
+export interface SkillEntry {
+  name: string;
+  displayName: string;
+  description: string;
+  source: 'project' | 'system' | 'builtin';
+}
+
 // Extended autocomplete option with metadata
 export interface AutocompleteResult {
   value: string;

package/server/utils/paths.ts

@@ -8,7 +8,8 @@
  * Works correctly whether running from source or installed globally.
  */
 
-import { dirname, resolve } from 'node:path';
+import { existsSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 // ES module equivalent of __dirname for this file
@@ -29,3 +30,18 @@ export const MSTRO_ROOT = resolve(__dirname, '../..');
  */
 export const MCP_SERVER_PATH = resolve(MSTRO_ROOT, 'server/mcp/server.ts');
 
+/**
+ * Walk up from startDir looking for `.claude/skills/`. Returns the path if found, null otherwise.
+ */
+export function findSkillsDir(startDir: string): string | null {
+  let dir = startDir;
+  for (let i = 0; i < 10; i++) {
+    const candidate = join(dir, '.claude', 'skills');
+    if (existsSync(candidate)) return candidate;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+