mstro-app 0.4.3 → 0.4.4

package/server/services/files.ts

@@ -2,27 +2,29 @@
 // Licensed under the MIT License. See LICENSE file for details.
 
 /**
- * File Service
+ * File Service — Autocomplete and file scoring for the working directory.
  *
- * Handles file autocomplete, directory operations, and file explorer features.
+ * Standalone file-explorer CRUD (listDirectory, writeFile, etc.) lives in
+ * file-explorer-ops.ts and is re-exported here for backward compatibility.
  */
 
-import {
-  existsSync,
-  mkdirSync,
-  readdirSync,
-  renameSync,
-  rmdirSync, 
-  statSync,
-  unlinkSync,
-  writeFileSync
-} from 'node:fs'
-import { dirname, join } from 'node:path'
-import {
-  containsDangerousPatterns, 
-  validateBothPathsWithinWorkingDir,
-  validatePathWithinWorkingDir
-} from './pathUtils.js'
+import { readdirSync, statSync } from 'node:fs'
+import { join } from 'node:path'
+
+export type {
+  DirectoryEntry,
+  FileOperationResult,
+  ListDirectoryResult,
+} from './file-explorer-ops.js'
+// Re-export standalone file explorer functions & types
+export {
+  createDirectory,
+  createFile,
+  deleteFile,
+  listDirectory,
+  renameFile,
+  writeFile,
+} from './file-explorer-ops.js'
 
 export interface FileItem {
   name: string
@@ -41,35 +43,6 @@ interface ScoredFileItem {
   score: number
 }
 
-/**
- * Directory entry with metadata for file explorer
- */
-export interface DirectoryEntry {
-  name: string
-  path: string
-  type: 'file' | 'directory'
-  size?: number
-  modifiedAt?: string
-}
-
-/**
- * Result type for file operations
- */
-export interface FileOperationResult {
-  success: boolean
-  path?: string
-  error?: string
-}
-
-/**
- * Result type for list directory operation
- */
-export interface ListDirectoryResult {
-  success: boolean
-  entries?: DirectoryEntry[]
-  error?: string
-}
-
 export class FileService {
   private workingDirectory: string
   private skipDirs = ['node_modules', '.git', '.mstro', 'dist', 'build', '.next', 'coverage', '.vscode', '.idea']
@@ -223,488 +196,3 @@ export class FileService {
     }
   }
 }
