nebula-notebook 0.1.0

package/node-server/dist/fs/fs-service.js

@@ -0,0 +1,1422 @@
+"use strict";
+/**
+ * Filesystem Service - Real filesystem operations
+ *
+ * Node.js port of the Python FilesystemService.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fsService = exports.FilesystemService = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const crypto = __importStar(require("crypto"));
+const util_1 = require("util");
+const default_kernel_1 = require("../kernel/default-kernel");
+const display_data_1 = require("../output/display-data");
+const NEBULA_DIR = path.join(os.homedir(), '.nebula');
+const USER_CONFIG_PATH = path.join(NEBULA_DIR, 'config.json');
+const PROJECT_CONFIG_PATH = path.join(__dirname, '..', '..', '..', '.nebula-config.json');
+const NOTEBOOK_METADATA_FAST_PATH_BYTES = 64 * 1024;
+const NOTEBOOK_METADATA_FALLBACK_PARSE_BYTES = 8 * 1024 * 1024;
+function readJsonString(source, startIndex) {
+    if (source[startIndex] !== '"') {
+        return null;
+    }
+    let i = startIndex + 1;
+    let escaped = false;
+    while (i < source.length) {
+        const ch = source[i];
+        if (escaped) {
+            escaped = false;
+            i++;
+            continue;
+        }
+        if (ch === '\\') {
+            escaped = true;
+            i++;
+            continue;
+        }
+        if (ch === '"') {
+            try {
+                return {
+                    value: JSON.parse(source.slice(startIndex, i + 1)),
+                    endIndex: i + 1,
+                };
+            }
+            catch {
+                return null;
+            }
+        }
+        i++;
+    }
+    return null;
+}
+function findMatchingJsonObjectEnd(source, startIndex) {
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    for (let i = startIndex; i < source.length; i++) {
+        const ch = source[i];
+        if (inString) {
+            if (escaped) {
+                escaped = false;
+            }
+            else if (ch === '\\') {
+                escaped = true;
+            }
+            else if (ch === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (ch === '"') {
+            inString = true;
+            continue;
+        }
+        if (ch === '{') {
+            depth++;
+            continue;
+        }
+        if (ch === '}') {
+            depth--;
+            if (depth === 0) {
+                return i;
+            }
+        }
+    }
+    return -1;
+}
+function extractTopLevelObjectField(source, fieldName) {
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    for (let i = 0; i < source.length; i++) {
+        const ch = source[i];
+        if (inString) {
+            if (escaped) {
+                escaped = false;
+            }
+            else if (ch === '\\') {
+                escaped = true;
+            }
+            else if (ch === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (ch === '"') {
+            if (depth !== 1) {
+                inString = true;
+                continue;
+            }
+            const key = readJsonString(source, i);
+            if (!key) {
+                return null;
+            }
+            let j = key.endIndex;
+            while (j < source.length && /\s/.test(source[j])) {
+                j++;
+            }
+            if (source[j] !== ':') {
+                i = key.endIndex - 1;
+                continue;
+            }
+            if (key.value !== fieldName) {
+                i = key.endIndex - 1;
+                continue;
+            }
+            j++;
+            while (j < source.length && /\s/.test(source[j])) {
+                j++;
+            }
+            if (source[j] !== '{') {
+                return null;
+            }
+            const endIndex = findMatchingJsonObjectEnd(source, j);
+            if (endIndex === -1) {
+                return null;
+            }
+            try {
+                return JSON.parse(source.slice(j, endIndex + 1));
+            }
+            catch {
+                return null;
+            }
+        }
+        if (ch === '{' || ch === '[') {
+            depth++;
+        }
+        else if (ch === '}' || ch === ']') {
+            depth--;
+        }
+    }
+    return null;
+}
+/**
+ * Load root directory from config files if they exist.
+ * Priority: env -> user config -> project config.
+ */
+function loadNebulaConfig() {
+    const envRoot = process.env.NEBULA_WORKDIR || process.env.NEBULA_ROOT;
+    if (envRoot) {
+        return envRoot;
+    }
+    try {
+        if (fs.existsSync(USER_CONFIG_PATH)) {
+            const config = JSON.parse(fs.readFileSync(USER_CONFIG_PATH, 'utf-8'));
+            if (config.rootDirectory) {
+                return config.rootDirectory;
+            }
+        }
+    }
+    catch {
+        // Ignore user config errors
+    }
+    try {
+        if (fs.existsSync(PROJECT_CONFIG_PATH)) {
+            const config = JSON.parse(fs.readFileSync(PROJECT_CONFIG_PATH, 'utf-8'));
+            if (config.rootDirectory) {
+                return config.rootDirectory;
+            }
+        }
+    }
+    catch {
+        // Ignore project config errors
+    }
+    return null;
+}
+class FilesystemService {
+    writeLocks = new Map();
+    defaultRoot;
+    constructor(defaultRoot) {
+        // Priority: explicit arg > config file > home directory
+        const configuredRoot = defaultRoot || loadNebulaConfig() || os.homedir();
+        this.defaultRoot = this.expandRootDirectory(configuredRoot);
+    }
+    /**
+     * Get the server root directory.
+     */
+    getRootDirectory() {
+        return this.defaultRoot;
+    }
+    /**
+     * Set the server root directory and persist it.
+     */
+    setRootDirectory(rootDirectory, options) {
+        const resolved = this.expandRootDirectory(rootDirectory);
+        if (!fs.existsSync(resolved)) {
+            throw new Error(`Root directory not found: ${resolved}`);
+        }
+        if (!fs.statSync(resolved).isDirectory()) {
+            throw new Error(`Root directory is not a folder: ${resolved}`);
+        }
+        this.defaultRoot = resolved;
+        if (options?.persist !== false) {
+            this.saveRootDirectory(resolved);
+        }
+        return this.defaultRoot;
+    }
+    expandRootDirectory(rootDirectory) {
+        const trimmed = rootDirectory.trim();
+        if (trimmed === '' || trimmed === '~') {
+            return os.homedir();
+        }
+        if (trimmed.startsWith('~/')) {
+            return path.join(os.homedir(), trimmed.slice(2));
+        }
+        return path.resolve(trimmed);
+    }
+    saveRootDirectory(rootDirectory) {
+        if (!fs.existsSync(NEBULA_DIR)) {
+            fs.mkdirSync(NEBULA_DIR, { recursive: true, mode: 0o700 });
+        }
+        const config = { rootDirectory };
+        fs.writeFileSync(USER_CONFIG_PATH, JSON.stringify(config, null, 2), { mode: 0o600 });
+    }
+    /**
+     * Normalize and expand path
+     */
+    normalizePath(filePath) {
+        if (filePath === '~' || filePath === '') {
+            return this.defaultRoot;
+        }
+        if (filePath.startsWith('~/')) {
+            return path.join(this.defaultRoot, filePath.slice(2));
+        }
+        if (filePath.startsWith('~')) {
+            // Handle ~user paths (rare in practice)
+            return path.resolve(os.homedir(), '..', filePath.slice(1));
+        }
+        if (!path.isAbsolute(filePath)) {
+            return path.resolve(this.defaultRoot, filePath);
+        }
+        return path.resolve(filePath);
+    }
+    /**
+     * Serialize write operations per notebook to avoid interleaving writes.
+     */
+    async withWriteLock(notebookPath, fn) {
+        const key = this.normalizePath(notebookPath);
+        const previous = this.writeLocks.get(key) || Promise.resolve();
+        let release;
+        const current = new Promise((resolve) => {
+            release = resolve;
+        });
+        const next = previous.then(() => current);
+        this.writeLocks.set(key, next);
+        await previous;
+        try {
+            return await fn();
+        }
+        finally {
+            release();
+            if (this.writeLocks.get(key) === next) {
+                this.writeLocks.delete(key);
+            }
+        }
+    }
+    /**
+     * Atomically write a file (write temp, fsync, rename, fsync dir).
+     * Prevents partial/corrupt files on interruption.
+     */
+    atomicWriteFileSync(targetPath, data) {
+        const dir = path.dirname(targetPath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        const tmpName = `.${path.basename(targetPath)}.${process.pid}.${Date.now()}.${crypto.randomUUID()}.tmp`;
+        const tmpPath = path.join(dir, tmpName);
+        const fd = fs.openSync(tmpPath, 'w', 0o600);
+        try {
+            fs.writeFileSync(fd, data, 'utf-8');
+            fs.fsyncSync(fd);
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+        fs.renameSync(tmpPath, targetPath);
+        // Best-effort directory fsync
+        try {
+            const dirFd = fs.openSync(dir, 'r');
+            try {
+                fs.fsyncSync(dirFd);
+            }
+            finally {
+                fs.closeSync(dirFd);
+            }
+        }
+        catch {
+            // Ignore fsync errors on directory handles
+        }
+    }
+    writeJsonAtomicSync(targetPath, payload) {
+        this.atomicWriteFileSync(targetPath, JSON.stringify(payload, null, 2));
+    }
+    /**
+     * Format file size for display
+     */
+    formatSize(size) {
+        if (size < 1024) {
+            return `${size}B`;
+        }
+        else if (size < 1024 * 1024) {
+            return `${(size / 1024).toFixed(1)}KB`;
+        }
+        else if (size < 1024 * 1024 * 1024) {
+            return `${(size / (1024 * 1024)).toFixed(1)}MB`;
+        }
+        else {
+            return `${(size / (1024 * 1024 * 1024)).toFixed(1)}GB`;
+        }
+    }
+    /**
+     * Determine file type from extension
+     */
+    getFileType(extension) {
+        const ext = extension.toLowerCase();
+        if (ext === '.ipynb') {
+            return 'notebook';
+        }
+        else if (['.py', '.js', '.ts', '.tsx', '.jsx', '.json', '.yaml', '.yml', '.toml', '.md', '.txt'].includes(ext)) {
+            return 'code';
+        }
+        else if (['.csv', '.tsv', '.xlsx', '.xls'].includes(ext)) {
+            return 'data';
+        }
+        else if (['.png', '.jpg', '.jpeg', '.gif', '.svg', '.webp'].includes(ext)) {
+            return 'image';
+        }
+        else if (ext === '.pdf') {
+            return 'document';
+        }
+        return 'file';
+    }
+    /**
+     * Get file info for a path
+     */
+    getFileInfo(filePath) {
+        const stat = fs.statSync(filePath);
+        const name = path.basename(filePath);
+        const isDir = stat.isDirectory();
+        return {
+            name,
+            path: filePath,
+            isDirectory: isDir,
+            size: isDir ? 0 : stat.size,
+            modified: stat.mtimeMs / 1000, // Convert to seconds
+            extension: isDir ? '' : path.extname(name),
+        };
+    }
+    /**
+     * Convert FileInfo to FileInfoResponse for API
+     */
+    toFileInfoResponse(info) {
+        return {
+            id: info.path,
+            name: info.name,
+            path: info.path,
+            isDirectory: info.isDirectory,
+            size: this.formatSize(info.size),
+            sizeBytes: info.size,
+            modified: info.modified,
+            extension: info.extension,
+            fileType: info.isDirectory ? 'folder' : this.getFileType(info.extension),
+        };
+    }
+    /**
+     * Get directory modification time (lightweight check for changes)
+     */
+    getDirectoryMtime(dirPath) {
+        const normalizedPath = this.normalizePath(dirPath);
+        if (!fs.existsSync(normalizedPath)) {
+            throw new Error(`Path not found: ${normalizedPath}`);
+        }
+        const stat = fs.statSync(normalizedPath);
+        if (!stat.isDirectory()) {
+            throw new Error(`Not a directory: ${normalizedPath}`);
+        }
+        return {
+            path: normalizedPath,
+            mtime: stat.mtimeMs / 1000,
+        };
+    }
+    /**
+     * Get file modification time
+     */
+    getFileMtime(filePath) {
+        const normalizedPath = this.normalizePath(filePath);
+        if (!fs.existsSync(normalizedPath)) {
+            throw new Error(`File not found: ${normalizedPath}`);
+        }
+        const stat = fs.statSync(normalizedPath);
+        return {
+            path: normalizedPath,
+            mtime: stat.mtimeMs / 1000,
+        };
+    }
+    /**
+     * List contents of a directory
+     */
+    listDirectory(dirPath) {
+        const normalizedPath = this.normalizePath(dirPath);
+        if (!fs.existsSync(normalizedPath)) {
+            throw new Error(`Path not found: ${normalizedPath}`);
+        }
+        const stat = fs.statSync(normalizedPath);
+        if (!stat.isDirectory()) {
+            throw new Error(`Not a directory: ${normalizedPath}`);
+        }
+        const items = [];
+        const entries = fs.readdirSync(normalizedPath);
+        for (const name of entries) {
+            // Skip hidden files
+            if (name.startsWith('.')) {
+                continue;
+            }
+            const fullPath = path.join(normalizedPath, name);
+            try {
+                const info = this.getFileInfo(fullPath);
+                items.push(this.toFileInfoResponse(info));
+            }
+            catch {
+                // Skip files we can't access
+                continue;
+            }
+        }
+        // Sort: directories first, then by name
+        items.sort((a, b) => {
+            if (a.isDirectory !== b.isDirectory) {
+                return a.isDirectory ? -1 : 1;
+            }
+            return a.name.toLowerCase().localeCompare(b.name.toLowerCase());
+        });
+        return {
+            path: normalizedPath,
+            parent: normalizedPath === '/' ? null : path.dirname(normalizedPath),
+            mtime: stat.mtimeMs / 1000,
+            items,
+        };
+    }
+    /**
+     * Read a file's contents
+     */
+    readFile(filePath) {
+        const normalizedPath = this.normalizePath(filePath);
+        if (!fs.existsSync(normalizedPath)) {
+            throw new Error(`File not found: ${normalizedPath}`);
+        }
+        const stat = fs.statSync(normalizedPath);
+        if (stat.isDirectory()) {
+            throw new Error(`Path is a directory: ${normalizedPath}`);
+        }
+        const extension = path.extname(normalizedPath).toLowerCase();
+        if (extension === '.ipynb') {
+            const content = JSON.parse(fs.readFileSync(normalizedPath, 'utf-8'));
+            return {
+                path: normalizedPath,
+                type: 'notebook',
+                content,
+            };
+        }
+        // Try to read as text
+        try {
+            const content = fs.readFileSync(normalizedPath, 'utf-8');
+            return {
+                path: normalizedPath,
+                type: 'text',
+                content,
+            };
+        }
+        catch {
+            // Binary file
+            return {
+                path: normalizedPath,
+                type: 'binary',
+                content: null,
+                message: 'Binary file cannot be displayed',
+            };
+        }
+    }
+    /**
+     * Write content to a file
+     */
+    writeFile(filePath, content, fileType = 'text') {
+        const normalizedPath = this.normalizePath(filePath);
+        // Create parent directories if needed
+        const parentDir = path.dirname(normalizedPath);
+        if (parentDir && !fs.existsSync(parentDir)) {
+            fs.mkdirSync(parentDir, { recursive: true });
+        }
+        if (fileType === 'notebook') {
+            fs.writeFileSync(normalizedPath, JSON.stringify(content, null, 2), 'utf-8');
+        }
+        else {
+            fs.writeFileSync(normalizedPath, content, 'utf-8');
+        }
+        return true;
+    }
+    /**
+     * Create a new file or directory
+     */
+    createFile(filePath, isDirectory = false) {
+        const normalizedPath = this.normalizePath(filePath);
+        if (fs.existsSync(normalizedPath)) {
+            throw new Error(`Path already exists: ${normalizedPath}`);
+        }
+        if (isDirectory) {
+            fs.mkdirSync(normalizedPath, { recursive: true });
+        }
+        else {
+            // Create parent directories if needed
+            const parentDir = path.dirname(normalizedPath);
+            if (parentDir && !fs.existsSync(parentDir)) {
+                fs.mkdirSync(parentDir, { recursive: true });
+            }
+            const extension = path.extname(normalizedPath).toLowerCase();
+            if (extension === '.ipynb') {
+                // Create empty notebook
+                const notebook = {
+                    cells: [],
+                    metadata: {
+                        kernelspec: {
+                            display_name: 'Python 3',
+                            language: 'python',
+                            name: 'python3',
+                        },
+                    },
+                    nbformat: 4,
+                    nbformat_minor: 5,
+                };
+                this.writeJsonAtomicSync(normalizedPath, notebook);
+            }
+            else {
+                // Create empty file
+                fs.writeFileSync(normalizedPath, '', 'utf-8');
+            }
+        }
+        const info = this.getFileInfo(normalizedPath);
+        return { ...info, is_directory: info.isDirectory };
+    }
+    /**
+     * Get the history file path for a notebook
+     */
+    getHistoryPath(notebookPath) {
+        const { nebulaDir, nameWithoutExt } = this.getNebulaPaths(notebookPath);
+        return path.join(nebulaDir, `${nameWithoutExt}.history.json`);
+    }
+    /**
+     * Get the session state file path for a notebook
+     */
+    getSessionPath(notebookPath) {
+        const { nebulaDir, nameWithoutExt } = this.getNebulaPaths(notebookPath);
+        return path.join(nebulaDir, `${nameWithoutExt}.session.json`);
+    }
+    /**
+     * Get the journal file path for a notebook (used for crash-safe commits)
+     */
+    getJournalPath(notebookPath) {
+        const { nebulaDir, nameWithoutExt } = this.getNebulaPaths(notebookPath);
+        return path.join(nebulaDir, `${nameWithoutExt}.commit.json`);
+    }
+    readJournal(notebookPath) {
+        const journalPath = this.getJournalPath(notebookPath);
+        if (!fs.existsSync(journalPath))
+            return null;
+        try {
+            return JSON.parse(fs.readFileSync(journalPath, 'utf-8'));
+        }
+        catch {
+            return null;
+        }
+    }
+    hasPendingCommit(notebookPath) {
+        const journal = this.readJournal(notebookPath);
+        if (!journal)
+            return false;
+        return journal.status === 'begin';
+    }
+    getNebulaPaths(notebookPath) {
+        const normalizedPath = this.normalizePath(notebookPath);
+        const parentDir = path.dirname(normalizedPath);
+        const notebookName = path.basename(normalizedPath);
+        const nameWithoutExt = path.basename(notebookName, path.extname(notebookName));
+        const nebulaDir = path.join(parentDir, '.nebula');
+        return { nebulaDir, nameWithoutExt };
+    }
+    /**
+     * Delete notebook-related metadata files (history, session)
+     */
+    deleteNotebookMetadata(notebookPath) {
+        const historyPath = this.getHistoryPath(notebookPath);
+        const sessionPath = this.getSessionPath(notebookPath);
+        const journalPath = this.getJournalPath(notebookPath);
+        if (fs.existsSync(historyPath)) {
+            fs.unlinkSync(historyPath);
+        }
+        if (fs.existsSync(sessionPath)) {
+            fs.unlinkSync(sessionPath);
+        }
+        if (fs.existsSync(journalPath)) {
+            fs.unlinkSync(journalPath);
+        }
+    }
+    /**
+     * Delete a file or directory
+     */
+    deleteFile(filePath) {
+        const normalizedPath = this.normalizePath(filePath);
+        if (!fs.existsSync(normalizedPath)) {
+            throw new Error(`Path not found: ${normalizedPath}`);
+        }
+        // For notebooks, also delete history and session files
+        const ext = path.extname(normalizedPath).toLowerCase();
+        const stat = fs.statSync(normalizedPath);
+        if (ext === '.ipynb' && !stat.isDirectory()) {
+            this.deleteNotebookMetadata(normalizedPath);
+        }
+        if (stat.isDirectory()) {
+            fs.rmSync(normalizedPath, { recursive: true, force: true });
+        }
+        else {
+            fs.unlinkSync(normalizedPath);
+        }
+        return true;
+    }
+    /**
+     * Rename notebook-related metadata files
+     */
+    renameNotebookMetadata(oldPath, newPath) {
+        const oldHistory = this.getHistoryPath(oldPath);
+        const oldSession = this.getSessionPath(oldPath);
+        const oldJournal = this.getJournalPath(oldPath);
+        const newHistory = this.getHistoryPath(newPath);
+        const newSession = this.getSessionPath(newPath);
+        // Create destination .nebula directory if needed
+        const newNebulaDir = path.dirname(newHistory);
+        if (!fs.existsSync(newNebulaDir)) {
+            fs.mkdirSync(newNebulaDir, { recursive: true });
+        }
+        if (fs.existsSync(oldHistory)) {
+            fs.renameSync(oldHistory, newHistory);
+        }
+        if (fs.existsSync(oldSession)) {
+            fs.renameSync(oldSession, newSession);
+        }
+        if (fs.existsSync(oldJournal)) {
+            // Journal files are ephemeral; remove any stale commit record on rename
+            fs.unlinkSync(oldJournal);
+        }
+    }
+    /**
+     * Rename/move a file or directory
+     */
+    renameFile(oldPath, newPath) {
+        const normalizedOld = this.normalizePath(oldPath);
+        const normalizedNew = this.normalizePath(newPath);
+        if (!fs.existsSync(normalizedOld)) {
+            throw new Error(`Path not found: ${normalizedOld}`);
+        }
+        if (fs.existsSync(normalizedNew)) {
+            throw new Error(`Destination already exists: ${normalizedNew}`);
+        }
+        // For notebooks, also rename history and session files
+        const ext = path.extname(normalizedOld).toLowerCase();
+        if (ext === '.ipynb') {
+            this.renameNotebookMetadata(normalizedOld, normalizedNew);
+        }
+        fs.renameSync(normalizedOld, normalizedNew);
+        return this.getFileInfo(normalizedNew);
+    }
+    /**
+     * Duplicate notebook-related metadata files
+     */
+    duplicateNotebookMetadata(srcPath, destPath) {
+        const srcHistory = this.getHistoryPath(srcPath);
+        const destHistory = this.getHistoryPath(destPath);
+        const srcSession = this.getSessionPath(srcPath);
+        const destSession = this.getSessionPath(destPath);
+        // Create destination .nebula directory if needed
+        const destNebulaDir = path.dirname(destHistory);
+        if (!fs.existsSync(destNebulaDir)) {
+            fs.mkdirSync(destNebulaDir, { recursive: true });
+        }
+        if (fs.existsSync(srcHistory)) {
+            fs.copyFileSync(srcHistory, destHistory);
+        }
+        if (fs.existsSync(srcSession)) {
+            fs.copyFileSync(srcSession, destSession);
+        }
+    }
+    /**
+     * Recursively copy a directory
+     */
+    copyDirectoryRecursive(src, dest) {
+        fs.mkdirSync(dest, { recursive: true });
+        const entries = fs.readdirSync(src, { withFileTypes: true });
+        for (const entry of entries) {
+            const srcPath = path.join(src, entry.name);
+            const destPath = path.join(dest, entry.name);
+            if (entry.isDirectory()) {
+                this.copyDirectoryRecursive(srcPath, destPath);
+            }
+            else {
+                if (entry.name.endsWith('.commit.json')) {
+                    continue;
+                }
+                fs.copyFileSync(srcPath, destPath);
+                // For notebooks, also duplicate history and session files
+                if (entry.name.toLowerCase().endsWith('.ipynb')) {
+                    this.duplicateNotebookMetadata(srcPath, destPath);
+                }
+            }
+        }
+    }
+    /**
+     * Duplicate a file or directory with _copy suffix
+     */
+    duplicateFile(filePath) {
+        const normalizedPath = this.normalizePath(filePath);
+        if (!fs.existsSync(normalizedPath)) {
+            throw new Error(`File not found: ${normalizedPath}`);
+        }
+        const stat = fs.statSync(normalizedPath);
+        const isDirectory = stat.isDirectory();
+        const parentDir = path.dirname(normalizedPath);
+        const ext = isDirectory ? '' : path.extname(normalizedPath);
+        const name = path.basename(normalizedPath, ext);
+        // Find a unique name
+        let newName = `${name}_copy${ext}`;
+        let newPath = path.join(parentDir, newName);
+        let counter = 2;
+        while (fs.existsSync(newPath)) {
+            newName = `${name}_copy_${counter}${ext}`;
+            newPath = path.join(parentDir, newName);
+            counter++;
+        }
+        if (isDirectory) {
+            // Recursively copy directory
+            this.copyDirectoryRecursive(normalizedPath, newPath);
+        }
+        else {
+            // Copy the file
+            fs.copyFileSync(normalizedPath, newPath);
+            // For notebooks, also duplicate history and session files
+            if (ext.toLowerCase() === '.ipynb') {
+                this.duplicateNotebookMetadata(normalizedPath, newPath);
+            }
+        }
+        return this.toFileInfoResponse(this.getFileInfo(newPath));
+    }
+    /**
+     * Upload a file to a directory
+     */
+    async uploadFile(destDir, tempFilePath, originalName) {
+        const normalizedDir = this.normalizePath(destDir);
+        if (!fs.existsSync(normalizedDir)) {
+            throw new Error(`Directory not found: ${normalizedDir}`);
+        }
+        const stat = fs.statSync(normalizedDir);
+        if (!stat.isDirectory()) {
+            throw new Error(`Not a directory: ${normalizedDir}`);
+        }
+        // Determine final path
+        let finalPath = path.join(normalizedDir, originalName);
+        // If file exists, find unique name
+        if (fs.existsSync(finalPath)) {
+            const ext = path.extname(originalName);
+            const name = path.basename(originalName, ext);
+            let counter = 1;
+            while (fs.existsSync(finalPath)) {
+                finalPath = path.join(normalizedDir, `${name}_${counter}${ext}`);
+                counter++;
+            }
+        }
+        // Move temp file to final destination
+        fs.copyFileSync(tempFilePath, finalPath);
+        fs.unlinkSync(tempFilePath);
+        return this.toFileInfoResponse(this.getFileInfo(finalPath));
+    }
+    /**
+     * Convert Jupyter source to string
+     */
+    sourceToString(source) {
+        if (Array.isArray(source)) {
+            return source.join('');
+        }
+        return source;
+    }
+    /**
+     * Convert string to Jupyter source format (array of lines)
+     */
+    stringToSource(content) {
+        if (!content) {
+            return [];
+        }
+        const lines = content.split('\n');
+        // Add \n back to all lines except the last
+        return lines.map((line, i) => (i < lines.length - 1 ? line + '\n' : line));
+    }
+    /**
+     * Convert Jupyter outputs to Nebula format
+     */
+    convertOutputs(outputs, cellIndex) {
+        if (!outputs)
+            return [];
+        const result = [];
+        const timestamp = Date.now();
+        for (let i = 0; i < outputs.length; i++) {
+            const output = outputs[i];
+            if (output.output_type === 'stream') {
+                const streamName = output.name || 'stdout';
+                const text = this.sourceToString(output.text || '');
+                result.push({
+                    id: `output-${cellIndex}-${result.length}`,
+                    type: streamName === 'stderr' ? 'stderr' : 'stdout',
+                    content: text,
+                    timestamp,
+                });
+            }
+            else if (output.output_type === 'execute_result' || output.output_type === 'display_data') {
+                const normalizedOutput = (0, display_data_1.buildDisplayOutput)(output.data || {}, output.metadata);
+                if (normalizedOutput) {
+                    result.push({
+                        id: `output-${cellIndex}-${result.length}`,
+                        type: normalizedOutput.type,
+                        content: normalizedOutput.content,
+                        timestamp,
+                        mimeBundle: normalizedOutput.mimeBundle,
+                        metadata: normalizedOutput.metadata,
+                        preferredMimeType: normalizedOutput.preferredMimeType,
+                    });
+                }
+            }
+            else if (output.output_type === 'error') {
+                const traceback = output.traceback || [];
+                result.push({
+                    id: `output-${cellIndex}-${result.length}`,
+                    type: 'error',
+                    content: traceback.join(''),
+                    timestamp,
+                });
+            }
+        }
+        return result;
+    }
+    /**
+     * Convert Nebula outputs back to Jupyter format
+     */
+    convertOutputsToJupyter(outputs) {
+        const result = [];
+        for (const output of outputs) {
+            if (output.type !== 'stdout' && output.type !== 'stderr' && output.type !== 'error' && output.mimeBundle) {
+                result.push({
+                    output_type: 'display_data',
+                    data: (0, display_data_1.convertMimeBundleToJupyter)(output.mimeBundle),
+                    metadata: output.metadata || {},
+                });
+                continue;
+            }
+            if (output.type === 'stdout' || output.type === 'stderr') {
+                // Coalesce consecutive same-name streams into one entry (matches Jupyter behavior).
+                // This prevents tqdm progress bars from creating hundreds of output entries.
+                const prev = result[result.length - 1];
+                if (prev && prev.output_type === 'stream' && prev.name === output.type) {
+                    // Append text to existing stream entry
+                    const prevText = Array.isArray(prev.text) ? prev.text.join('') : prev.text;
+                    prev.text = this.stringToSource(prevText + output.content);
+                }
+                else {
+                    result.push({
+                        output_type: 'stream',
+                        name: output.type,
+                        text: this.stringToSource(output.content),
+                    });
+                }
+            }
+            else if (output.type === 'image') {
+                result.push({
+                    output_type: 'display_data',
+                    data: { 'image/png': output.content },
+                    metadata: output.metadata || {},
+                });
+            }
+            else if (output.type === 'html') {
+                result.push({
+                    output_type: 'display_data',
+                    data: { 'text/html': output.content },
+                    metadata: output.metadata || {},
+                });
+            }
+            else if (output.type === 'display_data') {
+                result.push({
+                    output_type: 'display_data',
+                    data: { 'text/plain': output.content },
+                    metadata: output.metadata || {},
+                });
+            }
+            else if (output.type === 'error') {
+                result.push({
+                    output_type: 'error',
+                    ename: 'Error',
+                    evalue: '',
+                    traceback: this.stringToSource(output.content),
+                });
+            }
+        }
+        return result;
+    }
+    /**
+     * Read a notebook and convert to internal cell format
+     */
+    getNotebookCells(notebookPath) {
+        const normalizedPath = this.normalizePath(notebookPath);
+        if (!fs.existsSync(normalizedPath)) {
+            throw new Error(`Notebook not found: ${normalizedPath}`);
+        }
+        const notebook = JSON.parse(fs.readFileSync(normalizedPath, 'utf-8'));
+        const metadataKernel = notebook.metadata?.kernelspec?.name;
+        const kernelspec = metadataKernel || 'python3';
+        const cells = notebook.cells.map((nbCell, i) => {
+            let cellType = nbCell.cell_type === 'markdown' ? 'markdown' : 'code';
+            const content = this.sourceToString(nbCell.source);
+            const cellId = nbCell.metadata?.nebula_id || nbCell.id || `cell-${i}`;
+            const outputs = this.convertOutputs(nbCell.outputs, i);
+            const cell = {
+                id: cellId,
+                type: cellType,
+                content,
+                outputs,
+                isExecuting: false,
+                executionCount: nbCell.execution_count ?? null,
+            };
+            // Preserve scrolled state if set
+            if (nbCell.metadata?.scrolled !== undefined) {
+                cell.scrolled = nbCell.metadata.scrolled;
+            }
+            if (nbCell.metadata?.scrolled_height !== undefined) {
+                cell.scrolledHeight = nbCell.metadata.scrolled_height;
+            }
+            // Preserve unknown metadata
+            const unknownMetadata = {};
+            for (const key of Object.keys(nbCell.metadata || {})) {
+                if (!['nebula_id', 'scrolled', 'scrolled_height'].includes(key)) {
+                    unknownMetadata[key] = nbCell.metadata[key];
+                }
+            }
+            if (Object.keys(unknownMetadata).length > 0) {
+                cell._metadata = unknownMetadata;
+            }
+            return cell;
+        });
+        const stat = fs.statSync(normalizedPath);
+        return {
+            cells,
+            metadata: notebook.metadata || {},
+            kernelspec,
+            kernelspecSource: metadataKernel ? 'metadata' : 'default',
+            mtime: stat.mtimeMs / 1000,
+        };
+    }
+    /**
+     * Read a notebook and convert to internal cell format, resolving default kernel if needed
+     */
+    async getNotebookCellsWithKernel(notebookPath) {
+        const result = this.getNotebookCells(notebookPath);
+        if (result.kernelspecSource === 'metadata') {
+            return result;
+        }
+        try {
+            const defaultKernel = await (0, default_kernel_1.getDefaultKernelName)();
+            if (defaultKernel) {
+                return {
+                    ...result,
+                    kernelspec: defaultKernel,
+                    kernelspecSource: 'env-default',
+                };
+            }
+        }
+        catch (err) {
+            console.warn('[FilesystemService] Failed to resolve default kernel:', err);
+        }
+        return result;
+    }
+    /**
+     * Save cells to a notebook file
+     */
+    saveNotebookCells(notebookPath, cells, kernelName, notebookMetadata) {
+        const normalizedPath = this.normalizePath(notebookPath);
+        // Load existing notebook metadata if file exists.
+        // Prefer a fast scan for the top-level metadata object so we avoid
+        // parsing the full notebook on every save. Fall back to full JSON
+        // parsing only for smaller notebooks when the fast path cannot find it.
+        let existingMetadata = {};
+        if (fs.existsSync(normalizedPath)) {
+            try {
+                const stat = fs.statSync(normalizedPath);
+                const fd = fs.openSync(normalizedPath, 'r');
+                const buf = Buffer.alloc(NOTEBOOK_METADATA_FAST_PATH_BYTES);
+                const bytesRead = fs.readSync(fd, buf, 0, NOTEBOOK_METADATA_FAST_PATH_BYTES, 0);
+                fs.closeSync(fd);
+                const head = buf.toString('utf-8', 0, bytesRead);
+                const extractedMetadata = extractTopLevelObjectField(head, 'metadata');
+                if (extractedMetadata) {
+                    existingMetadata = extractedMetadata;
+                }
+                else if (stat.size <= NOTEBOOK_METADATA_FALLBACK_PARSE_BYTES) {
+                    const notebook = JSON.parse(fs.readFileSync(normalizedPath, 'utf-8'));
+                    existingMetadata = notebook.metadata || {};
+                }
+            }
+            catch {
+                // Start fresh — metadata extraction failed
+            }
+        }
+        kernelName = kernelName || 'python3';
+        const displayName = kernelName === 'python3' ? 'Python 3' : kernelName.replace(/[-_]/g, ' ').replace(/\b\w/g, c => c.toUpperCase());
+        const nbCells = cells.map((cell) => {
+            const preservedMetadata = cell._metadata || {};
+            const cellMetadata = {
+                ...preservedMetadata,
+                nebula_id: cell.id,
+            };
+            if (cell.scrolled !== undefined) {
+                cellMetadata.scrolled = cell.scrolled;
+            }
+            if (cell.scrolledHeight !== undefined) {
+                cellMetadata.scrolled_height = cell.scrolledHeight;
+            }
+            const nbCell = {
+                cell_type: cell.type,
+                source: this.stringToSource(cell.content),
+                metadata: cellMetadata,
+            };
+            if (cell.type === 'code') {
+                nbCell.outputs = this.convertOutputsToJupyter(cell.outputs);
+                nbCell.execution_count = cell.executionCount;
+            }
+            return nbCell;
+        });
+        // Build final metadata
+        const finalMetadata = {
+            ...existingMetadata,
+            kernelspec: {
+                display_name: displayName,
+                language: 'python',
+                name: kernelName,
+            },
+            language_info: {
+                name: 'python',
+                version: '3.11',
+            },
+        };
+        // Merge custom notebook metadata
+        if (notebookMetadata) {
+            for (const [key, value] of Object.entries(notebookMetadata)) {
+                if (typeof value === 'object' && value !== null && typeof finalMetadata[key] === 'object' && finalMetadata[key] !== null) {
+                    // Deep merge for dict values
+                    finalMetadata[key] = { ...finalMetadata[key], ...value };
+                }
+                else {
+                    finalMetadata[key] = value;
+                }
+            }
+        }
+        const notebook = {
+            metadata: finalMetadata,
+            nbformat: 4,
+            nbformat_minor: 5,
+            cells: nbCells,
+        };
+        // Create parent directory if needed
+        const parentDir = path.dirname(normalizedPath);
+        if (!fs.existsSync(parentDir)) {
+            fs.mkdirSync(parentDir, { recursive: true });
+        }
+        this.writeJsonAtomicSync(normalizedPath, notebook);
+        const stat = fs.statSync(normalizedPath);
+        return {
+            success: true,
+            mtime: stat.mtimeMs / 1000,
+        };
+    }
+    /**
+     * Save notebook cells and history in a single crash-safe commit.
+     * Uses a small journal + atomic writes to avoid partial files.
+     */
+    async saveNotebookBundle(notebookPath, cells, kernelName, history, session, notebookMetadata) {
+        return await this.withWriteLock(notebookPath, async () => {
+            const normalizedPath = this.normalizePath(notebookPath);
+            const historyPath = history ? this.getHistoryPath(notebookPath) : undefined;
+            const sessionPath = session ? this.getSessionPath(notebookPath) : undefined;
+            const journalPath = this.getJournalPath(notebookPath);
+            const txId = crypto.randomUUID();
+            const journal = {
+                version: 1,
+                txId,
+                notebookPath: normalizedPath,
+                status: 'begin',
+                startedAt: Date.now(),
+                files: {
+                    notebook: normalizedPath,
+                    ...(historyPath ? { history: historyPath } : {}),
+                    ...(sessionPath ? { session: sessionPath } : {}),
+                },
+            };
+            // Ensure .nebula directory exists for journal/history/session
+            const { nebulaDir } = this.getNebulaPaths(notebookPath);
+            if (!fs.existsSync(nebulaDir)) {
+                fs.mkdirSync(nebulaDir, { recursive: true });
+            }
+            this.writeJsonAtomicSync(journalPath, journal);
+            if (historyPath) {
+                this.writeJsonAtomicSync(historyPath, history || []);
+            }
+            if (sessionPath) {
+                this.writeJsonAtomicSync(sessionPath, session || {});
+            }
+            const result = this.saveNotebookCells(notebookPath, cells, kernelName, notebookMetadata);
+            const committedJournal = {
+                ...journal,
+                status: 'commit',
+                committedAt: Date.now(),
+            };
+            this.writeJsonAtomicSync(journalPath, committedJournal);
+            try {
+                fs.unlinkSync(journalPath);
+            }
+            catch {
+                // Ignore cleanup errors; journal can be inspected if needed
+            }
+            return result;
+        });
+    }
+    /**
+     * Get notebook-level metadata
+     */
+    getNotebookMetadata(notebookPath) {
+        const normalizedPath = this.normalizePath(notebookPath);
+        if (!fs.existsSync(normalizedPath)) {
+            return {};
+        }
+        try {
+            const notebook = JSON.parse(fs.readFileSync(normalizedPath, 'utf-8'));
+            return notebook.metadata || {};
+        }
+        catch {
+            return {};
+        }
+    }
+    /**
+     * Update notebook-level metadata without modifying cells
+     */
+    async updateNotebookMetadata(notebookPath, metadataUpdates) {
+        return await this.withWriteLock(notebookPath, async () => {
+            const normalizedPath = this.normalizePath(notebookPath);
+            if (!fs.existsSync(normalizedPath)) {
+                return { success: false, error: `Notebook not found: ${normalizedPath}` };
+            }
+            try {
+                const notebook = JSON.parse(fs.readFileSync(normalizedPath, 'utf-8'));
+                const existingMetadata = notebook.metadata || {};
+                const nextMetadata = { ...existingMetadata };
+                for (const [key, value] of Object.entries(metadataUpdates)) {
+                    if (typeof value === 'object' && value !== null && typeof nextMetadata[key] === 'object' && nextMetadata[key] !== null) {
+                        nextMetadata[key] = {
+                            ...nextMetadata[key],
+                            ...value,
+                        };
+                    }
+                    else {
+                        nextMetadata[key] = value;
+                    }
+                }
+                if ((0, util_1.isDeepStrictEqual)(existingMetadata, nextMetadata)) {
+                    const stat = fs.statSync(normalizedPath);
+                    return {
+                        success: true,
+                        changed: false,
+                        mtime: stat.mtimeMs / 1000,
+                    };
+                }
+                notebook.metadata = nextMetadata;
+                this.writeJsonAtomicSync(normalizedPath, notebook);
+                const stat = fs.statSync(normalizedPath);
+                return {
+                    success: true,
+                    changed: true,
+                    mtime: stat.mtimeMs / 1000,
+                };
+            }
+            catch (e) {
+                return { success: false, error: `Failed to update notebook: ${e}` };
+            }
+        });
+    }
+    stripOutputsForHistorySnapshot(cell) {
+        const snapshot = {
+            ...cell,
+            outputs: [],
+            isExecuting: false,
+            pendingOutputReset: undefined,
+        };
+        return snapshot;
+    }
+    buildInitialHistory(notebookPath) {
+        const { cells } = this.getNotebookCells(notebookPath);
+        return [{
+                type: 'snapshot',
+                cells: cells.map(cell => this.stripOutputsForHistorySnapshot(cell)),
+                timestamp: Date.now(),
+            }];
+    }
+    /**
+     * Set agent permission and ensure newly-permitted notebooks are immediately editable.
+     */
+    async setAgentPermission(notebookPath, permitted) {
+        return await this.withWriteLock(notebookPath, async () => {
+            const normalizedPath = this.normalizePath(notebookPath);
+            if (!fs.existsSync(normalizedPath)) {
+                return { success: false, error: `Notebook not found: ${normalizedPath}` };
+            }
+            try {
+                const notebook = JSON.parse(fs.readFileSync(normalizedPath, 'utf-8'));
+                const metadata = notebook.metadata || {};
+                const nebula = (metadata.nebula || {});
+                notebook.metadata = {
+                    ...metadata,
+                    nebula: {
+                        ...nebula,
+                        agent_permitted: permitted,
+                    },
+                };
+                this.writeJsonAtomicSync(normalizedPath, notebook);
+                if (permitted && !this.hasHistory(notebookPath)) {
+                    const historyPath = this.getHistoryPath(notebookPath);
+                    const nebulaDir = path.dirname(historyPath);
+                    if (!fs.existsSync(nebulaDir)) {
+                        fs.mkdirSync(nebulaDir, { recursive: true });
+                    }
+                    this.writeJsonAtomicSync(historyPath, this.buildInitialHistory(notebookPath));
+                }
+                return {
+                    success: true,
+                    status: this.getAgentPermissionStatus(notebookPath),
+                };
+            }
+            catch (e) {
+                return { success: false, error: `Failed to set agent permission: ${e}` };
+            }
+        });
+    }
+    /**
+     * Derive agent permission status from persisted notebook metadata.
+     */
+    getAgentPermissionStatus(notebookPath) {
+        const metadata = this.getNotebookMetadata(notebookPath);
+        const nebula = (metadata.nebula || {});
+        const hasHistory = this.hasHistory(notebookPath);
+        const agentCreated = Boolean(nebula.agent_created);
+        const agentPermitted = Boolean(nebula.agent_permitted);
+        const canModify = agentCreated || (agentPermitted && hasHistory);
+        return {
+            agent_created: agentCreated,
+            agent_permitted: agentPermitted,
+            has_history: hasHistory,
+            can_agent_modify: canModify,
+            reason: agentCreated
+                ? 'Agent created this notebook'
+                : canModify
+                    ? 'User permitted and history enabled'
+                    : agentPermitted
+                        ? 'User permitted but history not enabled'
+                        : 'Not permitted for agent modifications',
+        };
+    }
+    /**
+     * Check if a notebook is permitted for agent modifications
+     */
+    isAgentPermitted(notebookPath) {
+        const status = this.getAgentPermissionStatus(notebookPath);
+        return status.agent_created || status.agent_permitted;
+    }
+    /**
+     * Check if a notebook has history tracking enabled
+     */
+    hasHistory(notebookPath) {
+        const historyPath = this.getHistoryPath(notebookPath);
+        if (!fs.existsSync(historyPath)) {
+            return false;
+        }
+        try {
+            const history = JSON.parse(fs.readFileSync(historyPath, 'utf-8'));
+            return Array.isArray(history) && history.length > 0;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Save operation history for a notebook
+     */
+    async saveHistory(notebookPath, history) {
+        const historyPath = this.getHistoryPath(notebookPath);
+        // Create .nebula directory if needed
+        const nebulaDir = path.dirname(historyPath);
+        if (!fs.existsSync(nebulaDir)) {
+            fs.mkdirSync(nebulaDir, { recursive: true });
+        }
+        await this.withWriteLock(notebookPath, async () => {
+            this.writeJsonAtomicSync(historyPath, history);
+        });
+        return true;
+    }
+    /**
+     * Load operation history for a notebook
+     */
+    loadHistory(notebookPath) {
+        const historyPath = this.getHistoryPath(notebookPath);
+        if (this.hasPendingCommit(notebookPath)) {
+            console.warn(`[FilesystemService] Pending commit detected for ${notebookPath}; skipping history load.`);
+            return [];
+        }
+        if (!fs.existsSync(historyPath)) {
+            return [];
+        }
+        try {
+            return JSON.parse(fs.readFileSync(historyPath, 'utf-8'));
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Save session state for a notebook
+     */
+    async saveSession(notebookPath, session) {
+        const sessionPath = this.getSessionPath(notebookPath);
+        // Create .nebula directory if needed
+        const nebulaDir = path.dirname(sessionPath);
+        if (!fs.existsSync(nebulaDir)) {
+            fs.mkdirSync(nebulaDir, { recursive: true });
+        }
+        await this.withWriteLock(notebookPath, async () => {
+            this.writeJsonAtomicSync(sessionPath, session);
+        });
+        return true;
+    }
+    /**
+     * Load session state for a notebook
+     */
+    loadSession(notebookPath) {
+        const sessionPath = this.getSessionPath(notebookPath);
+        if (this.hasPendingCommit(notebookPath)) {
+            console.warn(`[FilesystemService] Pending commit detected for ${notebookPath}; skipping session load.`);
+            return {};
+        }
+        if (!fs.existsSync(sessionPath)) {
+            return {};
+        }
+        try {
+            return JSON.parse(fs.readFileSync(sessionPath, 'utf-8'));
+        }
+        catch {
+            return {};
+        }
+    }
+}
+exports.FilesystemService = FilesystemService;
+// Global instance with default configuration
+exports.fsService = new FilesystemService();