mstro-app 0.4.2 → 0.4.4

package/server/services/websocket/file-search-handlers.ts

@@ -0,0 +1,291 @@
+// Copyright (c) 2025-present Mstro, Inc. All rights reserved.
+// Licensed under the MIT License. See LICENSE file for details.
+
+import { spawn } from 'node:child_process';
+import { relative } from 'node:path';
+import type { HandlerContext } from './handler-context.js';
+import type { WebSocketMessage, WSContext } from './types.js';
+
+type SearchMatch = { filePath: string; line: number; column: number; lineContent: string; contextBefore: string[]; contextAfter: string[] };
+
+function appendGlobArgs(args: string[], globStr: string, prefix: string): void {
+  for (const glob of globStr.split(',')) {
+    const trimmed = glob.trim();
+    if (trimmed) args.push('--glob', `${prefix}${trimmed}`);
+  }
+}
+
+function buildRgArgs(query: string, options: Record<string, unknown>): string[] {
+  const args: string[] = ['--json', '--no-heading'];
+  if (!options.caseSensitive) args.push('-i');
+  if (options.wholeWord) args.push('-w');
+  if (!options.regex) args.push('-F');
+  args.push('-C', options.contextLines !== undefined ? String(options.contextLines) : '1');
+  if (options.includeGlob) appendGlobArgs(args, options.includeGlob as string, '');
+  if (options.excludeGlob) appendGlobArgs(args, options.excludeGlob as string, '!');
+  args.push('--', query, '.');
+  return args;
+}
+
+/** Process a single JSON line from rg output. Returns true if search should stop (maxResults reached). */
+function processRgSearchLine(
+  line: string,
+  workingDir: string,
+  batch: SearchMatch[],
+  seenFiles: Set<string>,
+  contextMap: Map<string, { before: string[]; after: string[] }>,
+  counters: { totalMatches: number; fileCount: number },
+  maxResults: number,
+  flushBatch: () => void,
+): boolean {
+  try {
+    const parsed = JSON.parse(line);
+    if (parsed.type === 'match') {
+      return processRgMatch(parsed, workingDir, batch, seenFiles, contextMap, counters, maxResults, flushBatch);
+    }
+    if (parsed.type === 'context') {
+      appendRgContext(parsed, workingDir, batch);
+    }
+  } catch {
+    // Skip malformed JSON lines
+  }
+  return false;
+}
+
+function processRgMatch(
+  parsed: { data: { path: { text: string }; line_number: number; lines: { text: string }; submatches?: Array<{ start: number }> } },
+  workingDir: string,
+  batch: SearchMatch[],
+  seenFiles: Set<string>,
+  contextMap: Map<string, { before: string[]; after: string[] }>,
+  counters: { totalMatches: number; fileCount: number },
+  maxResults: number,
+  flushBatch: () => void,
+): boolean {
+  const filePath = relative(workingDir, parsed.data.path.text);
+  const lineNumber = parsed.data.line_number;
+  const lineContent = parsed.data.lines.text.replace(/\n$/, '');
+  const column = parsed.data.submatches?.[0]?.start ?? 0;
+
+  if (!seenFiles.has(filePath)) {
+    seenFiles.add(filePath);
+    counters.fileCount++;
+  }
+  counters.totalMatches++;
+
+  const key = `${filePath}:${lineNumber}`;
+  const ctxLines = contextMap.get(key) || { before: [], after: [] };
+  batch.push({ filePath, line: lineNumber, column: column + 1, lineContent, contextBefore: ctxLines.before, contextAfter: [] });
+
+  if (counters.totalMatches >= maxResults) {
+    flushBatch();
+    return true;
+  }
+  if (batch.length >= 50) flushBatch();
+  return false;
+}
+
+function appendRgContext(
+  parsed: { data: { path: { text: string }; line_number: number; lines: { text: string } } },
+  workingDir: string,
+  batch: SearchMatch[],
+): void {
+  const filePath = relative(workingDir, parsed.data.path.text);
+  const lineNumber = parsed.data.line_number;
+  const lineContent = parsed.data.lines.text.replace(/\n$/, '');
+
+  const lastMatch = batch[batch.length - 1];
+  if (!lastMatch || lastMatch.filePath !== filePath) return;
+  if (lineNumber < lastMatch.line) {
+    lastMatch.contextBefore.push(lineContent);
+  } else {
+    lastMatch.contextAfter.push(lineContent);
+  }
+}
+
+export function handleSearchFileContents(ctx: HandlerContext, ws: WSContext, msg: WebSocketMessage, tabId: string, workingDir: string): void {
+  const query = msg.data?.query;
+  if (!query) {
+    ctx.send(ws, { type: 'contentSearchError', tabId, data: { error: 'Search query is required' } });
+    return;
+  }
+
+  handleCancelSearch(ctx, tabId);
+
+  const options = msg.data.options || {};
+  const startTime = Date.now();
+  let totalMatches = 0;
+  let fileCount = 0;
+  const seenFiles = new Set<string>();
+  const maxResults = options.maxResults || 5000;
+  let batch: SearchMatch[] = [];
+
+  const args = buildRgArgs(query, options);
+
+  const rgProcess = spawn('rg', args, { cwd: workingDir, stdio: ['ignore', 'pipe', 'pipe'] });
+  ctx.activeSearches.set(tabId, rgProcess);
+
+  let buffer = '';
+  const contextMap = new Map<string, { before: string[]; after: string[] }>();
+
+  const flushBatch = () => {
+    if (batch.length > 0) {
+      ctx.send(ws, { type: 'contentSearchResults', tabId, data: { matches: batch, partial: true } });
+      batch = [];
+    }
+  };
+
+  const searchState = { totalMatches, fileCount };
+
+  rgProcess.stdout?.on('data', (chunk: Buffer) => {
+    buffer += chunk.toString();
+    const lines = buffer.split('\n');
+    buffer = lines.pop() || '';
+
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      if (processRgSearchLine(line, workingDir, batch, seenFiles, contextMap, searchState, maxResults, flushBatch)) {
+        rgProcess.kill();
+        return;
+      }
+    }
+    totalMatches = searchState.totalMatches;
+    fileCount = searchState.fileCount;
+  });
+
+  rgProcess.stderr?.on('data', (chunk: Buffer) => {
+    const errText = chunk.toString().trim();
+    if (errText && !errText.includes('No files were searched')) {
+      console.error(`[Search] rg stderr: ${errText}`);
+    }
+  });
+
+  rgProcess.on('close', (_code) => {
+    ctx.activeSearches.delete(tabId);
+    flushBatch();
+
+    ctx.send(ws, {
+      type: 'contentSearchComplete',
+      tabId,
+      data: {
+        totalMatches,
+        fileCount,
+        truncated: totalMatches >= maxResults,
+        durationMs: Date.now() - startTime,
+      },
+    });
+  });
+
+  rgProcess.on('error', (err) => {
+    ctx.activeSearches.delete(tabId);
+    if ((err as NodeJS.ErrnoException).code === 'ENOENT') {
+      handleSearchFallback(ctx, ws, query, options, tabId, workingDir);
+    } else {
+      ctx.send(ws, { type: 'contentSearchError', tabId, data: { error: err.message } });
+    }
+  });
+}
+
+/** Process a single grep output line. Returns true if search should stop. */
+function processGrepLine(
+  line: string,
+  batch: SearchMatch[],
+  seenFiles: Set<string>,
+  counters: { totalMatches: number; fileCount: number },
+  maxResults: number,
+  flushBatch: () => void,
+): boolean {
+  const match = line.match(/^\.\/(.+?):(\d+):(.*)$/);
+  if (!match) return false;
+
+  const filePath = match[1];
+  const lineNumber = parseInt(match[2], 10);
+  const lineContent = match[3];
+
+  if (!seenFiles.has(filePath)) {
+    seenFiles.add(filePath);
+    counters.fileCount++;
+  }
+  counters.totalMatches++;
+
+  batch.push({ filePath, line: lineNumber, column: 1, lineContent, contextBefore: [], contextAfter: [] });
+
+  if (counters.totalMatches >= maxResults) {
+    flushBatch();
+    return true;
+  }
+  if (batch.length >= 50) flushBatch();
+  return false;
+}
+
+function handleSearchFallback(ctx: HandlerContext, ws: WSContext, query: string, options: Record<string, unknown>, tabId: string, workingDir: string): void {
+  const startTime = Date.now();
+  const args: string[] = ['-rn'];
+  if (!options.caseSensitive) args.push('-i');
+  if (options.includeGlob) {
+    for (const glob of String(options.includeGlob).split(',')) {
+      const trimmed = glob.trim();
+      if (trimmed) args.push(`--include=${trimmed}`);
+    }
+  }
+  args.push('--', query, '.');
+
+  const grepProcess = spawn('grep', args, { cwd: workingDir, stdio: ['ignore', 'pipe', 'pipe'] });
+  ctx.activeSearches.set(tabId, grepProcess);
+
+  let buffer = '';
+  let totalMatches = 0;
+  let fileCount = 0;
+  const seenFiles = new Set<string>();
+  const maxResults = (options.maxResults as number) || 5000;
+  let batch: SearchMatch[] = [];
+  const grepState = { totalMatches, fileCount };
+
+  const flushGrepBatch = () => {
+    if (batch.length > 0) {
+      ctx.send(ws, { type: 'contentSearchResults', tabId, data: { matches: batch, partial: true } });
+      batch = [];
+    }
+  };
+
+  grepProcess.stdout?.on('data', (chunk: Buffer) => {
+    buffer += chunk.toString();
+    const lines = buffer.split('\n');
+    buffer = lines.pop() || '';
+
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      if (processGrepLine(line, batch, seenFiles, grepState, maxResults, flushGrepBatch)) {
+        grepProcess.kill();
+        return;
+      }
+    }
+    totalMatches = grepState.totalMatches;
+    fileCount = grepState.fileCount;
+  });
+
+  grepProcess.on('close', () => {
+    ctx.activeSearches.delete(tabId);
+    if (batch.length > 0) {
+      ctx.send(ws, { type: 'contentSearchResults', tabId, data: { matches: batch, partial: true } });
+    }
+    ctx.send(ws, {
+      type: 'contentSearchComplete',
+      tabId,
+      data: { totalMatches, fileCount, truncated: totalMatches >= maxResults, durationMs: Date.now() - startTime },
+    });
+  });
+
+  grepProcess.on('error', (err) => {
+    ctx.activeSearches.delete(tabId);
+    ctx.send(ws, { type: 'contentSearchError', tabId, data: { error: `Search unavailable: ${err.message}` } });
+  });
+}
+
+export function handleCancelSearch(ctx: HandlerContext, tabId: string): void {
+  const process = ctx.activeSearches.get(tabId);
+  if (process) {
+    process.kill();
+    ctx.activeSearches.delete(tabId);
+  }
+}

