@minionry/minion 0.7.36

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

@@ -0,0 +1,180 @@
+// 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 classifyDefinitionKind(lineContent) {
+    if (/\b(function|def|func|fn)\b/.test(lineContent))
+        return 'function';
+    if (/\bclass\b/.test(lineContent))
+        return 'class';
+    if (/\binterface\b/.test(lineContent))
+        return 'interface';
+    if (/\btype\b/.test(lineContent))
+        return 'type';
+    if (/\b(enum|struct|trait)\b/.test(lineContent))
+        return 'enum';
+    return 'variable';
+}
+function parseDefinitionLine(line, workingDir, definitions) {
+    try {
+        const parsed = JSON.parse(line);
+        if (parsed.type !== 'match')
+            return false;
+        const filePath = relative(workingDir, join(workingDir, parsed.data.path.text));
+        const lineContent = parsed.data.lines.text.replace(/\n$/, '');
+        const column = parsed.data.submatches?.[0]?.start ?? 0;
+        definitions.push({
+            filePath,
+            line: parsed.data.line_number,
+            column: column + 1,
+            lineContent,
+            kind: classifyDefinitionKind(lineContent),
+        });
+        return definitions.length >= 20;
+    }
+    catch {
+        return false;
+    }
+}
+function sortDefinitionsByProximity(definitions, currentFile) {
+    const currentDir = currentFile ? currentFile.substring(0, currentFile.lastIndexOf('/')) : '';
+    definitions.sort((a, b) => {
+        const exactDiff = (a.filePath === currentFile ? 0 : 1) - (b.filePath === currentFile ? 0 : 1);
+        if (exactDiff !== 0)
+            return exactDiff;
+        const dirDiff = (a.filePath.startsWith(`${currentDir}/`) ? 0 : 1) - (b.filePath.startsWith(`${currentDir}/`) ? 0 : 1);
+        if (dirDiff !== 0)
+            return dirDiff;
+        return a.filePath.split('/').length - b.filePath.split('/').length;
+    });
+}
+const DEFINITION_PATTERNS = {
+    typescript: (s) => [
+        `(function|const|let|var|class|interface|type|enum)\\s+${s}\\b`,
+        `export\\s+(default\\s+)?(function|const|let|var|class|interface|type|enum)\\s+${s}\\b`,
+    ],
+    javascript: (s) => [
+        `(function|const|let|var|class)\\s+${s}\\b`,
+        `export\\s+(default\\s+)?(function|const|let|var|class)\\s+${s}\\b`,
+    ],
+    python: (s) => [
+        `(def|class)\\s+${s}\\b`,
+        `${s}\\s*=`,
+    ],
+    go: (s) => [
+        `func\\s+(\\(\\w+\\s+\\*?\\w+\\)\\s+)?${s}\\b`,
+        `type\\s+${s}\\b`,
+        `var\\s+${s}\\b`,
+    ],
+    rust: (s) => [
+        `(fn|struct|enum|trait|type|const|static|mod)\\s+${s}\\b`,
+        `impl\\s+${s}\\b`,
+    ],
+    swift: (s) => [
+        `(func|class|struct|enum|protocol|typealias|actor)\\s+${s}\\b`,
+        `(let|var)\\s+${s}\\b`,
+        `extension\\s+${s}\\b`,
+    ],
+    kotlin: (s) => [
+        `(fun|class|object|interface|typealias|enum\\s+class)\\s+${s}\\b`,
+        `(val|var)\\s+${s}\\b`,
+    ],
+    java: (s) => [
+        `(class|interface|enum)\\s+${s}\\b`,
+        `(public|private|protected|static)?\\s*(void|int|String|boolean|\\w+)\\s+${s}\\s*\\(`,
+    ],
+    ruby: (s) => [
+        `(def|class|module)\\s+${s}\\b`,
+    ],
+};
+const LANGUAGE_GLOBS = {
+    typescript: '*.{ts,tsx}',
+    javascript: '*.{js,jsx,mjs,cjs}',
+    python: '*.py',
+    go: '*.go',
+    rust: '*.rs',
+    swift: '*.swift',
+    kotlin: '*.{kt,kts}',
+    java: '*.java',
+    ruby: '*.rb',
+};
+function buildDefinitionRgArgs(symbol, language) {
+    const escapedSymbol = symbol.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const patterns = DEFINITION_PATTERNS[language] || DEFINITION_PATTERNS.typescript;
+    const combinedPattern = patterns(escapedSymbol).join('|');
+    const fileGlob = LANGUAGE_GLOBS[language] || LANGUAGE_GLOBS.typescript;
+    return [
+        '--json', '-n',
+        '--glob', fileGlob,
+        '--glob', '!node_modules/**',
+        '--glob', '!dist/**',
+        '--glob', '!build/**',
+        '--glob', '!.git/**',
+        '--glob', '!*.min.*',
+        '--glob', '!*.bundle.*',
+        '-e', combinedPattern, '.',
+    ];
+}
+export function findDefinitions(symbol, language, currentFile, workingDir) {
+    return new Promise((resolve) => {
+        const args = buildDefinitionRgArgs(symbol, language);
+        const rgProcess = spawn('rg', args, { cwd: workingDir, stdio: ['ignore', 'pipe', 'pipe'] });
+        let buffer = '';
+        const definitions = [];
+        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 (parseDefinitionLine(line, workingDir, definitions)) {
+                    rgProcess.kill();
+                    return;
+                }
+            }
+        });
+        rgProcess.on('close', () => {
+            sortDefinitionsByProximity(definitions, currentFile);
+            resolve(definitions.slice(0, 10));
+        });
+        rgProcess.on('error', () => resolve([]));
+    });
+}
+export function handleFindDefinition(ctx, ws, msg, tabId, workingDir) {
+    const symbol = msg.data?.symbol;
+    const language = msg.data?.language || 'typescript';
+    const currentFile = msg.data?.currentFile || '';
+    if (!symbol) {
+        ctx.send(ws, { type: 'definitionResult', tabId, data: { definitions: [], symbol: '' } });
+        return;
+    }
+    const args = buildDefinitionRgArgs(symbol, language);
+    const rgProcess = spawn('rg', args, { cwd: workingDir, stdio: ['ignore', 'pipe', 'pipe'] });
+    let rgBuffer = '';
+    const definitions = [];
+    rgProcess.stdout?.on('data', (chunk) => {
+        rgBuffer += chunk.toString();
+        const lines = rgBuffer.split('\n');
+        rgBuffer = lines.pop() || '';
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            if (parseDefinitionLine(line, workingDir, definitions)) {
+                rgProcess.kill();
+                return;
+            }
+        }
+    });
+    rgProcess.on('close', () => {
+        sortDefinitionsByProximity(definitions, currentFile);
+        ctx.send(ws, {
+            type: 'definitionResult',
+            tabId,
+            data: { definitions: definitions.slice(0, 10), symbol },
+        });
+    });
+    rgProcess.on('error', (_err) => {
+        ctx.send(ws, { type: 'definitionResult', tabId, data: { definitions: [], symbol } });
+    });
+}

