@minionry/minion 0.7.36

package/dist/server/services/file-explorer-ops.js

@@ -0,0 +1,328 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { existsSync, mkdirSync, readdirSync, realpathSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
+import { readdir, stat } from 'node:fs/promises';
+import { dirname, join, resolve, sep } from 'node:path';
+import { containsDangerousPatterns, validateBothPathsWithinWorkingDir, validatePathWithinWorkingDir } from './pathUtils.js';
+export const MAX_RESOLVE_TO = 200;
+const STAT_CONCURRENCY = 32;
+const RESOLVE_CONCURRENCY = 4;
+const nameCollator = new Intl.Collator();
+function validateListingTarget(dirPath, workingDir) {
+    if (containsDangerousPatterns(dirPath)) {
+        console.error(`[FileService] SECURITY: Dangerous pattern in path: "${dirPath}"`);
+        return { ok: false, error: 'Invalid path: contains dangerous patterns' };
+    }
+    const validation = validatePathWithinWorkingDir(dirPath, workingDir);
+    if (!validation.valid) {
+        return { ok: false, error: validation.error ?? 'Access denied' };
+    }
+    return { ok: true, resolvedPath: validation.resolvedPath };
+}
+function workingDirRoots(workingDir) {
+    const raw = resolve(workingDir);
+    const roots = [raw];
+    try {
+        const real = realpathSync(raw);
+        if (real !== raw)
+            roots.push(real);
+    }
+    catch {
+    }
+    return roots;
+}
+function relativeToRoots(entryPath, roots) {
+    for (const root of roots) {
+        if (entryPath.startsWith(root + sep))
+            return entryPath.slice(root.length + 1);
+    }
+    return entryPath;
+}
+function toDirectoryEntry(name, isDir, stats, relativePath) {
+    const entry = { name, path: relativePath, type: isDir ? 'directory' : 'file' };
+    if (stats) {
+        entry.modifiedAt = stats.mtime.toISOString();
+        if (!isDir)
+            entry.size = stats.size;
+    }
+    return entry;
+}
+function compareDirectoryEntries(a, b) {
+    if (a.type !== b.type)
+        return a.type === 'directory' ? -1 : 1;
+    return nameCollator.compare(a.name, b.name);
+}
+function listingFailure(error) {
+    if (error instanceof Error && 'code' in error) {
+        const code = error.code;
+        if (code === 'EACCES' || code === 'EPERM')
+            return { success: false, error: 'Permission denied' };
+        if (code === 'ENOENT')
+            return { success: false, error: 'Directory not found' };
+        if (code === 'ENOTDIR')
+            return { success: false, error: 'Path is not a directory' };
+    }
+    console.error('[FileService] Error listing directory:', error);
+    return { success: false, error: error instanceof Error ? error.message : 'Failed to list directory' };
+}
+async function mapWithConcurrency(items, limit, fn) {
+    const results = new Array(items.length);
+    let next = 0;
+    const worker = async () => {
+        while (next < items.length) {
+            const index = next++;
+            results[index] = await fn(items[index]);
+        }
+    };
+    const workers = Array.from({ length: Math.min(limit, items.length) }, worker);
+    await Promise.all(workers);
+    return results;
+}
+export function listDirectory(dirPath, workingDir, showHidden = false) {
+    const target = validateListingTarget(dirPath, workingDir);
+    if (!target.ok)
+        return { success: false, error: target.error };
+    const resolvedPath = target.resolvedPath;
+    try {
+        if (!existsSync(resolvedPath)) {
+            return { success: false, error: 'Directory not found' };
+        }
+        if (!statSync(resolvedPath).isDirectory()) {
+            return { success: false, error: 'Path is not a directory' };
+        }
+        const roots = workingDirRoots(workingDir);
+        const entries = readdirSync(resolvedPath, { withFileTypes: true })
+            .filter(entry => showHidden || !entry.name.startsWith('.'))
+            .map(entry => {
+            const entryPath = join(resolvedPath, entry.name);
+            let stats;
+            try {
+                stats = statSync(entryPath);
+            }
+            catch {   }
+            const isDir = stats ? stats.isDirectory() : entry.isDirectory();
+            return toDirectoryEntry(entry.name, isDir, stats, relativeToRoots(entryPath, roots));
+        })
+            .sort(compareDirectoryEntries);
+        return { success: true, entries };
+    }
+    catch (error) {
+        return listingFailure(error);
+    }
+}
+export async function listDirectoryAsync(dirPath, workingDir, showHidden = false) {
+    const target = validateListingTarget(dirPath, workingDir);
+    if (!target.ok)
+        return { success: false, error: target.error };
+    const resolvedPath = target.resolvedPath;
+    try {
+        const dirStats = await stat(resolvedPath);
+        if (!dirStats.isDirectory()) {
+            return { success: false, error: 'Path is not a directory' };
+        }
+        const roots = workingDirRoots(workingDir);
+        const dirents = (await readdir(resolvedPath, { withFileTypes: true }))
+            .filter(entry => showHidden || !entry.name.startsWith('.'));
+        const entries = await mapWithConcurrency(dirents, STAT_CONCURRENCY, async (entry) => {
+            const entryPath = join(resolvedPath, entry.name);
+            let stats;
+            try {
+                stats = await stat(entryPath);
+            }
+            catch {   }
+            const isDir = stats ? stats.isDirectory() : entry.isDirectory();
+            return toDirectoryEntry(entry.name, isDir, stats, relativeToRoots(entryPath, roots));
+        });
+        entries.sort(compareDirectoryEntries);
+        return { success: true, entries };
+    }
+    catch (error) {
+        return listingFailure(error);
+    }
+}
+function normalizeResolveTo(resolveTo, primaryPath) {
+    const unique = new Set();
+    for (const candidate of resolveTo) {
+        if (typeof candidate !== 'string' || candidate === primaryPath)
+            continue;
+        unique.add(candidate);
+    }
+    return [...unique]
+        .sort((a, b) => depthOf(a) - depthOf(b) || (a < b ? -1 : a > b ? 1 : 0))
+        .slice(0, MAX_RESOLVE_TO);
+}
+function depthOf(path) {
+    return path.split('/').filter(Boolean).length;
+}
+export async function resolveDirectoryListings(dirPath, resolveTo, workingDir, showHidden = false) {
+    const primary = await listDirectoryAsync(dirPath, workingDir, showHidden);
+    if (!primary.success)
+        return { primary, resolved: [] };
+    const targets = normalizeResolveTo(resolveTo, dirPath);
+    const resolved = await mapWithConcurrency(targets, RESOLVE_CONCURRENCY, async (path) => {
+        const result = await listDirectoryAsync(path, workingDir, showHidden);
+        return result.success ? { path, entries: result.entries } : { path, error: result.error };
+    });
+    return { primary, resolved };
+}
+export function validatePathWithinRoots(filePath, workingDir, extraRoots) {
+    const validation = validatePathWithinWorkingDir(filePath, workingDir);
+    if (validation.valid)
+        return validation;
+    for (const root of extraRoots) {
+        const alt = validatePathWithinWorkingDir(filePath, root);
+        if (alt.valid)
+            return alt;
+    }
+    return validation;
+}
+export function writeFile(filePath, content, workingDir, options) {
+    const encoding = options?.encoding;
+    if (containsDangerousPatterns(filePath)) {
+        console.error(`[FileService] SECURITY: Dangerous pattern in path: "${filePath}"`);
+        return { success: false, error: 'Invalid path: contains dangerous patterns' };
+    }
+    const validation = validatePathWithinRoots(filePath, workingDir, options?.extraRoots ?? []);
+    if (!validation.valid) {
+        return { success: false, error: validation.error };
+    }
+    const resolvedPath = validation.resolvedPath;
+    try {
+        const parentDir = dirname(resolvedPath);
+        if (!existsSync(parentDir))
+            mkdirSync(parentDir, { recursive: true });
+        if (existsSync(resolvedPath)) {
+            const stats = statSync(resolvedPath);
+            if (stats.isDirectory()) {
+                return { success: false, error: 'Cannot write to a directory' };
+            }
+        }
+        if (encoding === 'base64') {
+            writeFileSync(resolvedPath, Buffer.from(content, 'base64'));
+        }
+        else {
+            writeFileSync(resolvedPath, content, 'utf-8');
+        }
+        return { success: true, path: resolvedPath.replace(`${workingDir}/`, '') };
+    }
+    catch (error) {
+        console.error('[FileService] Error writing file:', error);
+        return { success: false, error: error instanceof Error ? error.message : 'Failed to write file' };
+    }
+}
+export function createFile(filePath, workingDir) {
+    if (containsDangerousPatterns(filePath)) {
+        console.error(`[FileService] SECURITY: Dangerous pattern in path: "${filePath}"`);
+        return { success: false, error: 'Invalid path: contains dangerous patterns' };
+    }
+    const validation = validatePathWithinWorkingDir(filePath, workingDir);
+    if (!validation.valid) {
+        return { success: false, error: validation.error };
+    }
+    const resolvedPath = validation.resolvedPath;
+    try {
+        if (existsSync(resolvedPath)) {
+            return { success: false, error: 'File already exists' };
+        }
+        const parentDir = dirname(resolvedPath);
+        if (!existsSync(parentDir))
+            mkdirSync(parentDir, { recursive: true });
+        writeFileSync(resolvedPath, '', 'utf-8');
+        return { success: true, path: resolvedPath.replace(`${workingDir}/`, '') };
+    }
+    catch (error) {
+        console.error('[FileService] Error creating file:', error);
+        return { success: false, error: error instanceof Error ? error.message : 'Failed to create file' };
+    }
+}
+export function createDirectory(dirPath, workingDir) {
+    if (containsDangerousPatterns(dirPath)) {
+        console.error(`[FileService] SECURITY: Dangerous pattern in path: "${dirPath}"`);
+        return { success: false, error: 'Invalid path: contains dangerous patterns' };
+    }
+    const validation = validatePathWithinWorkingDir(dirPath, workingDir);
+    if (!validation.valid) {
+        return { success: false, error: validation.error };
+    }
+    const resolvedPath = validation.resolvedPath;
+    try {
+        if (existsSync(resolvedPath)) {
+            const stats = statSync(resolvedPath);
+            if (stats.isDirectory()) {
+                return { success: false, error: 'Directory already exists' };
+            }
+            return { success: false, error: 'A file with that name already exists' };
+        }
+        mkdirSync(resolvedPath, { recursive: true });
+        return { success: true, path: resolvedPath.replace(`${workingDir}/`, '') };
+    }
+    catch (error) {
+        console.error('[FileService] Error creating directory:', error);
+        return { success: false, error: error instanceof Error ? error.message : 'Failed to create directory' };
+    }
+}
+export function deleteFile(targetPath, workingDir) {
+    if (containsDangerousPatterns(targetPath)) {
+        console.error(`[FileService] SECURITY: Dangerous pattern in path: "${targetPath}"`);
+        return { success: false, error: 'Invalid path: contains dangerous patterns' };
+    }
+    const validation = validatePathWithinWorkingDir(targetPath, workingDir);
+    if (!validation.valid) {
+        return { success: false, error: validation.error };
+    }
+    const resolvedPath = validation.resolvedPath;
+    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 {
+        if (!existsSync(resolvedPath)) {
+            return { success: false, error: 'File or directory not found' };
+        }
+        const stats = statSync(resolvedPath);
+        if (stats.isDirectory()) {
+            rmSync(resolvedPath, { recursive: true });
+        }
+        else {
+            unlinkSync(resolvedPath);
+        }
+        return { success: true, path: resolvedPath.replace(`${workingDir}/`, '') };
+    }
+    catch (error) {
+        console.error('[FileService] Error deleting file:', error);
+        return { success: false, error: error instanceof Error ? error.message : 'Failed to delete' };
+    }
+}
+export function renameFile(oldPath, newPath, workingDir) {
+    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' };
+    }
+    const validation = validateBothPathsWithinWorkingDir(oldPath, newPath, workingDir);
+    if (!validation.valid) {
+        return { success: false, error: validation.error };
+    }
+    const resolvedOldPath = validation.resolvedSourcePath;
+    const resolvedNewPath = validation.resolvedDestPath;
+    try {
+        if (!existsSync(resolvedOldPath)) {
+            return { success: false, error: 'Source file or directory not found' };
+        }
+        if (existsSync(resolvedNewPath)) {
+            return { success: false, error: 'Destination already exists' };
+        }
+        const parentDir = dirname(resolvedNewPath);
+        if (!existsSync(parentDir))
+            mkdirSync(parentDir, { recursive: true });
+        renameSync(resolvedOldPath, resolvedNewPath);
+        return { success: true, path: resolvedNewPath.replace(`${workingDir}/`, '') };
+    }
+    catch (error) {
+        console.error('[FileService] Error renaming file:', error);
+        return { success: false, error: error instanceof Error ? error.message : 'Failed to rename' };
+    }
+}