package/server/services/websocket/file-utils.ts

@@ -8,7 +8,7 @@
  */
 
 import { existsSync, readdirSync, readFileSync, type Stats, statSync } from 'node:fs';
-import { extname, join, relative, sep } from 'node:path';
+import { extname, join, relative, resolve, sep } from 'node:path';
 import type { CacheEntry, } from './types.js';
 
 // Directories always excluded from autocomplete scanning
@@ -286,8 +286,8 @@ function readTextContent(fullPath: string, filePath: string, fileName: string, s
 }
 
 function validateFileAccess(fullPath: string, filePath: string, fileName: string, workingDir: string): FileContentResult | null {
-  const normalizedPath = join(fullPath);
-  if (!normalizedPath.startsWith(join(workingDir)) && !isPathInSafeLocation(normalizedPath)) {
+  const normalizedPath = resolve(fullPath);
+  if (!normalizedPath.startsWith(resolve(workingDir)) && !isPathInSafeLocation(normalizedPath)) {
     return { path: filePath, fileName, content: '', error: 'Access denied: path outside allowed locations' };
   }
   if (!existsSync(fullPath)) {

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

@@ -0,0 +1,130 @@
+// Copyright (c) 2025-present Mstro, Inc. All rights reserved.
+// Licensed under the MIT License. See LICENSE file for details.
+
+import { executeGitCommand, sendGitError } from './git-utils.js';
+import type { HandlerContext } from './handler-context.js';
+import type { GitBranchEntry, WebSocketMessage, WSContext } from './types.js';
+
+export async function handleGitListBranches(ctx: HandlerContext, ws: WSContext, tabId: string, workingDir: string): Promise<void> {
+  try {
+    const result = await executeGitCommand(
+      ['branch', '-a', '--format=%(refname:short)|%(objectname:short)|%(upstream:short)|%(HEAD)'],
+      workingDir
+    );
+    if (result.exitCode !== 0) {
+      ctx.send(ws, { type: 'gitError', tabId, data: { error: result.stderr || 'Failed to list branches' } });
+      return;
+    }
+
+    const currentBranchResult = await executeGitCommand(['rev-parse', '--abbrev-ref', 'HEAD'], workingDir);
+    const currentBranch = currentBranchResult.stdout.trim() || 'HEAD';
+
+    const branches: GitBranchEntry[] = result.stdout.trim().split('\n')
+      .filter(line => line.trim())
+      .map(line => {
+        const [name, shortHash, upstream, head] = line.split('|');
+        const isRemote = name.includes('/') && (name.startsWith('origin/') || name.includes('remotes/'));
+        return {
+          name: name.trim(),
+          shortHash: shortHash?.trim() || '',
+          isRemote,
+          isCurrent: head?.trim() === '*',
+          upstream: upstream?.trim() || undefined,
+        };
+      })
+      .filter(b => b.name !== 'origin/HEAD');
+
+    ctx.send(ws, { type: 'gitBranchList', tabId, data: { branches, current: currentBranch } });
+  } catch (error: unknown) {
+    sendGitError(ctx, ws, tabId, error);
+  }
+}
+
+export async function handleGitCheckout(ctx: HandlerContext, ws: WSContext, msg: WebSocketMessage, tabId: string, workingDir: string): Promise<void> {
+  try {
+    const { branch, create, startPoint } = msg.data || {};
+    if (!branch) {
+      ctx.send(ws, { type: 'gitError', tabId, data: { error: 'Branch name is required' } });
+      return;
+    }
+
+    const statusResult = await executeGitCommand(['status', '--porcelain'], workingDir);
+    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 previous = prevResult.stdout.trim();
+
+    const args = create
+      ? ['checkout', '-b', branch, ...(startPoint ? [startPoint] : [])]
+      : ['checkout', branch];
+
+    const result = await executeGitCommand(args, workingDir);
+    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
+    const { handleGitStatus } = await import('./git-handlers.js');
+    handleGitStatus(ctx, ws, tabId, workingDir);
+  } catch (error: unknown) {
+    sendGitError(ctx, ws, tabId, error);
+  }
+}
+
+export async function handleGitCreateBranch(ctx: HandlerContext, ws: WSContext, msg: WebSocketMessage, tabId: string, workingDir: string): Promise<void> {
+  try {
+    const { name, startPoint, checkout } = msg.data || {};
+    if (!name) {
+      ctx.send(ws, { type: 'gitError', tabId, data: { error: 'Branch name is required' } });
+      return;
+    }
+
+    const args = ['branch', name, ...(startPoint ? [startPoint] : [])];
+    const result = await executeGitCommand(args, workingDir);
+    if (result.exitCode !== 0) {
+      ctx.send(ws, { type: 'gitError', tabId, data: { error: result.stderr || 'Failed to create branch' } });
+      return;
+    }
+
+    const hashResult = await executeGitCommand(['rev-parse', '--short', name], workingDir);
+
+    if (checkout) {
+      await executeGitCommand(['checkout', name], workingDir);
+    }
+
+    ctx.send(ws, { type: 'gitBranchCreated', tabId, data: { name, hash: hashResult.stdout.trim() } });
+  } catch (error: unknown) {
+    sendGitError(ctx, ws, tabId, error);
+  }
+}
+
+export async function handleGitDeleteBranch(ctx: HandlerContext, ws: WSContext, msg: WebSocketMessage, tabId: string, workingDir: string): Promise<void> {
+  try {
+    const { name, force } = msg.data || {};
+    if (!name) {
+      ctx.send(ws, { type: 'gitError', tabId, data: { error: 'Branch name is required' } });
+      return;
+    }
+
+    const currentResult = await executeGitCommand(['rev-parse', '--abbrev-ref', 'HEAD'], workingDir);
+    if (currentResult.stdout.trim() === name) {
+      ctx.send(ws, { type: 'gitError', tabId, data: { error: 'Cannot delete the currently checked out branch' } });
+      return;
+    }
+
+    const result = await executeGitCommand(['branch', force ? '-D' : '-d', name], workingDir);
+    if (result.exitCode !== 0) {
+      ctx.send(ws, { type: 'gitError', tabId, data: { error: result.stderr || 'Failed to delete branch' } });
+      return;
+    }
+
+    ctx.send(ws, { type: 'gitBranchDeleted', tabId, data: { name } });
+  } catch (error: unknown) {
+    sendGitError(ctx, ws, tabId, error);
+  }
+}

package/server/services/websocket/git-diff-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 { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { executeGitCommand, sendGitError, stripCoauthorLines } from './git-utils.js';
+import type { HandlerContext } from './handler-context.js';
+import type { GitCommitFile, WebSocketMessage, WSContext } from './types.js';
+
+export async function handleGitDiff(ctx: HandlerContext, ws: WSContext, msg: WebSocketMessage, tabId: string, workingDir: string): Promise<void> {
+  try {
+    const { path, staged } = msg.data || {};
+    if (!path) {
+      ctx.send(ws, { type: 'gitError', tabId, data: { error: 'File path is required' } });
+      return;
+    }
+
+    const originalResult = await executeGitCommand(['show', `HEAD:${path}`], workingDir);
+    const original = originalResult.exitCode === 0 ? originalResult.stdout : '';
+
+    let modified: string;
+    if (staged) {
+      const indexResult = await executeGitCommand(['show', `:${path}`], workingDir);
+      modified = indexResult.exitCode === 0 ? indexResult.stdout : '';
+    } else {
+      const fullPath = join(workingDir, path);
+      try {
+        modified = readFileSync(fullPath, 'utf-8');
+      } catch {
+        modified = '';
+      }
+    }
+
+    ctx.send(ws, {
+      type: 'gitDiffResult',
+      tabId,
+      data: { path, original, modified, staged: !!staged },
+    });
+  } catch (error: unknown) {
+    sendGitError(ctx, ws, tabId, error);
+  }
+}
+
+/** Parse a single name-status line into {status, oldPath?} */
+function parseStatusLine(line: string | undefined): { status: string; oldPath?: string } {
+  if (!line) return { status: 'M' };
+  const parts = line.split('\t');
+  const status = (parts[0] || 'M').charAt(0); // R100 -> R, C100 -> C
+  const oldPath = (status === 'R' || status === 'C') && parts.length >= 3 ? parts[1] : undefined;
+  return { status, oldPath };
+}
+
+/** Parse numstat + name-status output into GitCommitFile[] */
+function parseCommitFiles(numstatOutput: string, statusOutput: string): GitCommitFile[] {
+  const numstatLines = numstatOutput.trim().split('\n').filter(Boolean);
+  const statusLines = statusOutput.trim().split('\n').filter(Boolean);
+
+  return numstatLines.map((line, i) => {
+    const numParts = line.split('\t');
+    const additions = numParts[0] === '-' ? 0 : parseInt(numParts[0], 10) || 0;
+    const deletions = numParts[1] === '-' ? 0 : parseInt(numParts[1], 10) || 0;
+    const { status, oldPath } = parseStatusLine(statusLines[i]);
+    return { path: numParts[2] || '', status, additions, deletions, ...(oldPath ? { oldPath } : {}) };
+  });
+}
+
+/** Get the changed files for a commit via diff-tree */
+async function getCommitFiles(hash: string, workingDir: string): Promise<GitCommitFile[]> {
+  const isRoot = (await executeGitCommand(['rev-parse', `${hash}^`], workingDir)).exitCode !== 0;
+  const extra = isRoot ? ['--root'] : [];
+  const numstatResult = await executeGitCommand(
+    ['diff-tree', '-r', '--numstat', '--no-commit-id', ...extra, hash], workingDir
+  );
+  const statusResult = await executeGitCommand(
+    ['diff-tree', '-r', '--name-status', '--no-commit-id', ...extra, hash], workingDir
+  );
+  return parseCommitFiles(numstatResult.stdout, statusResult.stdout);
+}
+
+export async function handleGitShowCommit(ctx: HandlerContext, ws: WSContext, msg: WebSocketMessage, tabId: string, workingDir: string): Promise<void> {
+  try {
+    const hash = msg.data?.hash as string | undefined;
+    if (!hash) {
+      ctx.send(ws, { type: 'gitError', tabId, data: { error: 'Commit hash is required' } });
+      return;
+    }
+
+    const metaResult = await executeGitCommand([
+      'show', '-s', '--format=%H%x00%h%x00%s%x00%b%x00%an%x00%aI', hash
+    ], workingDir);
+
+    if (metaResult.exitCode !== 0) {
+      ctx.send(ws, { type: 'gitError', tabId, data: { error: metaResult.stderr || 'Failed to get commit details' } });
+      return;
+    }
+
+    const parts = metaResult.stdout.trim().split('\x00');
+    const subject = stripCoauthorLines(parts[2] || '') || parts[2] || '';
+    const files = await getCommitFiles(hash, workingDir);
+
+    ctx.send(ws, {
+      type: 'gitCommitDetail',
+      tabId,
+      data: {
+        hash: parts[0], shortHash: parts[1], subject,
+        body: stripCoauthorLines(parts[3] || '').trim(),
+        author: parts[4], date: parts[5], files,
+      },
+    });
+  } catch (error: unknown) {
+    sendGitError(ctx, ws, tabId, error);
+  }
+}
+
+export async function handleGitCommitDiff(ctx: HandlerContext, ws: WSContext, msg: WebSocketMessage, tabId: string, workingDir: string): Promise<void> {
+  try {
+    const hash = msg.data?.hash as string | undefined;
+    const path = msg.data?.path as string | undefined;
+    if (!hash || !path) {
+      ctx.send(ws, { type: 'gitError', tabId, data: { error: 'Commit hash and file path are required' } });
+      return;
+    }
+
+    // Get the file content at this commit
+    const modifiedResult = await executeGitCommand(['show', `${hash}:${path}`], workingDir);
+    const modified = modifiedResult.exitCode === 0 ? modifiedResult.stdout : '';
+
+    // Get the file content at the parent commit
+    const originalResult = await executeGitCommand(['show', `${hash}^:${path}`], workingDir);
+    const original = originalResult.exitCode === 0 ? originalResult.stdout : '';
+
+    ctx.send(ws, {
+      type: 'gitCommitDiffResult',
+      tabId,
+      data: { hash, path, original, modified },
+    });
+  } catch (error: unknown) {
+    sendGitError(ctx, ws, tabId, error);
+  }
+}