mstro-app 0.4.3 → 0.4.4

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

@@ -0,0 +1,149 @@
+// Copyright (c) 2025-present Mstro, Inc. All rights reserved.
+// Licensed under the MIT License. See LICENSE file for details.
+
+import { existsSync, readdirSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { executeGitCommand, sendGitError, stripCoauthorLines } from './git-utils.js';
+import type { HandlerContext } from './handler-context.js';
+import type { GitDirectorySetResponse, GitLogEntry, GitRepoInfo, GitReposDiscoveredResponse, WebSocketMessage, WSContext } from './types.js';
+
+export async function handleGitLog(ctx: HandlerContext, ws: WSContext, msg: WebSocketMessage, tabId: string, workingDir: string): Promise<void> {
+  const limit = msg.data?.limit ?? 10;
+  const skip = msg.data?.skip ?? 0;
+
+  try {
+    // Request one extra to detect if there are more commits
+    const fetchCount = limit + 1;
+    const args = [
+      'log',
+      `-${fetchCount}`,
+      `--skip=${skip}`,
+      '--format=%H%x00%h%x00%s%x00%an%x00%aI'
+    ];
+    const result = await executeGitCommand(args, workingDir);
+
+    if (result.exitCode !== 0) {
+      ctx.send(ws, { type: 'gitError', tabId, data: { error: result.stderr || result.stdout || 'Failed to get log' } });
+      return;
+    }
+
+    const allEntries: GitLogEntry[] = result.stdout.trim().split('\n').filter(Boolean).map(line => {
+      const parts = line.split('\x00');
+      const cleanSubject = stripCoauthorLines(parts[2] || '') || parts[2] || '';
+      return { hash: parts[0], shortHash: parts[1], subject: cleanSubject, author: parts[3], date: parts[4] };
+    });
+
+    const hasMore = allEntries.length > limit;
+    const entries = hasMore ? allEntries.slice(0, limit) : allEntries;
+
+    ctx.send(ws, { type: 'gitLog', tabId, data: { entries, hasMore, skip } });
+  } catch (error: unknown) {
+    sendGitError(ctx, ws, tabId, error);
+  }
+}
+
+const SKIP_DIRS = ['node_modules', 'vendor', '.git'];
+
+function shouldSkipDir(name: string): boolean {
+  return name.startsWith('.') || SKIP_DIRS.includes(name);
+}
+
+async function getRepoBranch(repoPath: string): Promise<string | undefined> {
+  const result = await executeGitCommand(['rev-parse', '--abbrev-ref', 'HEAD'], repoPath);
+  return result.exitCode === 0 ? result.stdout.trim() : undefined;
+}
+
+async function scanForGitRepos(dir: string, depth: number, maxDepth: number, repos: GitRepoInfo[]): Promise<void> {
+  if (depth > maxDepth) return;
+
+  let entries: string[];
+  try {
+    entries = readdirSync(dir);
+  } catch {
+    return;
+  }
+
+  for (const name of entries) {
+    if (shouldSkipDir(name)) continue;
+
+    const fullPath = join(dir, name);
+    const gitPath = join(fullPath, '.git');
+
+    if (existsSync(gitPath)) {
+      repos.push({ path: fullPath, name, branch: await getRepoBranch(fullPath) });
+    } else {
+      await scanForGitRepos(fullPath, depth + 1, maxDepth, repos);
+    }
+  }
+}
+
+export async function handleGitDiscoverRepos(ctx: HandlerContext, ws: WSContext, tabId: string, workingDir: string): Promise<void> {
+  try {
+    const repos: GitRepoInfo[] = [];
+    const rootIsGitRepo = existsSync(join(workingDir, '.git'));
+
+    if (rootIsGitRepo) {
+      repos.push({
+        path: workingDir,
+        name: workingDir.split('/').pop() || workingDir,
+        branch: await getRepoBranch(workingDir),
+      });
+    } else {
+      await scanForGitRepos(workingDir, 1, 3, repos);
+    }
+
+    const response: GitReposDiscoveredResponse = {
+      repos,
+      rootIsGitRepo,
+      selectedDirectory: ctx.gitDirectories.get(tabId) || null,
+    };
+
+    ctx.send(ws, { type: 'gitReposDiscovered', tabId, data: response });
+  } catch (error: unknown) {
+    sendGitError(ctx, ws, tabId, error);
+  }
+}
+
+export async function handleGitSetDirectory(ctx: HandlerContext, ws: WSContext, msg: WebSocketMessage, tabId: string, workingDir: string): Promise<void> {
+  const directory = msg.data?.directory as string | undefined;
+
+  if (!directory) {
+    ctx.gitDirectories.delete(tabId);
+    const response: GitDirectorySetResponse = {
+      directory: workingDir,
+      isValid: existsSync(join(workingDir, '.git')),
+    };
+    ctx.send(ws, { type: 'gitDirectorySet', tabId, data: response });
+    const { handleGitStatus } = await import('./git-handlers.js');
+    handleGitStatus(ctx, ws, tabId, workingDir);
+    return;
+  }
+
+  // Security: validate path is within working directory to prevent traversal
+  const resolvedDir = resolve(directory);
+  const resolvedWorkingDir = resolve(workingDir);
+  if (!resolvedDir.startsWith(`${resolvedWorkingDir}/`) && resolvedDir !== resolvedWorkingDir) {
+    ctx.send(ws, { type: 'gitError', tabId, data: { error: 'Access denied: path outside project directory' } });
+    return;
+  }
+
+  const gitPath = join(directory, '.git');
+  const isValid = existsSync(gitPath);
+
+  if (isValid) {
+    ctx.gitDirectories.set(tabId, directory);
+  }
+
+  const response: GitDirectorySetResponse = {
+    directory,
+    isValid,
+  };
+
+  ctx.send(ws, { type: 'gitDirectorySet', tabId, data: response });
+
+  if (isValid) {
+    const { handleGitStatus } = await import('./git-handlers.js');
+    handleGitStatus(ctx, ws, tabId, directory);
+    handleGitLog(ctx, ws, { type: 'gitLog', data: { limit: 5 } }, tabId, directory);
+  }
+}

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

@@ -1,11 +1,8 @@
 // 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 { existsSync, mkdirSync, unlinkSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
 import { getPrBaseBranch, setPrBaseBranch } from '../settings.js';
-import { detectGitProvider, executeGitCommand, spawnCheck, spawnWithOutput, stripCoauthorLines } from './git-handlers.js';
+import { detectGitProvider, executeGitCommand, spawnCheck, spawnHaikuWithPrompt, spawnWithOutput, stripCoauthorLines, truncateDiff } from './git-handlers.js';
 import type { HandlerContext } from './handler-context.js';
 import type { WebSocketMessage, WSContext } from './types.js';
 
@@ -273,20 +270,7 @@ async function handleGitGeneratePRDescription(ctx: HandlerContext, ws: WSContext
     }
 
     const diffResult = await executeGitCommand(['diff', `${compareRef}...HEAD`], workingDir);
-    const diff = diffResult.exitCode === 0 ? diffResult.stdout : '';
-
     const statResult = await executeGitCommand(['diff', `${compareRef}...HEAD`, '--stat'], workingDir);
-    const stat = statResult.exitCode === 0 ? statResult.stdout.trim() : '';
-
-    let truncatedDiff = diff;
-    if (diff.length > 8000) {
-      truncatedDiff = `${diff.slice(0, 4000)}\n\n... [diff truncated] ...\n\n${diff.slice(-3500)}`;
-    }
-
-    const tempDir = join(workingDir, '.mstro', 'tmp');
-    if (!existsSync(tempDir)) {
-      mkdirSync(tempDir, { recursive: true });
-    }
 
     const prompt = `You are generating a pull request title and description for the following changes.
 
@@ -294,10 +278,10 @@ COMMITS (${baseBranch}..HEAD):
 ${commits}
 
 FILES CHANGED:
-${stat}
+${statResult.exitCode === 0 ? statResult.stdout.trim() : ''}
 
 DIFF:
-${truncatedDiff}
+${truncateDiff(diffResult.exitCode === 0 ? diffResult.stdout : '')}
 
 Generate a pull request title and description following these rules:
 1. TITLE: First line must be the PR title — imperative mood, under 70 characters
@@ -310,53 +294,24 @@ Generate a pull request title and description following these rules:
 
 Respond with ONLY the title and description, nothing else.`;
 
-    const promptFile = join(tempDir, `pr-desc-${Date.now()}.txt`);
-    writeFileSync(promptFile, prompt);
-
-    const systemPrompt = 'You are a pull request description assistant. Respond with only the PR title and description, no preamble or explanation.';
-
-    const args = [
-      '--print',
-      '--model', 'haiku',
-      '--system-prompt', systemPrompt,
-      promptFile
-    ];
-
-    const claude = spawn('claude', args, {
-      cwd: workingDir,
-      stdio: ['ignore', 'pipe', 'pipe']
-    });
-
-    let stdout = '';
-    let stderr = '';
+    const result = await spawnHaikuWithPrompt(
+      prompt,
+      'You are a pull request description assistant. Respond with only the PR title and description, no preamble or explanation.',
+      workingDir,
+    );
 
-    claude.stdout?.on('data', (data: Buffer) => { stdout += data.toString(); });
-    claude.stderr?.on('data', (data: Buffer) => { stderr += data.toString(); });
-
-    claude.on('close', (code: number | null) => {
-      try { unlinkSync(promptFile); } catch { /* ignore */ }
-
-      if (code !== 0 || !stdout.trim()) {
-        console.error('[WebSocketImproviseHandler] Claude PR description error:', stderr || 'No output');
-        ctx.send(ws, { type: 'gitError', tabId, data: { error: 'Failed to generate PR description' } });
-        return;
-      }
-
-      const output = stripCoauthorLines(stdout.trim());
-      const lines = output.split('\n');
-      const title = lines[0].trim();
-      const body = lines.slice(1).join('\n').trim();
-
-      ctx.send(ws, { type: 'gitPRDescription', tabId, data: { title, body } });
-    });
-
-    claude.on('error', (err: Error) => {
-      console.error('[WebSocketImproviseHandler] Failed to spawn Claude for PR description:', err);
+    if (result.exitCode !== 0 || !result.stdout.trim()) {
+      console.error('[WebSocketImproviseHandler] Claude PR description error:', result.stderr || 'No output');
       ctx.send(ws, { type: 'gitError', tabId, data: { error: 'Failed to generate PR description' } });
-    });
+      return;
+    }
 
-    setTimeout(() => { claude.kill(); }, 30000);
+    const output = stripCoauthorLines(result.stdout.trim());
+    const lines = output.split('\n');
+    const title = lines[0].trim();
+    const body = lines.slice(1).join('\n').trim();
 
+    ctx.send(ws, { type: 'gitPRDescription', tabId, data: { title, body } });
   } catch (error: unknown) {
     ctx.send(ws, { type: 'gitError', tabId, data: { error: error instanceof Error ? error.message : String(error) } });
   }

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