package/dist/server/services/file-transfer-zip.js

@@ -0,0 +1,188 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { createReadStream, lstatSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { dirname, join, relative, sep } from 'node:path';
+import { Zip, ZipDeflate, zipSync } from 'fflate';
+import { isIgnored, parseGitignore } from './websocket/file-utils.js';
+const MAX_ZIP_ENTRIES = 20_000;
+const MAX_ZIP_UNCOMPRESSED_BYTES = 50 * 1024 * 1024;
+export const MAX_STREAMED_ZIP_UNCOMPRESSED_BYTES = 2 * 1024 * 1024 * 1024;
+const STREAM_READ_CHUNK_BYTES = 192 * 1024;
+export class ZipTooLargeError extends Error {
+}
+function addZipEntry(abs, rel, out, budget) {
+    budget.entries += 1;
+    if (budget.entries > MAX_ZIP_ENTRIES) {
+        throw new ZipTooLargeError(`directory has more than ${MAX_ZIP_ENTRIES} files — too large to download as a zip`);
+    }
+    const bytes = readFileSync(abs);
+    budget.bytes += bytes.byteLength;
+    if (budget.bytes > MAX_ZIP_UNCOMPRESSED_BYTES) {
+        throw new ZipTooLargeError(`directory contents exceed ${MAX_ZIP_UNCOMPRESSED_BYTES} bytes uncompressed — too large to download as a zip`);
+    }
+    out[rel] = bytes;
+}
+function shouldSkipEntry(entry, rel, gitignorePatterns) {
+    if (entry.isSymbolicLink())
+        return true;
+    if (entry.isDirectory() && entry.name === '.git')
+        return true;
+    return gitignorePatterns.length > 0 && isIgnored(rel, gitignorePatterns);
+}
+function collectZippableFiles(dir, baseDir, gitignorePatterns, out, budget) {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        const abs = join(dir, entry.name);
+        const rel = relative(baseDir, abs);
+        if (shouldSkipEntry(entry, rel, gitignorePatterns))
+            continue;
+        if (entry.isDirectory()) {
+            collectZippableFiles(abs, baseDir, gitignorePatterns, out, budget);
+        }
+        else if (entry.isFile()) {
+            addZipEntry(abs, rel, out, budget);
+        }
+    }
+}
+export function buildDirectoryZipBuffer(dirPath, options = {}) {
+    const gitignorePatterns = parseGitignore(options.gitignoreRoot ?? dirPath);
+    const files = {};
+    collectZippableFiles(dirPath, dirPath, gitignorePatterns, files, { entries: 0, bytes: 0 });
+    return Buffer.from(zipSync(files, { level: 6 }));
+}
+async function runZipStream(roots, baseDir, gitignorePatterns, onChunk, isCancelled) {
+    const budget = { entries: 0, bytes: 0 };
+    let totalBytes = 0;
+    let pending = Promise.resolve();
+    let streamError = null;
+    const zip = new Zip((err, chunk, _final) => {
+        if (err) {
+            streamError = err instanceof Error ? err : new Error(String(err));
+            return;
+        }
+        if (chunk.length === 0)
+            return;
+        totalBytes += chunk.length;
+        pending = pending.then(() => onChunk(chunk));
+    });
+    const asView = (buf) => new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+    async function pushFileChunks(abs, entry) {
+        let previous = null;
+        for await (const raw of createReadStream(abs, { highWaterMark: STREAM_READ_CHUNK_BYTES })) {
+            const chunk = raw;
+            if (previous) {
+                entry.push(asView(previous), false);
+                await pending;
+                if (streamError)
+                    throw streamError;
+            }
+            previous = chunk;
+        }
+        entry.push(previous ? asView(previous) : new Uint8Array(0), true);
+        await pending;
+        if (streamError)
+            throw streamError;
+    }
+    async function addFile(abs, rel) {
+        budget.entries += 1;
+        if (budget.entries > MAX_ZIP_ENTRIES) {
+            throw new ZipTooLargeError(`directory has more than ${MAX_ZIP_ENTRIES} files — too large to download as a zip`);
+        }
+        const size = statSync(abs).size;
+        budget.bytes += size;
+        if (budget.bytes > MAX_STREAMED_ZIP_UNCOMPRESSED_BYTES) {
+            throw new ZipTooLargeError(`directory contents exceed ${MAX_STREAMED_ZIP_UNCOMPRESSED_BYTES} bytes uncompressed — too large to download as a zip`);
+        }
+        const entry = new ZipDeflate(rel, { level: 6 });
+        zip.add(entry);
+        if (size === 0) {
+            entry.push(new Uint8Array(0), true);
+            await pending;
+            if (streamError)
+                throw streamError;
+            return;
+        }
+        await pushFileChunks(abs, entry);
+    }
+    const stopped = () => isCancelled() || streamError !== null;
+    async function walk(dir) {
+        for (const entry of readdirSync(dir, { withFileTypes: true })) {
+            if (stopped())
+                return;
+            const abs = join(dir, entry.name);
+            const rel = relative(baseDir, abs);
+            if (shouldSkipEntry(entry, rel, gitignorePatterns))
+                continue;
+            if (entry.isDirectory())
+                await walk(abs);
+            else if (entry.isFile())
+                await addFile(abs, rel);
+        }
+    }
+    for (const root of roots) {
+        if (stopped())
+            break;
+        if (root.isDirectory) {
+            await walk(root.abs);
+            continue;
+        }
+        const rel = relative(baseDir, root.abs);
+        let lst;
+        try {
+            lst = lstatSync(root.abs);
+        }
+        catch {
+            continue;
+        }
+        if (lst.isSymbolicLink())
+            continue;
+        if (gitignorePatterns.length > 0 && isIgnored(rel, gitignorePatterns))
+            continue;
+        await addFile(root.abs, rel);
+    }
+    if (streamError)
+        throw streamError;
+    if (isCancelled())
+        return totalBytes;
+    zip.end();
+    await pending;
+    if (streamError)
+        throw streamError;
+    return totalBytes;
+}
+export async function streamDirectoryZip(dirPath, onChunk, options = {}) {
+    const gitignorePatterns = parseGitignore(options.gitignoreRoot ?? dirPath);
+    const isCancelled = options.isCancelled ?? (() => false);
+    return runZipStream([{ abs: dirPath, isDirectory: true }], dirPath, gitignorePatterns, onChunk, isCancelled);
+}
+function commonParentDir(absPaths) {
+    if (absPaths.length <= 1)
+        return dirname(absPaths[0] ?? sep);
+    const parts = absPaths.map((p) => p.split(sep));
+    const minLen = Math.min(...parts.map((p) => p.length));
+    let common = 0;
+    for (let i = 0; i < minLen - 1; i++) {
+        const segment = parts[0][i];
+        if (parts.every((p) => p[i] === segment))
+            common = i + 1;
+        else
+            break;
+    }
+    return common > 0 ? parts[0].slice(0, common).join(sep) : sep;
+}
+export async function streamPathsZip(absPaths, onChunk, options = {}) {
+    const baseDir = commonParentDir(absPaths);
+    const gitignorePatterns = parseGitignore(options.gitignoreRoot ?? baseDir);
+    const isCancelled = options.isCancelled ?? (() => false);
+    const roots = dedupeNestedRoots(absPaths).map((abs) => ({ abs, isDirectory: statSync(abs).isDirectory() }));
+    return runZipStream(roots, baseDir, gitignorePatterns, onChunk, isCancelled);
+}
+function dedupeNestedRoots(absPaths) {
+    const sorted = [...absPaths].sort((a, b) => a.length - b.length);
+    const kept = [];
+    for (const path of sorted) {
+        if (kept.some((ancestor) => path === ancestor || path.startsWith(ancestor + sep)))
+            continue;
+        kept.push(path);
+    }
+    return kept;
+}

