@minionry/minion 0.7.36

package/dist/server/services/websocket/file-explorer-handlers.js

@@ -0,0 +1,291 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { resolve } from 'node:path';
+import { can } from '@minionry/roles';
+import { getClientId } from '../client-id.js';
+import { createDirectory, createFile, deleteFile, renameFile, resolveDirectoryListings, writeFile } from '../files.js';
+import { validatePathWithinWorkingDir } from '../pathUtils.js';
+import { notifyFileChanged } from '../sdk/file-change-notify.js';
+import { makeSpaceKey } from '../settings.js';
+import { systemPromptsDir } from '../system-prompts.js';
+import { dispatchByType } from './dispatch-util.js';
+import { handleFindDefinition } from './file-definition-handlers.js';
+import { handleCancelSearch, handleSearchFileContents } from './file-search-handlers.js';
+import { readFileContent } from './file-utils.js';
+export const FILES_VIEW_TAB_ID = '__files_view__';
+export function resolveFileDomainRoot(tabId, workingDir, effectiveDir) {
+    return tabId === FILES_VIEW_TAB_ID ? effectiveDir : workingDir;
+}
+export function handleFileMessage(ctx, ws, msg, tabId, workingDir, role) {
+    const isSandboxed = role !== 'owner';
+    switch (msg.type) {
+        case 'autocomplete':
+            handleAutocomplete(ctx, ws, msg, tabId, workingDir, isSandboxed);
+            break;
+        case 'readFile':
+            handleReadFile(ctx, ws, msg, tabId, workingDir, role);
+            break;
+        case 'recordSelection':
+            if (msg.data?.filePath) {
+                if (isSandboxed) {
+                    const validation = validatePathWithinWorkingDir(msg.data.filePath, workingDir);
+                    if (!validation.valid)
+                        break;
+                }
+                ctx.recordFileSelection(resolve(workingDir, msg.data.filePath));
+            }
+            break;
+    }
+}
+function handleAutocomplete(ctx, ws, msg, tabId, workingDir, isSandboxed) {
+    const partialPath = msg.data?.partialPath;
+    const requestId = typeof msg.data?.requestId === 'string' ? msg.data.requestId : undefined;
+    const correlation = requestId === undefined ? {} : { requestId };
+    const failure = (query, error) => {
+        ctx.send(ws, {
+            type: 'autocomplete',
+            tabId,
+            data: {
+                completions: [],
+                query,
+                mode: 'search',
+                totalMatches: 0,
+                truncated: false,
+                indexTruncated: false,
+                error: error instanceof Error ? error.message : String(error),
+                ...correlation,
+            },
+        });
+    };
+    if (typeof partialPath !== 'string' || partialPath.length === 0) {
+        failure('', new Error('Partial path is required'));
+        return;
+    }
+    ctx.autocompleteService
+        .complete(partialPath, workingDir, { sandboxed: isSandboxed })
+        .then((result) => {
+        ctx.send(ws, { type: 'autocomplete', tabId, data: { ...result, ...correlation } });
+    })
+        .catch((error) => failure(partialPath, error));
+}
+function invalidateAutocompleteIndex(ctx) {
+    ctx.autocompleteService?.invalidateIndex();
+}
+function handleReadFile(ctx, ws, msg, tabId, workingDir, role) {
+    if (!msg.data?.filePath)
+        throw new Error('File path is required');
+    const isSandboxed = role !== 'owner';
+    const correlation = typeof msg.data.msgId === 'string' ? { msgId: msg.data.msgId } : {};
+    if (isSandboxed) {
+        const validation = validatePathWithinWorkingDir(msg.data.filePath, workingDir);
+        if (!validation.valid) {
+            ctx.send(ws, { type: 'fileContent', tabId, data: { path: msg.data.filePath, fileName: msg.data.filePath.split('/').pop() || '', content: '', error: 'Sandboxed: path outside project directory', ...correlation } });
+            return;
+        }
+    }
+    ctx.send(ws, { type: 'fileContent', tabId, data: { ...readFileContent(msg.data.filePath, workingDir), ...correlation } });
+}
+function sendFileResult(ctx, ws, type, tabId, result, successData) {
+    const data = result.success
+        ? { success: true, path: result.path, ...successData }
+        : { success: false, path: result.path, error: result.error };
+    ctx.send(ws, { type, tabId, data });
+}
+const SANDBOX_PATH_ERROR = 'Sandboxed: path outside project directory';
+function guardSandboxedPath(isSandboxed, path, workingDir, onBlocked) {
+    if (!isSandboxed || !path)
+        return true;
+    if (validatePathWithinWorkingDir(path, workingDir).valid)
+        return true;
+    onBlocked();
+    return false;
+}
+function sendSandboxFileError(ctx, ws, tabId, operation, path) {
+    ctx.send(ws, { type: 'fileError', tabId, data: { operation, path: path || '', error: SANDBOX_PATH_ERROR } });
+}
+function checkSandboxAccess(ctx, ws, msg, tabId, workingDir, role) {
+    const guard = (path, onBlocked) => guardSandboxedPath(true, path, workingDir, onBlocked);
+    switch (msg.type) {
+        case 'listDirectory':
+            return guard(msg.data?.dirPath, () => ctx.send(ws, { type: 'directoryListing', tabId, data: { success: false, path: msg.data?.dirPath, error: SANDBOX_PATH_ERROR } }));
+        case 'writeFile':
+            if (role === 'owner' && msg.data?.filePath &&
+                validatePathWithinWorkingDir(msg.data.filePath, systemPromptsDir()).valid) {
+                return true;
+            }
+            return guard(msg.data?.filePath, () => sendSandboxFileError(ctx, ws, tabId, 'writeFile', msg.data?.filePath));
+        case 'createFile':
+            return guard(msg.data?.filePath, () => sendSandboxFileError(ctx, ws, tabId, 'createFile', msg.data?.filePath));
+        case 'createDirectory':
+            return guard(msg.data?.dirPath, () => sendSandboxFileError(ctx, ws, tabId, 'createDirectory', msg.data?.dirPath));
+        case 'deleteFile':
+            return guard(msg.data?.filePath, () => sendSandboxFileError(ctx, ws, tabId, 'deleteFile', msg.data?.filePath));
+        case 'renameFile': {
+            const oldOk = msg.data?.oldPath ? validatePathWithinWorkingDir(msg.data.oldPath, workingDir).valid : false;
+            const newOk = msg.data?.newPath ? validatePathWithinWorkingDir(msg.data.newPath, workingDir).valid : false;
+            if (!oldOk || !newOk) {
+                sendSandboxFileError(ctx, ws, tabId, 'renameFile', msg.data?.oldPath);
+                return false;
+            }
+            return true;
+        }
+        case 'searchFileContents': {
+            const searchPath = msg.data?.query ? (msg.data.path || msg.data.dirPath) : undefined;
+            return guard(searchPath, () => ctx.send(ws, { type: 'contentSearchError', tabId, data: { error: 'Sandboxed: search path outside project directory' } }));
+        }
+        case 'findDefinition':
+            return guard(msg.data?.filePath, () => ctx.send(ws, { type: 'definitionResult', tabId, data: { definitions: [], symbol: msg.data?.symbol || '' } }));
+        default:
+            return true;
+    }
+}
+const FILE_EXPLORER_WRITE_OPS = new Set(['writeFile', 'createFile', 'createDirectory', 'deleteFile', 'renameFile']);
+export function handleFileExplorerMessage(ctx, ws, msg, tabId, workingDir, role) {
+    const handlers = {
+        listDirectory: () => handleListDirectory(ctx, ws, msg, tabId, workingDir),
+        writeFile: () => handleWriteFile(ctx, ws, msg, tabId, workingDir, role),
+        createFile: () => handleCreateFile(ctx, ws, msg, tabId, workingDir),
+        createDirectory: () => handleCreateDirectory(ctx, ws, msg, tabId, workingDir),
+        deleteFile: () => handleDeleteFile(ctx, ws, msg, tabId, workingDir),
+        renameFile: () => handleRenameFile(ctx, ws, msg, tabId, workingDir),
+        notifyFileOpened: () => handleNotifyFileOpened(ctx, ws, msg, workingDir),
+        searchFileContents: () => handleSearchFileContents(ctx, ws, msg, tabId, workingDir),
+        cancelSearch: () => handleCancelSearch(ctx, tabId),
+        findDefinition: () => handleFindDefinition(ctx, ws, msg, tabId, workingDir),
+    };
+    const isWrite = FILE_EXPLORER_WRITE_OPS.has(msg.type);
+    try {
+        if (isWrite && !can(role, 'editFiles')) {
+            ctx.send(ws, { type: 'fileError', tabId, data: { operation: msg.type, path: msg.data?.dirPath || msg.data?.filePath || msg.data?.oldPath || '', error: 'Your role does not permit editing files' } });
+            return;
+        }
+        if ((isWrite || role !== 'owner') && !checkSandboxAccess(ctx, ws, msg, tabId, workingDir, role))
+            return;
+        dispatchByType(handlers, 'file-explorer', msg.type, (type) => {
+            ctx.send(ws, { type: 'fileError', tabId, data: { operation: type, path: msg.data?.dirPath || msg.data?.filePath || msg.data?.oldPath || '', error: `Unknown file-explorer message type: ${type}` } });
+        });
+        if (isWrite)
+            invalidateAutocompleteIndex(ctx);
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        ctx.send(ws, {
+            type: 'fileError',
+            tabId,
+            data: { operation: msg.type, path: msg.data?.dirPath || msg.data?.filePath || '', error: errorMessage },
+        });
+    }
+}
+function handleListDirectory(ctx, ws, msg, tabId, workingDir) {
+    if (msg.data?.dirPath === undefined)
+        throw new Error('Directory path is required');
+    const dirPath = msg.data.dirPath;
+    const showHidden = msg.data.showHidden ?? false;
+    const correlation = typeof msg.data.msgId === 'string' ? { msgId: msg.data.msgId } : {};
+    const resolveTo = Array.isArray(msg.data.resolveTo) ? msg.data.resolveTo : undefined;
+    const reply = (data) => {
+        ctx.send(ws, { type: 'directoryListing', tabId, data: { ...data, path: dirPath, ...correlation } });
+    };
+    resolveDirectoryListings(dirPath, resolveTo ?? [], workingDir, showHidden)
+        .then(({ primary, resolved }) => {
+        if (!primary.success) {
+            reply({ success: false, error: primary.error });
+            return;
+        }
+        reply({ success: true, entries: primary.entries, ...(resolveTo ? { resolved } : {}) });
+    })
+        .catch((error) => {
+        reply({ success: false, error: error instanceof Error ? error.message : String(error) });
+    });
+}
+function handleWriteFile(ctx, ws, msg, tabId, workingDir, role) {
+    if (!msg.data?.filePath)
+        throw new Error('File path is required');
+    if (msg.data.content === undefined)
+        throw new Error('Content is required');
+    const encoding = msg.data.encoding === 'base64' ? 'base64' : undefined;
+    const extraRoots = role === 'owner' ? [systemPromptsDir()] : [];
+    const result = writeFile(msg.data.filePath, msg.data.content, workingDir, { encoding, extraRoots });
+    if (result.success && result.path && encoding !== 'base64') {
+        ctx.collabSessions?.noteExternalWrite(resolve(workingDir, result.path), msg.data.content);
+    }
+    sendFileResult(ctx, ws, 'fileWritten', tabId, { ...result, path: msg.data.filePath });
+    if (result.success) {
+        ctx.broadcastToOthers(ws, {
+            type: 'fileContentChanged',
+            data: { path: result.path, content: msg.data.content }
+        });
+        if (result.path)
+            notifyFileChanged(makeSpaceKey(getClientId(), workingDir), workingDir, result.path, 'changed');
+    }
+}
+function handleCreateFile(ctx, ws, msg, tabId, workingDir) {
+    if (!msg.data?.filePath)
+        throw new Error('File path is required');
+    const result = createFile(msg.data.filePath, workingDir);
+    sendFileResult(ctx, ws, 'fileCreated', tabId, result);
+    if (result.success && result.path) {
+        const name = result.path.split('/').pop() || 'unknown';
+        ctx.broadcastToOthers(ws, {
+            type: 'fileCreated',
+            data: { path: result.path, name, size: 0, modifiedAt: new Date().toISOString() }
+        });
+    }
+}
+function handleCreateDirectory(ctx, ws, msg, tabId, workingDir) {
+    if (!msg.data?.dirPath)
+        throw new Error('Directory path is required');
+    const result = createDirectory(msg.data.dirPath, workingDir);
+    sendFileResult(ctx, ws, 'directoryCreated', tabId, result);
+    if (result.success && result.path) {
+        const name = result.path.split('/').pop() || 'unknown';
+        ctx.broadcastToOthers(ws, {
+            type: 'directoryCreated',
+            data: { path: result.path, name }
+        });
+    }
+}
+function handleDeleteFile(ctx, ws, msg, tabId, workingDir) {
+    if (!msg.data?.filePath)
+        throw new Error('File path is required');
+    const result = deleteFile(msg.data.filePath, workingDir);
+    sendFileResult(ctx, ws, 'fileDeleted', tabId, result);
+    if (result.success && result.path) {
+        ctx.broadcastToOthers(ws, {
+            type: 'fileDeleted',
+            data: { path: result.path }
+        });
+    }
+}
+function handleRenameFile(ctx, ws, msg, tabId, workingDir) {
+    if (!msg.data?.oldPath)
+        throw new Error('Old path is required');
+    if (!msg.data?.newPath)
+        throw new Error('New path is required');
+    const result = renameFile(msg.data.oldPath, msg.data.newPath, workingDir);
+    const renamedName = result.path?.split('/').pop() || 'unknown';
+    sendFileResult(ctx, ws, 'fileRenamed', tabId, result, { oldPath: msg.data.oldPath, newPath: result.path, name: renamedName });
+    if (result.success && result.path) {
+        const name = result.path.split('/').pop() || 'unknown';
+        ctx.broadcastToOthers(ws, {
+            type: 'fileRenamed',
+            data: { oldPath: msg.data.oldPath, newPath: result.path, name }
+        });
+    }
+}
+function handleNotifyFileOpened(ctx, ws, msg, workingDir) {
+    if (!msg.data?.filePath)
+        return;
+    const fileData = readFileContent(msg.data.filePath, workingDir);
+    if (!fileData.error) {
+        ctx.broadcastToOthers(ws, {
+            type: 'fileOpened',
+            data: {
+                path: msg.data.filePath,
+                fileName: fileData.fileName,
+                content: fileData.content
+            }
+        });
+        notifyFileChanged(makeSpaceKey(getClientId(), workingDir), workingDir, msg.data.filePath, 'opened');
+    }
+}