@@ -0,0 +1,91 @@
+// 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 { GitTagEntry, WebSocketMessage, WSContext } from './types.js';
+
+export async function handleGitListTags(ctx: HandlerContext, ws: WSContext, tabId: string, workingDir: string): Promise<void> {
+  try {
+    const result = await executeGitCommand(
+      ['tag', '-l', '--sort=-creatordate', '--format=%(refname:short)|%(objectname:short)|%(creatordate:iso-strict)|%(subject)'],
+      workingDir
+    );
+    if (result.exitCode !== 0) {
+      ctx.send(ws, { type: 'gitError', tabId, data: { error: result.stderr || 'Failed to list tags' } });
+      return;
+    }
+
+    const tags: GitTagEntry[] = result.stdout.trim().split('\n')
+      .filter(line => line.trim())
+      .slice(0, 50)
+      .map(line => {
+        const parts = line.split('|');
+        return {
+          name: parts[0]?.trim() || '',
+          shortHash: parts[1]?.trim() || '',
+          date: parts[2]?.trim() || '',
+          message: parts[3]?.trim() || '',
+        };
+      });
+
+    ctx.send(ws, { type: 'gitTagList', tabId, data: { tags } });
+  } catch (error: unknown) {
+    sendGitError(ctx, ws, tabId, error);
+  }
+}
+
+export async function handleGitCreateTag(ctx: HandlerContext, ws: WSContext, msg: WebSocketMessage, tabId: string, workingDir: string): Promise<void> {
+  try {
+    const { name, message, commit } = msg.data || {};
+    if (!name) {
+      ctx.send(ws, { type: 'gitError', tabId, data: { error: 'Tag name is required' } });
+      return;
+    }
+
+    if (/\s/.test(name) || name.includes('..')) {
+      ctx.send(ws, { type: 'gitError', tabId, data: { error: 'Invalid tag name: no spaces or ".." allowed' } });
+      return;
+    }
+
+    const args = message
+      ? ['tag', '-a', name, '-m', message, ...(commit ? [commit] : [])]
+      : ['tag', name, ...(commit ? [commit] : [])];
+
+    const result = await executeGitCommand(args, workingDir);
+    if (result.exitCode !== 0) {
+      ctx.send(ws, { type: 'gitError', tabId, data: { error: result.stderr || 'Failed to create tag' } });
+      return;
+    }
+
+    const hashResult = await executeGitCommand(['rev-parse', '--short', name], workingDir);
+    ctx.send(ws, { type: 'gitTagCreated', tabId, data: { name, hash: hashResult.stdout.trim() } });
+  } catch (error: unknown) {
+    sendGitError(ctx, ws, tabId, error);
+  }
+}
+
+export async function handleGitPushTag(ctx: HandlerContext, ws: WSContext, msg: WebSocketMessage, tabId: string, workingDir: string): Promise<void> {
+  try {
+    const { name, all } = msg.data || {};
+
+    const args = all
+      ? ['push', 'origin', '--tags']
+      : ['push', 'origin', name];
+
+    if (!all && !name) {
+      ctx.send(ws, { type: 'gitError', tabId, data: { error: 'Tag name is required' } });
+      return;
+    }
+
+    const result = await executeGitCommand(args, workingDir);
+    if (result.exitCode !== 0) {
+      ctx.send(ws, { type: 'gitError', tabId, data: { error: result.stderr || 'Failed to push tag' } });
+      return;
+    }
+
+    ctx.send(ws, { type: 'gitTagPushed', tabId, data: { name: name || 'all', output: result.stderr || result.stdout } });
+  } catch (error: unknown) {
+    sendGitError(ctx, ws, tabId, error);
+  }
+}

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

