dist/utils/fileSystem.js

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.DATA_ROOT = void 0;
exports.ensureDataRootExists = ensureDataRootExists;
exports.formatBytes = formatBytes;
exports.safeResolvePath = safeResolvePath;
exports.getBreadcrumbs = getBreadcrumbs;
exports.listDirectory = listDirectory;
exports.getFileDetails = getFileDetails;
const fs_1 = __importDefault(require("fs"));
const path_1 = __importDefault(require("path"));
const mime_types_1 = __importDefault(require("mime-types"));
// Storage root directory: defaults to /data on HuggingFace Space
// Can be customized via DATA_DIR env var (e.g. for local testing)
const DEFAULT_DATA_DIR = process.platform === 'win32' ? path_1.default.resolve(process.cwd(), 'data_local') : '/data';
exports.DATA_ROOT = path_1.default.resolve(process.env.DATA_DIR || DEFAULT_DATA_DIR);
// Ensure root storage directory exists in local/dev environment
function ensureDataRootExists() {
    if (!fs_1.default.existsSync(exports.DATA_ROOT)) {
        try {
            fs_1.default.mkdirSync(exports.DATA_ROOT, { recursive: true });
            console.log(`[Storage] Created storage directory at: ${exports.DATA_ROOT}`);
        }
        catch (err) {
            console.error(`[Storage Error] Could not create storage root ${exports.DATA_ROOT}:`, err);
        }
    }
    return exports.DATA_ROOT;
}
function formatBytes(bytes, decimals = 2) {
    if (bytes === 0)
        return '0 Bytes';
    const k = 1024;
    const dm = decimals < 0 ? 0 : decimals;
    const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB'];
    const i = Math.floor(Math.log(bytes) / Math.log(k));
    return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + ' ' + sizes[i];
}
function safeResolvePath(subPath = '') {
    ensureDataRootExists();
    // Normalize and remove leading slashes
    const cleanSubPath = path_1.default.normalize(subPath).replace(/^(\.\.[\/\\])+/, '').replace(/^[/\\]+/, '');
    const fullPath = path_1.default.resolve(exports.DATA_ROOT, cleanSubPath);
    // Security check: path traversal prevention
    if (!fullPath.startsWith(exports.DATA_ROOT)) {
        throw new Error('Access denied: Invalid path traversal target.');
    }
    const relativePath = path_1.default.relative(exports.DATA_ROOT, fullPath).replace(/\\/g, '/');
    return { fullPath, relativePath };
}
function getBreadcrumbs(relativePath) {
    const parts = relativePath.split('/').filter(Boolean);
    const crumbs = [{ name: 'data', path: '' }];
    let accumulated = '';
    for (const part of parts) {
        accumulated = accumulated ? `${accumulated}/${part}` : part;
        crumbs.push({ name: part, path: accumulated });
    }
    return crumbs;
}
function getCategory(isDirectory, ext, mimeType) {
    if (isDirectory)
        return 'folder';
    ext = ext.toLowerCase();
    if (['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg', 'bmp', 'ico'].includes(ext))
        return 'image';
    if (['txt', 'md', 'json', 'js', 'ts', 'html', 'css', 'py', 'sh', 'yaml', 'yml', 'xml', 'c', 'cpp', 'rs', 'go', 'java'].includes(ext))
        return 'code';
    if (['pdf', 'doc', 'docx', 'xls', 'xlsx', 'ppt', 'pptx'].includes(ext))
        return 'document';
    if (['mp3', 'wav', 'ogg', 'flac', 'm4a'].includes(ext))
        return 'audio';
    if (['mp4', 'webm', 'mkv', 'avi', 'mov'].includes(ext))
        return 'video';
    if (['zip', 'tar', 'gz', 'bz2', '7z', 'rar'].includes(ext))
        return 'archive';
    if (['csv', 'parquet', 'arrow', 'feather', 'h5', 'hdf5', 'npy', 'npz', 'pt', 'pth', 'bin', 'onnx', 'safetensors'].includes(ext))
        return 'data';
    return 'file';
}
function listDirectory(subPath = '') {
    const { fullPath, relativePath } = safeResolvePath(subPath);
    if (!fs_1.default.existsSync(fullPath)) {
        throw new Error(`Directory does not exist: /data/${relativePath}`);
    }
    const stat = fs_1.default.statSync(fullPath);
    if (!stat.isDirectory()) {
        throw new Error(`Path /data/${relativePath} is a file, not a directory.`);
    }
    const filenames = fs_1.default.readdirSync(fullPath);
    const items = [];
    let totalFiles = 0;
    let totalFolders = 0;
    let totalSize = 0;
    for (const name of filenames) {
        try {
            const itemFullPath = path_1.default.join(fullPath, name);
            const itemStat = fs_1.default.statSync(itemFullPath);
            const isDir = itemStat.isDirectory();
            const ext = isDir ? '' : path_1.default.extname(name).slice(1);
            const mimeType = isDir ? '' : (mime_types_1.default.lookup(name) || 'application/octet-stream');
            const itemRelPath = relativePath ? `${relativePath}/${name}` : name;
            const size = isDir ? 0 : itemStat.size;
            if (isDir) {
                totalFolders++;
            }
            else {
                totalFiles++;
                totalSize += size;
            }
            items.push({
                name,
                relativePath: itemRelPath,
                isDirectory: isDir,
                size,
                formattedSize: isDir ? '--' : formatBytes(size),
                modifiedAt: itemStat.mtime,
                extension: ext,
                mimeType,
                category: getCategory(isDir, ext, mimeType),
            });
        }
        catch (e) {
            console.warn(`Could not stat item ${name} in ${fullPath}`, e);
        }
    }
    // Sort folders first, then files alphabetically
    items.sort((a, b) => {
        if (a.isDirectory && !b.isDirectory)
            return -1;
        if (!a.isDirectory && b.isDirectory)
            return 1;
        return a.name.localeCompare(b.name, undefined, { sensitivity: 'base', numeric: true });
    });
    return {
        items,
        relativePath,
        breadcrumbs: getBreadcrumbs(relativePath),
        totalFiles,
        totalFolders,
        totalSize,
    };
}
function getFileDetails(subPath) {
    const { fullPath, relativePath } = safeResolvePath(subPath);
    if (!fs_1.default.existsSync(fullPath)) {
        throw new Error(`File does not exist: /data/${relativePath}`);
    }
    const stat = fs_1.default.statSync(fullPath);
    if (stat.isDirectory()) {
        throw new Error(`Path is a directory, not a file.`);
    }
    const name = path_1.default.basename(fullPath);
    const ext = path_1.default.extname(name).slice(1).toLowerCase();
    const mimeType = mime_types_1.default.lookup(name) || 'application/octet-stream';
    const category = getCategory(false, ext, mimeType);
    let textContent = null;
    const MAX_PREVIEW_SIZE = 1024 * 1024; // 1 MB limit for text preview
    if (category === 'code' || ['csv', 'txt', 'json', 'md', 'log', 'yaml', 'yml'].includes(ext)) {
        if (stat.size <= MAX_PREVIEW_SIZE) {
            try {
                textContent = fs_1.default.readFileSync(fullPath, 'utf-8');
            }
            catch (err) {
                textContent = `[Unable to read text content: ${err}]`;
            }
        }
        else {
            // Read first 50KB for large files
            try {
                const fd = fs_1.default.openSync(fullPath, 'r');
                const buffer = Buffer.alloc(50 * 1024);
                const bytesRead = fs_1.default.readSync(fd, buffer, 0, buffer.length, 0);
                fs_1.default.closeSync(fd);
                textContent = buffer.toString('utf-8', 0, bytesRead) + `\n\n... [Preview truncated. Total size: ${formatBytes(stat.size)}]`;
            }
            catch (err) {
                textContent = `[Error reading partial preview]`;
            }
        }
    }
    return {
        name,
        relativePath,
        fullPath,
        size: stat.size,
        formattedSize: formatBytes(stat.size),
        modifiedAt: stat.mtime,
        extension: ext,
        mimeType,
        category,
        textContent,
        breadcrumbs: getBreadcrumbs(relativePath),
    };
}