package/dist/server/services/files.js

@@ -0,0 +1,111 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+export { createDirectory, createFile, deleteFile, listDirectory, listDirectoryAsync, renameFile, resolveDirectoryListings, writeFile, } from './file-explorer-ops.js';
+export class FileService {
+    workingDirectory;
+    skipDirs = ['node_modules', '.git', '.minionry', 'dist', 'build', '.next', 'coverage', '.vscode', '.idea'];
+    constructor(workingDirectory) {
+        this.workingDirectory = workingDirectory;
+    }
+    getAllFiles(_baseDir = 'working', filter, limit = 10) {
+        const directory = this.workingDirectory;
+        let files = this.scanDirectory(directory, directory);
+        if (filter) {
+            files = this.filterAndScore(files, filter);
+        }
+        if (filter) {
+            files.sort((a, b) => (b.score || 0) - (a.score || 0));
+        }
+        else {
+            files.sort((a, b) => {
+                if (a.isDirectory && !b.isDirectory)
+                    return -1;
+                if (!a.isDirectory && b.isDirectory)
+                    return 1;
+                return a.name.localeCompare(b.name);
+            });
+        }
+        return files.slice(0, limit);
+    }
+    scanDirectory(dir, baseDir, results = []) {
+        try {
+            const dirName = dir.split('/').pop() || '';
+            if (this.skipDirs.includes(dirName)) {
+                return results;
+            }
+            const entries = readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.name.startsWith('.') || this.skipDirs.includes(entry.name)) {
+                    continue;
+                }
+                const fullPath = join(dir, entry.name);
+                const relativePath = fullPath.replace(`${baseDir}/`, '');
+                results.push({
+                    name: entry.name,
+                    path: relativePath,
+                    isDirectory: entry.isDirectory()
+                });
+                if (results.length >= 1000) {
+                    console.warn('[FilesService] Directory scan hit 1000-item limit — results may be incomplete');
+                    return results;
+                }
+                if (entry.isDirectory()) {
+                    this.scanDirectory(fullPath, baseDir, results);
+                }
+            }
+        }
+        catch (_error) {
+        }
+        return results;
+    }
+    filterAndScore(files, filter) {
+        const filterLower = filter.toLowerCase();
+        const scoredFiles = [];
+        for (const file of files) {
+            const nameLower = file.name.toLowerCase();
+            const pathLower = file.path.toLowerCase();
+            let score = 0;
+            if (nameLower.startsWith(filterLower)) {
+                score = 1000;
+            }
+            else if (pathLower.split('/').some(part => part.startsWith(filterLower))) {
+                score = 500;
+            }
+            else if (nameLower.includes(filterLower)) {
+                score = 100;
+            }
+            else if (pathLower.includes(filterLower)) {
+                score = 10;
+            }
+            else {
+                continue;
+            }
+            score += (50 - Math.min(50, file.path.split('/').length * 5));
+            scoredFiles.push({
+                name: file.name,
+                path: file.path,
+                isDirectory: file.isDirectory,
+                score
+            });
+        }
+        return scoredFiles;
+    }
+    getFileStats(path, _baseDir = 'working') {
+        try {
+            const fullPath = join(this.workingDirectory, path);
+            const stats = statSync(fullPath);
+            return {
+                size: stats.size,
+                created: stats.birthtime,
+                modified: stats.mtime,
+                isDirectory: stats.isDirectory(),
+                isFile: stats.isFile()
+            };
+        }
+        catch (_error) {
+            return null;
+        }
+    }
+}