-
-// ============================================================================
-// File Explorer Functions (standalone exports for WebSocket handler)
-// ============================================================================
-
-/**
- * List immediate children of a directory.
- * Returns entries sorted: directories first, then files, alphabetically.
- *
- * @param dirPath - Directory path (relative to workingDir or absolute)
- * @param workingDir - Working directory boundary
- * @param showHidden - Whether to show hidden files (starting with .)
- * @returns ListDirectoryResult with entries array or error
- */
-export function listDirectory(
-  dirPath: string,
-  workingDir: string,
-  showHidden: boolean = false
-): ListDirectoryResult {
-  // Check for dangerous patterns first
-  if (containsDangerousPatterns(dirPath)) {
-    console.error(`[FileService] SECURITY: Dangerous pattern in path: "${dirPath}"`)
-    return {
-      success: false,
-      error: 'Invalid path: contains dangerous patterns'
-    }
-  }
-
-  // Validate path is within working directory
-  const validation = validatePathWithinWorkingDir(dirPath, workingDir)
-  if (!validation.valid) {
-    return {
-      success: false,
-      error: validation.error
-    }
-  }
-
-  const resolvedPath = validation.resolvedPath
-
-  try {
-    // Check if path exists and is a directory
-    if (!existsSync(resolvedPath)) {
-      return {
-        success: false,
-        error: 'Directory not found'
-      }
-    }
-
-    const stats = statSync(resolvedPath)
-    if (!stats.isDirectory()) {
-      return {
-        success: false,
-        error: 'Path is not a directory'
-      }
-    }
-
-    // Read directory entries
-    const entries = readdirSync(resolvedPath, { withFileTypes: true })
-
-    // Map to DirectoryEntry objects
-    const directoryEntries: DirectoryEntry[] = entries
-      .filter(entry => {
-        // Filter hidden files unless showHidden is true
-        if (!showHidden && entry.name.startsWith('.')) {
-          return false
-        }
-        return true
-      })
-      .map(entry => {
-        const entryPath = join(resolvedPath, entry.name)
-        const isDir = entry.isDirectory()
-
-        // Get stats for size and modification time
-        let size: number | undefined
-        let modifiedAt: string | undefined
-
-        try {
-          const entryStats = statSync(entryPath)
-          modifiedAt = entryStats.mtime.toISOString()
-          if (!isDir) {
-            size = entryStats.size
-          }
-        } catch {
-          // Skip stats if we can't read them
-        }
-
-        // Return path relative to workingDir for consistency
-        const relativePath = entryPath.replace(`${workingDir}/`, '')
-
-        return {
-          name: entry.name,
-          path: relativePath,
-          type: isDir ? 'directory' : 'file',
-          size,
-          modifiedAt
-        } as DirectoryEntry
-      })
-
-    // Sort: directories first, then files, alphabetically within each group
-    directoryEntries.sort((a, b) => {
-      if (a.type === 'directory' && b.type === 'file') return -1
-      if (a.type === 'file' && b.type === 'directory') return 1
-      return a.name.localeCompare(b.name)
-    })
-
-    return {
-      success: true,
-      entries: directoryEntries
-    }
-  } catch (error: unknown) {
-    // Handle permission errors gracefully
-    if (error instanceof Error && 'code' in error && (error as NodeJS.ErrnoException).code === 'EACCES') {
-      return {
-        success: false,
-        error: 'Permission denied'
-      }
-    }
-
-    console.error('[FileService] Error listing directory:', error)
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : 'Failed to list directory'
-    }
-  }
-}
-
-/**
- * Write content to a file.
- * Creates parent directories if needed.
- *
- * @param filePath - File path (relative to workingDir or absolute)
- * @param content - Content to write
- * @param workingDir - Working directory boundary
- * @returns FileOperationResult
- */
-export function writeFile(
-  filePath: string,
-  content: string,
-  workingDir: string
-): FileOperationResult {
-  // Check for dangerous patterns first
-  if (containsDangerousPatterns(filePath)) {
-    console.error(`[FileService] SECURITY: Dangerous pattern in path: "${filePath}"`)
-    return {
-      success: false,
-      error: 'Invalid path: contains dangerous patterns'
-    }
-  }
-
-  // Validate path is within working directory
-  const validation = validatePathWithinWorkingDir(filePath, workingDir)
-  if (!validation.valid) {
-    return {
-      success: false,
-      error: validation.error
-    }
-  }
-
-  const resolvedPath = validation.resolvedPath
-
-  try {
-    // Create parent directories if they don't exist
-    const parentDir = dirname(resolvedPath)
-    if (!existsSync(parentDir)) {
-      mkdirSync(parentDir, { recursive: true })
-    }
-
-    // Check if target is a directory (can't write to directory)
-    if (existsSync(resolvedPath)) {
-      const stats = statSync(resolvedPath)
-      if (stats.isDirectory()) {
-        return {
-          success: false,
-          error: 'Cannot write to a directory'
-        }
-      }
-    }
-
-    // Write the file
-    writeFileSync(resolvedPath, content, 'utf-8')
-
-    return {
-      success: true,
-      path: resolvedPath.replace(`${workingDir}/`, '')
-    }
-  } catch (error: unknown) {
-    console.error('[FileService] Error writing file:', error)
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : 'Failed to write file'
-    }
-  }
-}
-
-/**
- * Create an empty file.
- * Returns error if file already exists.
- *
- * @param filePath - File path (relative to workingDir or absolute)
- * @param workingDir - Working directory boundary
- * @returns FileOperationResult
- */
-export function createFile(
-  filePath: string,
-  workingDir: string
-): FileOperationResult {
-  // Check for dangerous patterns first
-  if (containsDangerousPatterns(filePath)) {
-    console.error(`[FileService] SECURITY: Dangerous pattern in path: "${filePath}"`)
-    return {
-      success: false,
-      error: 'Invalid path: contains dangerous patterns'
-    }
-  }
-
-  // Validate path is within working directory
-  const validation = validatePathWithinWorkingDir(filePath, workingDir)
-  if (!validation.valid) {
-    return {
-      success: false,
-      error: validation.error
-    }
-  }
-
-  const resolvedPath = validation.resolvedPath
-
-  try {
-    // Check if file already exists
-    if (existsSync(resolvedPath)) {
-      return {
-        success: false,
-        error: 'File already exists'
-      }
-    }
-
-    // Create parent directories if needed
-    const parentDir = dirname(resolvedPath)
-    if (!existsSync(parentDir)) {
-      mkdirSync(parentDir, { recursive: true })
-    }
-
-    // Create empty file
-    writeFileSync(resolvedPath, '', 'utf-8')
-
-    return {
-      success: true,
-      path: resolvedPath.replace(`${workingDir}/`, '')
-    }
-  } catch (error: unknown) {
-    console.error('[FileService] Error creating file:', error)
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : 'Failed to create file'
-    }
-  }
-}
-
-/**
- * Create a directory (recursively if needed).
- * Returns error if directory already exists.
- *
- * @param dirPath - Directory path (relative to workingDir or absolute)
- * @param workingDir - Working directory boundary
- * @returns FileOperationResult
- */
-export function createDirectory(
-  dirPath: string,
-  workingDir: string
-): FileOperationResult {
-  // Check for dangerous patterns first
-  if (containsDangerousPatterns(dirPath)) {
-    console.error(`[FileService] SECURITY: Dangerous pattern in path: "${dirPath}"`)
-    return {
-      success: false,
-      error: 'Invalid path: contains dangerous patterns'
-    }
-  }
-
-  // Validate path is within working directory
-  const validation = validatePathWithinWorkingDir(dirPath, workingDir)
-  if (!validation.valid) {
-    return {
-      success: false,
-      error: validation.error
-    }
-  }
-
-  const resolvedPath = validation.resolvedPath
-
-  try {
-    // Check if path already exists
-    if (existsSync(resolvedPath)) {
-      const stats = statSync(resolvedPath)
-      if (stats.isDirectory()) {
-        return {
-          success: false,
-          error: 'Directory already exists'
-        }
-      } else {
-        return {
-          success: false,
-          error: 'A file with that name already exists'
-        }
-      }
-    }
-
-    // Create directory recursively
-    mkdirSync(resolvedPath, { recursive: true })
-
-    return {
-      success: true,
-      path: resolvedPath.replace(`${workingDir}/`, '')
-    }
-  } catch (error: unknown) {
-    console.error('[FileService] Error creating directory:', error)
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : 'Failed to create directory'
-    }
-  }
-}
-
-/**
- * Delete a file or EMPTY directory.
- * For safety, only deletes empty directories.
- *
- * CRITICAL: Validates path is within workingDir to prevent path traversal.
- *
- * @param targetPath - Path to delete (relative to workingDir or absolute)
- * @param workingDir - Working directory boundary
- * @returns FileOperationResult
- */
-export function deleteFile(
-  targetPath: string,
-  workingDir: string
-): FileOperationResult {
-  // Check for dangerous patterns first
-  if (containsDangerousPatterns(targetPath)) {
-    console.error(`[FileService] SECURITY: Dangerous pattern in path: "${targetPath}"`)
-    return {
-      success: false,
-      error: 'Invalid path: contains dangerous patterns'
-    }
-  }
-
-  // Validate path is within working directory
-  const validation = validatePathWithinWorkingDir(targetPath, workingDir)
-  if (!validation.valid) {
-    return {
-      success: false,
-      error: validation.error
-    }
-  }
-
-  const resolvedPath = validation.resolvedPath
-
-  // Additional safety: prevent deleting the working directory itself
-  if (resolvedPath === workingDir || resolvedPath === `${workingDir}/`) {
-    console.error(`[FileService] SECURITY: Attempted to delete working directory: "${resolvedPath}"`)
-    return {
-      success: false,
-      error: 'Cannot delete the working directory'
-    }
-  }
-
-  try {
-    // Check if path exists
-    if (!existsSync(resolvedPath)) {
-      return {
-        success: false,
-        error: 'File or directory not found'
-      }
-    }
-
-    const stats = statSync(resolvedPath)
-
-    if (stats.isDirectory()) {
-      // Only delete empty directories for safety
-      const contents = readdirSync(resolvedPath)
-      if (contents.length > 0) {
-        return {
-          success: false,
-          error: 'Directory is not empty. Only empty directories can be deleted.'
-        }
-      }
-
-      rmdirSync(resolvedPath)
-    } else {
-      unlinkSync(resolvedPath)
-    }
-
-    return {
-      success: true,
-      path: resolvedPath.replace(`${workingDir}/`, '')
-    }
-  } catch (error: unknown) {
-    console.error('[FileService] Error deleting file:', error)
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : 'Failed to delete'
-    }
-  }
-}
-
-/**
- * Rename or move a file/directory.
- * Both source and destination must be within workingDir.
- *
- * @param oldPath - Current path (relative to workingDir or absolute)
- * @param newPath - New path (relative to workingDir or absolute)
- * @param workingDir - Working directory boundary
- * @returns FileOperationResult
- */
-export function renameFile(
-  oldPath: string,
-  newPath: string,
-  workingDir: string
-): FileOperationResult {
-  // Check for dangerous patterns in both paths
-  if (containsDangerousPatterns(oldPath)) {
-    console.error(`[FileService] SECURITY: Dangerous pattern in source path: "${oldPath}"`)
-    return {
-      success: false,
-      error: 'Invalid source path: contains dangerous patterns'
-    }
-  }
-
-  if (containsDangerousPatterns(newPath)) {
-    console.error(`[FileService] SECURITY: Dangerous pattern in destination path: "${newPath}"`)
-    return {
-      success: false,
-      error: 'Invalid destination path: contains dangerous patterns'
-    }
-  }
-
-  // Validate both paths are within working directory
-  const validation = validateBothPathsWithinWorkingDir(oldPath, newPath, workingDir)
-  if (!validation.valid) {
-    return {
-      success: false,
-      error: validation.error
-    }
-  }
-
-  const resolvedOldPath = validation.resolvedSourcePath
-  const resolvedNewPath = validation.resolvedDestPath
-
-  try {
-    // Check if source exists
-    if (!existsSync(resolvedOldPath)) {
-      return {
-        success: false,
-        error: 'Source file or directory not found'
-      }
-    }
-
-    // Check if destination already exists
-    if (existsSync(resolvedNewPath)) {
-      return {
-        success: false,
-        error: 'Destination already exists'
-      }
-    }
-
-    // Create parent directories for destination if needed
-    const parentDir = dirname(resolvedNewPath)
-    if (!existsSync(parentDir)) {
-      mkdirSync(parentDir, { recursive: true })
-    }
-
-    // Perform the rename
-    renameSync(resolvedOldPath, resolvedNewPath)
-
-    return {
-      success: true,
-      path: resolvedNewPath.replace(`${workingDir}/`, '')
-    }
-  } catch (error: unknown) {
-    console.error('[FileService] Error renaming file:', error)
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : 'Failed to rename'
-    }
-  }
-}