package/dist/server/services/websocket/file-download-handler.js

@@ -0,0 +1,291 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { createReadStream, existsSync, statSync } from 'node:fs';
+import { basename, resolve, sep } from 'node:path';
+import { streamDirectoryZip, streamPathsZip } from '../file-transfer-zip.js';
+import { isBinaryFile, isPathInSafeLocation } from './file-utils.js';
+const CHUNK_RAW_BYTES = 192 * 1024;
+const MAX_DOWNLOAD_SIZE = 2 * 1024 * 1024 * 1024;
+const MAX_SHARE_DOWNLOAD_SIZE = 50 * 1024 * 1024;
+const IDLE_TIMEOUT_MS = 120_000;
+const SPACE_DOWNLOAD_TYPES = {
+    ready: 'fileDownloadReady',
+    chunk: 'fileDownloadChunk',
+    complete: 'fileDownloadComplete',
+};
+const BACKPRESSURE_HIGH_WATER = 4 * 1024 * 1024;
+const BACKPRESSURE_LOW_WATER = 1 * 1024 * 1024;
+const BACKPRESSURE_POLL_MS = 10;
+function bufferedAmountOf(ws) {
+    const accessor = ws._getBufferedAmount;
+    if (typeof accessor === 'function') {
+        const amount = accessor();
+        return typeof amount === 'number' ? amount : 0;
+    }
+    const raw = ws._ws;
+    return typeof raw?.bufferedAmount === 'number' ? raw.bufferedAmount : 0;
+}
+async function waitForDrain(ws, isCancelled) {
+    while (!isCancelled() && bufferedAmountOf(ws) > BACKPRESSURE_LOW_WATER) {
+        await new Promise((done) => setTimeout(done, BACKPRESSURE_POLL_MS));
+    }
+}
+function getMimeType(fullPath) {
+    const ext = fullPath.toLowerCase().split('.').pop() || '';
+    if (ext === 'svg')
+        return 'image/svg+xml';
+    if (ext === 'jpg' || ext === 'jpeg')
+        return 'image/jpeg';
+    if (ext === 'pdf')
+        return 'application/pdf';
+    if (['png', 'gif', 'webp', 'bmp', 'tiff', 'ico'].includes(ext))
+        return `image/${ext}`;
+    return 'application/octet-stream';
+}
+export class FileDownloadHandler {
+    workingDir;
+    active = new Map();
+    cleanupInterval;
+    constructor(workingDir) {
+        this.workingDir = workingDir;
+        this.cleanupInterval = setInterval(() => this.cleanupStale(), 30_000);
+    }
+    handleDownloadStart(ws, send, tabId, data) {
+        const { downloadId, filePath, paths } = data;
+        const sendError = (error) => send(ws, {
+            type: 'fileDownloadError',
+            tabId,
+            data: { downloadId, error },
+        });
+        try {
+            if (paths && paths.length > 0) {
+                this.startPathsDownload(ws, send, tabId, downloadId, paths, sendError);
+                return;
+            }
+            const normalized = this.resolveSandboxed(filePath, sendError);
+            if (normalized === null)
+                return;
+            const stats = statSync(normalized);
+            if (stats.isDirectory()) {
+                this.startDirectoryDownload(ws, send, tabId, downloadId, filePath, normalized, stats, sendError);
+                return;
+            }
+            if (stats.size > MAX_DOWNLOAD_SIZE) {
+                sendError(`File too large: ${(stats.size / 1024 / 1024).toFixed(1)}MB exceeds ${MAX_DOWNLOAD_SIZE / 1024 / 1024}MB limit`);
+                return;
+            }
+            this.startFileDownload(ws, send, tabId, downloadId, filePath, normalized, stats, sendError, SPACE_DOWNLOAD_TYPES);
+        }
+        catch (err) {
+            sendError(err instanceof Error ? err.message : String(err));
+        }
+    }
+    resolveSandboxed(filePath, sendError) {
+        const fullPath = filePath.startsWith('/') ? filePath : resolve(this.workingDir, filePath);
+        const normalized = resolve(fullPath);
+        const normalizedWorkingDir = resolve(this.workingDir);
+        const withinDir = normalized === normalizedWorkingDir
+            || normalized.startsWith(normalizedWorkingDir + sep);
+        if (!withinDir && !isPathInSafeLocation(normalized)) {
+            sendError('Access denied: path outside allowed locations');
+            return null;
+        }
+        if (!existsSync(normalized)) {
+            sendError('File not found');
+            return null;
+        }
+        return normalized;
+    }
+    startPathsDownload(ws, send, tabId, downloadId, paths, sendError) {
+        const normalized = [];
+        for (const p of paths) {
+            const resolved = this.resolveSandboxed(p, sendError);
+            if (resolved === null)
+                return;
+            normalized.push(resolved);
+        }
+        const readyPayload = {
+            downloadId,
+            filePath: paths[0],
+            fileName: normalized.length === 1 ? `${basename(normalized[0])}.zip` : `${normalized.length} items.zip`,
+            size: null,
+            mimeType: 'application/zip',
+            isImage: false,
+            totalChunks: null,
+            modifiedAt: new Date().toISOString(),
+            preparing: true,
+        };
+        send(ws, { type: SPACE_DOWNLOAD_TYPES.ready, tabId, data: readyPayload });
+        const state = { downloadId, cancelled: false, lastActivity: Date.now() };
+        this.active.set(downloadId, state);
+        void this.pumpZipStream(ws, send, tabId, downloadId, state, sendError, (onChunk, isCancelled) => streamPathsZip(normalized, onChunk, { gitignoreRoot: this.workingDir, isCancelled }));
+    }
+    startResolvedDownload(ws, send, data, types, sendError, owner) {
+        if (data.stats.size > MAX_SHARE_DOWNLOAD_SIZE) {
+            sendError(`File too large: ${(data.stats.size / 1024 / 1024).toFixed(1)}MB exceeds ${MAX_SHARE_DOWNLOAD_SIZE / 1024 / 1024}MB limit`);
+            return;
+        }
+        this.startFileDownload(ws, send, undefined, data.downloadId, data.path, data.resolvedPath, data.stats, sendError, types, owner);
+    }
+    startDirectoryDownload(ws, send, tabId, downloadId, filePath, normalized, stats, sendError) {
+        const readyPayload = {
+            downloadId,
+            filePath,
+            fileName: `${basename(normalized)}.zip`,
+            size: null,
+            mimeType: 'application/zip',
+            isImage: false,
+            totalChunks: null,
+            modifiedAt: stats.mtime.toISOString(),
+            preparing: true,
+        };
+        send(ws, { type: SPACE_DOWNLOAD_TYPES.ready, tabId, data: readyPayload });
+        const state = { downloadId, cancelled: false, lastActivity: Date.now() };
+        this.active.set(downloadId, state);
+        void this.pumpZipStream(ws, send, tabId, downloadId, state, sendError, (onChunk, isCancelled) => streamDirectoryZip(normalized, onChunk, { gitignoreRoot: this.workingDir, isCancelled }));
+    }
+    startFileDownload(ws, send, tabId, downloadId, filePath, normalized, stats, sendError, types, owner) {
+        const totalChunks = Math.max(1, Math.ceil(stats.size / CHUNK_RAW_BYTES));
+        const fileName = basename(normalized);
+        const isImg = isBinaryFile(normalized);
+        send(ws, {
+            type: types.ready,
+            tabId,
+            data: {
+                downloadId,
+                filePath,
+                fileName,
+                size: stats.size,
+                mimeType: getMimeType(normalized),
+                isImage: isImg,
+                totalChunks,
+                modifiedAt: stats.mtime.toISOString(),
+            },
+        });
+        const stream = createReadStream(normalized, { highWaterMark: CHUNK_RAW_BYTES });
+        const state = {
+            downloadId,
+            owner,
+            stream,
+            cancelled: false,
+            lastActivity: Date.now(),
+        };
+        this.active.set(downloadId, state);
+        let chunkIndex = 0;
+        stream.on('data', (buf) => {
+            if (state.cancelled)
+                return;
+            const chunk = typeof buf === 'string' ? Buffer.from(buf) : buf;
+            for (let off = 0; off < chunk.length; off += CHUNK_RAW_BYTES) {
+                const slice = chunk.subarray(off, Math.min(off + CHUNK_RAW_BYTES, chunk.length));
+                send(ws, {
+                    type: types.chunk,
+                    tabId,
+                    data: {
+                        downloadId,
+                        chunkIndex: chunkIndex++,
+                        content: slice.toString('base64'),
+                    },
+                });
+            }
+            state.lastActivity = Date.now();
+            if (bufferedAmountOf(ws) > BACKPRESSURE_HIGH_WATER) {
+                stream.pause();
+                void waitForDrain(ws, () => state.cancelled).then(() => {
+                    if (!state.cancelled)
+                        stream.resume();
+                });
+            }
+        });
+        stream.on('end', () => {
+            if (state.cancelled)
+                return;
+            send(ws, {
+                type: types.complete,
+                tabId,
+                data: { downloadId },
+            });
+            this.active.delete(downloadId);
+        });
+        stream.on('error', (err) => {
+            sendError(`Read failed: ${err.message}`);
+            this.active.delete(downloadId);
+        });
+    }
+    async pumpZipStream(ws, send, tabId, downloadId, state, sendError, streamFn) {
+        let chunkIndex = 0;
+        let carry = Buffer.alloc(0);
+        const flush = async (finalFlush) => {
+            while (!state.cancelled && (carry.length >= CHUNK_RAW_BYTES || (finalFlush && carry.length > 0))) {
+                const size = Math.min(CHUNK_RAW_BYTES, carry.length);
+                const slice = carry.subarray(0, size);
+                carry = carry.subarray(size);
+                if (bufferedAmountOf(ws) > BACKPRESSURE_HIGH_WATER) {
+                    await waitForDrain(ws, () => state.cancelled);
+                    if (state.cancelled)
+                        return;
+                }
+                send(ws, {
+                    type: SPACE_DOWNLOAD_TYPES.chunk,
+                    tabId,
+                    data: { downloadId, chunkIndex: chunkIndex++, content: slice.toString('base64') },
+                });
+                state.lastActivity = Date.now();
+            }
+        };
+        try {
+            const totalBytes = await streamFn(async (chunk) => {
+                if (state.cancelled)
+                    return;
+                carry = Buffer.concat([carry, Buffer.from(chunk)]);
+                await flush(false);
+            }, () => state.cancelled);
+            if (state.cancelled)
+                return;
+            await flush(true);
+            if (state.cancelled)
+                return;
+            const completePayload = { downloadId, size: totalBytes };
+            send(ws, { type: SPACE_DOWNLOAD_TYPES.complete, tabId, data: completePayload });
+            this.active.delete(downloadId);
+        }
+        catch (err) {
+            if (state.cancelled)
+                return;
+            sendError(err instanceof Error ? err.message : String(err));
+            this.active.delete(downloadId);
+        }
+    }
+    handleDownloadCancel(_ws, _send, _tabId, data) {
+        this.cancelDownload(data.downloadId);
+    }
+    cancelDownload(downloadId, expectedOwner) {
+        const state = this.active.get(downloadId);
+        if (!state)
+            return;
+        if (state.owner !== undefined && state.owner !== expectedOwner)
+            return;
+        state.cancelled = true;
+        state.stream?.destroy();
+        this.active.delete(downloadId);
+    }
+    cleanupStale() {
+        const now = Date.now();
+        for (const [id, state] of this.active) {
+            if (now - state.lastActivity > IDLE_TIMEOUT_MS) {
+                console.warn(`[FileDownloadHandler] Download ${id} idle, cleaning up`);
+                state.cancelled = true;
+                state.stream?.destroy();
+                this.active.delete(id);
+            }
+        }
+    }
+    destroy() {
+        clearInterval(this.cleanupInterval);
+        for (const state of this.active.values()) {
+            state.cancelled = true;
+            state.stream?.destroy();
+        }
+        this.active.clear();
+    }
+}