package/dist/server/services/git/branch-ops.js

@@ -0,0 +1,62 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { executeGitCommand } from './command.js';
+import { BRANCH_LIST_FORMAT, findWorktreePathForBranch, parseBranchList } from './parsers.js';
+import { gitFail, gitOk } from './types.js';
+export async function listBranches({ cwd }) {
+    const result = await executeGitCommand(['branch', '-a', `--format=${BRANCH_LIST_FORMAT}`], cwd);
+    if (result.exitCode !== 0) {
+        return gitFail(result.stderr || 'Failed to list branches');
+    }
+    const currentBranchResult = await executeGitCommand(['rev-parse', '--abbrev-ref', 'HEAD'], cwd);
+    const currentBranch = currentBranchResult.stdout.trim() || 'HEAD';
+    return gitOk({ branches: parseBranchList(result.stdout), current: currentBranch });
+}
+export async function findOtherWorktreeForBranch({ cwd, branch }) {
+    const wtListResult = await executeGitCommand(['worktree', 'list', '--porcelain'], cwd);
+    if (wtListResult.exitCode !== 0)
+        return null;
+    const existingWt = findWorktreePathForBranch(wtListResult.stdout, branch);
+    if (!existingWt || existingWt === cwd)
+        return null;
+    return existingWt;
+}
+export async function checkoutBranch({ cwd, branch, create, startPoint }) {
+    const statusResult = await executeGitCommand(['status', '--porcelain'], cwd);
+    if (statusResult.stdout.trim()) {
+        return gitFail('Commit or stash changes before switching branches');
+    }
+    const prevResult = await executeGitCommand(['rev-parse', '--abbrev-ref', 'HEAD'], cwd);
+    const previous = prevResult.stdout.trim();
+    const args = create
+        ? ['checkout', '-b', branch, ...(startPoint ? [startPoint] : [])]
+        : ['checkout', branch];
+    const result = await executeGitCommand(args, cwd);
+    if (result.exitCode !== 0) {
+        return gitFail(result.stderr || 'Failed to checkout branch');
+    }
+    return gitOk({ previous });
+}
+export async function createBranch({ cwd, name, startPoint, checkout }) {
+    const args = ['branch', '--', name, ...(startPoint ? [startPoint] : [])];
+    const result = await executeGitCommand(args, cwd);
+    if (result.exitCode !== 0) {
+        return gitFail(result.stderr || 'Failed to create branch');
+    }
+    const hashResult = await executeGitCommand(['rev-parse', '--short', name], cwd);
+    if (checkout) {
+        await executeGitCommand(['checkout', name], cwd);
+    }
+    return gitOk({ name, hash: hashResult.stdout.trim() });
+}
+export async function deleteBranch({ cwd, name, force }) {
+    const currentResult = await executeGitCommand(['rev-parse', '--abbrev-ref', 'HEAD'], cwd);
+    if (currentResult.stdout.trim() === name) {
+        return gitFail('Cannot delete the currently checked out branch');
+    }
+    const result = await executeGitCommand(['branch', force ? '-D' : '-d', '--', name], cwd);
+    if (result.exitCode !== 0) {
+        return gitFail(result.stderr || 'Failed to delete branch');
+    }
+    return gitOk({ name });
+}