@@ -0,0 +1,230 @@
+// 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 { existsSync, mkdirSync, unlinkSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import type { HandlerContext } from './handler-context.js';
+import type { GitFileStatus, WSContext } from './types.js';
+
+/** Send a gitError response to the client. */
+export function sendGitError(ctx: HandlerContext, ws: WSContext, tabId: string, error: unknown): void {
+  ctx.send(ws, { type: 'gitError', tabId, data: { error: error instanceof Error ? error.message : String(error) } });
+}
+
+/** Detect git provider from remote URL */
+export function detectGitProvider(remoteUrl: string): 'github' | 'gitlab' | 'unknown' {
+  if (remoteUrl.includes('github.com')) return 'github';
+  if (remoteUrl.includes('gitlab.com') || remoteUrl.includes('gitlab')) return 'gitlab';
+  return 'unknown';
+}
+
+/** Execute a git command and return stdout */
+export function executeGitCommand(args: string[], workingDir: string): Promise<{ stdout: string; stderr: string; exitCode: number }> {
+  return new Promise((resolve) => {
+    const git = spawn('git', args, {
+      cwd: workingDir,
+      stdio: ['ignore', 'pipe', 'pipe']
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    git.stdout?.on('data', (data: Buffer) => {
+      stdout += data.toString();
+    });
+
+    git.stderr?.on('data', (data: Buffer) => {
+      stderr += data.toString();
+    });
+
+    git.on('close', (code: number | null) => {
+      resolve({ stdout, stderr, exitCode: code ?? 1 });
+    });
+
+    git.on('error', (err: Error) => {
+      resolve({ stdout: '', stderr: err.message, exitCode: 1 });
+    });
+  });
+}
+
+/** Map of simple escape sequences to their character values */
+const ESCAPE_CHARS: Record<string, string> = {
+  '\\': '\\',
+  '"': '"',
+  'n': '\n',
+  't': '\t',
+  'r': '\r',
+};
+
+/** Check if position i starts an octal escape sequence (\nnn) */
+function isOctalEscape(str: string, i: number): boolean {
+  return i + 3 < str.length &&
+    /[0-7]/.test(str[i + 1]) &&
+    /[0-7]{2}/.test(str.slice(i + 2, i + 4));
+}
+
+/**
+ * Unquote a git-quoted path (C-style quoting)
+ */
+export function unquoteGitPath(path: string): string {
+  if (!path.startsWith('"') || !path.endsWith('"')) {
+    return path;
+  }
+
+  const inner = path.slice(1, -1);
+  let result = '';
+  let i = 0;
+
+  while (i < inner.length) {
+    if (inner[i] !== '\\' || i + 1 >= inner.length) {
+      result += inner[i];
+      i++;
+      continue;
+    }
+
+    const next = inner[i + 1];
+    const escaped = ESCAPE_CHARS[next];
+
+    if (escaped !== undefined) {
+      result += escaped;
+      i += 2;
+    } else if (isOctalEscape(inner, i)) {
+      result += String.fromCharCode(parseInt(inner.slice(i + 1, i + 4), 8));
+      i += 4;
+    } else {
+      result += inner[i];
+      i++;
+    }
+  }
+
+  return result;
+}
+
+/** Parse git status --porcelain output into structured format */
+export function parseGitStatus(porcelainOutput: string): { staged: GitFileStatus[]; unstaged: GitFileStatus[]; untracked: GitFileStatus[] } {
+  const staged: GitFileStatus[] = [];
+  const unstaged: GitFileStatus[] = [];
+  const untracked: GitFileStatus[] = [];
+
+  const lines = porcelainOutput.split('\n').filter(line => line.length >= 4);
+
+  for (const line of lines) {
+    const indexStatus = line[0];
+    const workTreeStatus = line[1];
+    const rawPath = line.slice(3);
+
+    const path = unquoteGitPath(rawPath);
+
+    let filePath = path;
+    let originalPath: string | undefined;
+    if (rawPath.includes(' -> ')) {
+      const parts = rawPath.split(' -> ');
+      originalPath = unquoteGitPath(parts[0]);
+      filePath = unquoteGitPath(parts[1]);
+    }
+
+    if (indexStatus === '?' && workTreeStatus === '?') {
+      untracked.push({ path: filePath, status: '?', staged: false });
+      continue;
+    }
+
+    if (indexStatus !== ' ' && indexStatus !== '?') {
+      staged.push({ path: filePath, status: indexStatus as GitFileStatus['status'], staged: true, originalPath });
+    }
+
+    if (workTreeStatus !== ' ' && workTreeStatus !== '?') {
+      unstaged.push({ path: filePath, status: workTreeStatus as GitFileStatus['status'], staged: false, originalPath });
+    }
+  }
+
+  return { staged, unstaged, untracked };
+}
+
+/** Check if a binary runs successfully (exit code 0) */
+export function spawnCheck(bin: string, args: string[]): Promise<boolean> {
+  return new Promise((resolve) => {
+    const proc = spawn(bin, args, { stdio: ['ignore', 'pipe', 'pipe'] });
+    proc.on('close', (code) => resolve(code === 0));
+    proc.on('error', () => resolve(false));
+  });
+}
+
+/** Spawn a process and capture stdout/stderr */
+export function spawnWithOutput(bin: string, args: string[], cwd: string): Promise<{ stdout: string; stderr: string; exitCode: number }> {
+  return new Promise((resolve) => {
+    const proc = spawn(bin, args, { cwd, stdio: ['ignore', 'pipe', 'pipe'] });
+    let stdout = '';
+    let stderr = '';
+    proc.stdout?.on('data', (d: Buffer) => { stdout += d.toString(); });
+    proc.stderr?.on('data', (d: Buffer) => { stderr += d.toString(); });
+    proc.on('close', (code) => resolve({ stdout, stderr, exitCode: code ?? 1 }));
+    proc.on('error', (err: Error) => resolve({ stdout: '', stderr: err.message, exitCode: 1 }));
+  });
+}
+
+/** Truncate a diff to stay within token limits. */
+export function truncateDiff(diff: string, maxLength = 8000): string {
+  if (diff.length <= maxLength) return diff;
+  const headSize = Math.floor(maxLength / 2);
+  const tailSize = Math.floor(maxLength * 0.44);
+  return `${diff.slice(0, headSize)}\n\n... [diff truncated] ...\n\n${diff.slice(-tailSize)}`;
+}
+
+/** Spawn Claude Haiku with a prompt file and return captured output. */
+export function spawnHaikuWithPrompt(
+  prompt: string,
+  systemPrompt: string,
+  workingDir: string,
+  timeoutMs = 30000,
+): Promise<{ stdout: string; stderr: string; exitCode: number }> {
+  return new Promise((resolve) => {
+    const tempDir = join(workingDir, '.mstro', 'tmp');
+    if (!existsSync(tempDir)) mkdirSync(tempDir, { recursive: true });
+    const promptFile = join(tempDir, `haiku-${Date.now()}.txt`);
+    writeFileSync(promptFile, prompt);
+
+    const args = ['--print', '--model', 'haiku', '--system-prompt', systemPrompt, promptFile];
+    const proc = spawn('claude', args, { cwd: workingDir, stdio: ['ignore', 'pipe', 'pipe'] });
+
+    let stdout = '';
+    let stderr = '';
+    proc.stdout?.on('data', (d: Buffer) => { stdout += d.toString(); });
+    proc.stderr?.on('data', (d: Buffer) => { stderr += d.toString(); });
+
+    const timer = setTimeout(() => proc.kill(), timeoutMs);
+
+    proc.on('close', (code) => {
+      clearTimeout(timer);
+      try { unlinkSync(promptFile); } catch { /* ignore cleanup errors */ }
+      resolve({ stdout, stderr, exitCode: code ?? 1 });
+    });
+
+    proc.on('error', (err: Error) => {
+      clearTimeout(timer);
+      try { unlinkSync(promptFile); } catch { /* ignore cleanup errors */ }
+      resolve({ stdout: '', stderr: err.message, exitCode: 1 });
+    });
+  });
+}
+
+/**
+ * Strip injected coauthor/attribution lines from a commit message.
+ */
+export function stripCoauthorLines(message: string): string {
+  const lines = message.split('\n');
+  const markers = ['co-authored', 'authored-by', 'haiku', 'noreply@anthropic.com'];
+  const result: string[] = [];
+  for (let i = 0; i < lines.length; i++) {
+    const lower = lines[i].toLowerCase();
+    if (markers.some(m => lower.includes(m))) {
+      if (result.length > 0 && result[result.length - 1].trim() === '') {
+        result.pop();
+      }
+      continue;
+    }
+    result.push(lines[i]);
+  }
+  if (result.length === 0) return '';
+  return result.join('\n').trimEnd();
+}