package/dist/server/services/websocket/file-search-handlers.js

@@ -0,0 +1,267 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { spawn } from 'node:child_process';
+import { join, relative } from 'node:path';
+function newSearchAccumulator(maxResults, sendBatch) {
+    const acc = {
+        batch: [],
+        seenFiles: new Set(),
+        totalMatches: 0,
+        fileCount: 0,
+        maxResults,
+        flush: () => {
+            if (acc.batch.length > 0) {
+                sendBatch(acc.batch);
+                acc.batch = [];
+            }
+        },
+    };
+    return acc;
+}
+function recordMatch(acc, match) {
+    if (!acc.seenFiles.has(match.filePath)) {
+        acc.seenFiles.add(match.filePath);
+        acc.fileCount++;
+    }
+    acc.totalMatches++;
+    acc.batch.push(match);
+    if (acc.totalMatches >= acc.maxResults) {
+        acc.flush();
+        return true;
+    }
+    if (acc.batch.length >= 50)
+        acc.flush();
+    return false;
+}
+function appendGlobArgs(args, globStr, prefix) {
+    for (const glob of globStr.split(',')) {
+        const trimmed = glob.trim();
+        if (trimmed)
+            args.push('--glob', `${prefix}${trimmed}`);
+    }
+}
+function buildRgArgs(query, options) {
+    const args = ['--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, '');
+    if (options.excludeGlob)
+        appendGlobArgs(args, options.excludeGlob, '!');
+    args.push('--', query, '.');
+    return args;
+}
+function processRgSearchLine(line, workingDir, acc) {
+    try {
+        const parsed = JSON.parse(line);
+        if (parsed.type === 'match') {
+            return processRgMatch(parsed, workingDir, acc);
+        }
+        if (parsed.type === 'context') {
+            appendRgContext(parsed, workingDir, acc.batch);
+        }
+    }
+    catch {
+    }
+    return false;
+}
+function processRgMatch(parsed, workingDir, acc) {
+    const filePath = relative(workingDir, join(workingDir, parsed.data.path.text));
+    if (filePath.startsWith('..'))
+        return false;
+    const lineContent = parsed.data.lines.text.replace(/\n$/, '');
+    const column = (parsed.data.submatches?.[0]?.start ?? 0) + 1;
+    return recordMatch(acc, { filePath, line: parsed.data.line_number, column, lineContent, contextBefore: [], contextAfter: [] });
+}
+function appendRgContext(parsed, workingDir, batch) {
+    const filePath = relative(workingDir, join(workingDir, parsed.data.path.text));
+    if (filePath.startsWith('..'))
+        return;
+    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 streamRgSearch(query, options, workingDir, callbacks) {
+    const startTime = Date.now();
+    const acc = newSearchAccumulator(options.maxResults || 5000, callbacks.onBatch);
+    const args = buildRgArgs(query, options);
+    const rgProcess = spawn('rg', args, { cwd: workingDir, stdio: ['ignore', 'pipe', 'pipe'] });
+    let buffer = '';
+    let stopped = false;
+    rgProcess.stdout?.on('data', (chunk) => {
+        buffer += chunk.toString();
+        const lines = buffer.split('\n');
+        buffer = lines.pop() || '';
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            if (processRgSearchLine(line, workingDir, acc)) {
+                rgProcess.kill();
+                return;
+            }
+        }
+    });
+    rgProcess.stderr?.on('data', (chunk) => {
+        const errText = chunk.toString().trim();
+        if (errText && !errText.includes('No files were searched')) {
+            console.error(`[Search] rg stderr: ${errText}`);
+        }
+    });
+    rgProcess.on('close', () => {
+        if (stopped)
+            return;
+        stopped = true;
+        acc.flush();
+        callbacks.onComplete({
+            totalMatches: acc.totalMatches,
+            fileCount: acc.fileCount,
+            truncated: acc.totalMatches >= acc.maxResults,
+            durationMs: Date.now() - startTime,
+        });
+    });
+    rgProcess.on('error', (err) => {
+        if (stopped)
+            return;
+        stopped = true;
+        callbacks.onError(err.code === 'ENOENT' ? 'ripgrep (rg) is not installed on this host' : err.message);
+    });
+    return {
+        cancel: () => {
+            if (stopped)
+                return;
+            stopped = true;
+            rgProcess.kill();
+        },
+    };
+}
+export function handleSearchFileContents(ctx, ws, msg, tabId, workingDir) {
+    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();
+    const acc = newSearchAccumulator(options.maxResults || 5000, (matches) => {
+        ctx.send(ws, { type: 'contentSearchResults', tabId, data: { matches, partial: true } });
+    });
+    const args = buildRgArgs(query, options);
+    const rgProcess = spawn('rg', args, { cwd: workingDir, stdio: ['ignore', 'pipe', 'pipe'] });
+    ctx.activeSearches.set(tabId, rgProcess);
+    let buffer = '';
+    rgProcess.stdout?.on('data', (chunk) => {
+        buffer += chunk.toString();
+        const lines = buffer.split('\n');
+        buffer = lines.pop() || '';
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            if (processRgSearchLine(line, workingDir, acc)) {
+                rgProcess.kill();
+                return;
+            }
+        }
+    });
+    rgProcess.stderr?.on('data', (chunk) => {
+        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);
+        acc.flush();
+        ctx.send(ws, {
+            type: 'contentSearchComplete',
+            tabId,
+            data: {
+                totalMatches: acc.totalMatches,
+                fileCount: acc.fileCount,
+                truncated: acc.totalMatches >= acc.maxResults,
+                durationMs: Date.now() - startTime,
+            },
+        });
+    });
+    rgProcess.on('error', (err) => {
+        ctx.activeSearches.delete(tabId);
+        if (err.code === 'ENOENT') {
+            handleSearchFallback(ctx, ws, query, options, tabId, workingDir);
+        }
+        else {
+            ctx.send(ws, { type: 'contentSearchError', tabId, data: { error: err.message } });
+        }
+    });
+}
+function processGrepLine(line, acc) {
+    const match = line.match(/^\.\/(.+?):(\d+):(.*)$/);
+    if (!match)
+        return false;
+    return recordMatch(acc, { filePath: match[1], line: parseInt(match[2], 10), column: 1, lineContent: match[3], contextBefore: [], contextAfter: [] });
+}
+function handleSearchFallback(ctx, ws, query, options, tabId, workingDir) {
+    const startTime = Date.now();
+    const args = ['-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 = '';
+    const acc = newSearchAccumulator(options.maxResults || 5000, (matches) => {
+        ctx.send(ws, { type: 'contentSearchResults', tabId, data: { matches, partial: true } });
+    });
+    grepProcess.stdout?.on('data', (chunk) => {
+        buffer += chunk.toString();
+        const lines = buffer.split('\n');
+        buffer = lines.pop() || '';
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            if (processGrepLine(line, acc)) {
+                grepProcess.kill();
+                return;
+            }
+        }
+    });
+    grepProcess.on('close', () => {
+        ctx.activeSearches.delete(tabId);
+        acc.flush();
+        ctx.send(ws, {
+            type: 'contentSearchComplete',
+            tabId,
+            data: { totalMatches: acc.totalMatches, fileCount: acc.fileCount, truncated: acc.totalMatches >= acc.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, tabId) {
+    const process = ctx.activeSearches.get(tabId);
+    if (process) {
+        process.kill();
+        ctx.activeSearches.delete(tabId);
+    }
+}