package/server/services/plan/composer.ts

@@ -273,7 +273,8 @@ User request: ${userPrompt}`;
       data: { message: 'Claude is planning your project...' },
     });
 
-    const result = await runWithFileLogger('pm-compose', () => runner.run());
+    const boardLogDir = cc.effectiveBoardId ? join(pmDir, 'boards', cc.effectiveBoardId, 'logs') : undefined;
+    const result = await runWithFileLogger('pm-compose', () => runner.run(), boardLogDir);
 
     ctx.broadcastToAll({
       type: 'planPromptProgress',

package/server/services/plan/executor.ts

@@ -211,7 +211,8 @@ export class PlanExecutor extends EventEmitter {
         },
       });
 
-      const result = await runWithFileLogger('pm-execute-wave', () => runner.run());
+      const boardLogDir = this.boardDir ? join(this.boardDir, 'logs') : undefined;
+      const result = await runWithFileLogger('pm-execute-wave', () => runner.run(), boardLogDir);
 
       if (!result.completed || result.error) {
         this.emit('waveError', {
@@ -338,6 +339,7 @@ export class PlanExecutor extends EventEmitter {
       pmDir,
       outputPath,
       onOutput: (text) => this.emit('output', { issueId: issue.id, text }),
+      logDir: this.boardDir ? join(this.boardDir, 'logs') : undefined,
     });
     persistReviewResult(reviewDir, issue, result);