nebula-notebook 0.1.0

package/node-server/dist/discovery/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Python Discovery Service Module
+ */
+export * from './types';
+export * from './discovery-service';

package/node-server/dist/discovery/index.js

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * Python Discovery Service Module
+ */
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./discovery-service"), exports);

package/node-server/dist/discovery/types.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Python Discovery Service Types
+ */
+export type PythonEnvType = 'system' | 'conda' | 'pyenv' | 'venv' | 'homebrew' | 'uv' | 'pixi';
+export interface PythonEnvironment {
+    path: string;
+    version: string;
+    displayName: string;
+    envType: PythonEnvType;
+    envName: string | null;
+    hasIpykernel: boolean;
+    kernelName: string | null;
+    externallyManaged: boolean;
+    installHint: string | null;
+}
+export interface DiscoveryCandidate {
+    path: string;
+    envType: PythonEnvType;
+    envName: string | null;
+    base?: string;
+}
+export interface CacheData {
+    environments: Record<string, PythonEnvironment>;
+    timestamp: number;
+}
+export interface InstallKernelResult {
+    kernelName: string;
+    pythonPath: string;
+    message: string;
+}
+export type KernelProvisionErrorCode = 'python_not_found' | 'externally_managed' | 'needs_ipykernel' | 'install_failed' | 'register_failed';
+export declare class KernelProvisionError extends Error {
+    code: KernelProvisionErrorCode;
+    installHint?: string;
+    constructor(message: string, code: KernelProvisionErrorCode, installHint?: string);
+}
+export interface CacheInfo {
+    cachedCount: number;
+    cacheAgeHours: number | null;
+    cacheValid: boolean;
+    cacheFile: string;
+}
+export declare const DEFAULT_CACHE_TTL_HOURS = 24;
+export declare const DEFAULT_VERSION_CHECK_TIMEOUT_MS = 5000;
+export declare const DEFAULT_IPYKERNEL_CHECK_TIMEOUT_MS = 10000;
+export declare const DEFAULT_CONDA_LIST_TIMEOUT_MS = 30000;
+export declare const DEFAULT_KERNEL_INSTALL_TIMEOUT_MS = 120000;
+export declare const DEFAULT_REGISTRATION_TIMEOUT_MS = 60000;

package/node-server/dist/discovery/types.js

@@ -0,0 +1,24 @@
+"use strict";
+/**
+ * Python Discovery Service Types
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_REGISTRATION_TIMEOUT_MS = exports.DEFAULT_KERNEL_INSTALL_TIMEOUT_MS = exports.DEFAULT_CONDA_LIST_TIMEOUT_MS = exports.DEFAULT_IPYKERNEL_CHECK_TIMEOUT_MS = exports.DEFAULT_VERSION_CHECK_TIMEOUT_MS = exports.DEFAULT_CACHE_TTL_HOURS = exports.KernelProvisionError = void 0;
+class KernelProvisionError extends Error {
+    code;
+    installHint;
+    constructor(message, code, installHint) {
+        super(message);
+        this.name = 'KernelProvisionError';
+        this.code = code;
+        this.installHint = installHint;
+    }
+}
+exports.KernelProvisionError = KernelProvisionError;
+// Configuration defaults
+exports.DEFAULT_CACHE_TTL_HOURS = 24;
+exports.DEFAULT_VERSION_CHECK_TIMEOUT_MS = 5000;
+exports.DEFAULT_IPYKERNEL_CHECK_TIMEOUT_MS = 10000;
+exports.DEFAULT_CONDA_LIST_TIMEOUT_MS = 30000;
+exports.DEFAULT_KERNEL_INSTALL_TIMEOUT_MS = 120000;
+exports.DEFAULT_REGISTRATION_TIMEOUT_MS = 60000;

package/node-server/dist/fs/fs-service.d.ts

@@ -0,0 +1,218 @@
+/**
+ * Filesystem Service - Real filesystem operations
+ *
+ * Node.js port of the Python FilesystemService.
+ */
+import { FileInfo, FileInfoResponse, FileType, DirectoryListing, MtimeResponse, ReadFileResponse, NebulaCell, NotebookCellsResponse, SaveNotebookResult } from './types';
+export interface AgentPermissionSnapshot {
+    agent_created: boolean;
+    agent_permitted: boolean;
+    has_history: boolean;
+    can_agent_modify: boolean;
+    reason: string;
+}
+export declare class FilesystemService {
+    private writeLocks;
+    private defaultRoot;
+    constructor(defaultRoot?: string);
+    /**
+     * Get the server root directory.
+     */
+    getRootDirectory(): string;
+    /**
+     * Set the server root directory and persist it.
+     */
+    setRootDirectory(rootDirectory: string, options?: {
+        persist?: boolean;
+    }): string;
+    private expandRootDirectory;
+    private saveRootDirectory;
+    /**
+     * Normalize and expand path
+     */
+    normalizePath(filePath: string): string;
+    /**
+     * Serialize write operations per notebook to avoid interleaving writes.
+     */
+    private withWriteLock;
+    /**
+     * Atomically write a file (write temp, fsync, rename, fsync dir).
+     * Prevents partial/corrupt files on interruption.
+     */
+    private atomicWriteFileSync;
+    private writeJsonAtomicSync;
+    /**
+     * Format file size for display
+     */
+    formatSize(size: number): string;
+    /**
+     * Determine file type from extension
+     */
+    getFileType(extension: string): FileType;
+    /**
+     * Get file info for a path
+     */
+    private getFileInfo;
+    /**
+     * Convert FileInfo to FileInfoResponse for API
+     */
+    private toFileInfoResponse;
+    /**
+     * Get directory modification time (lightweight check for changes)
+     */
+    getDirectoryMtime(dirPath: string): MtimeResponse;
+    /**
+     * Get file modification time
+     */
+    getFileMtime(filePath: string): MtimeResponse;
+    /**
+     * List contents of a directory
+     */
+    listDirectory(dirPath: string): DirectoryListing;
+    /**
+     * Read a file's contents
+     */
+    readFile(filePath: string): ReadFileResponse;
+    /**
+     * Write content to a file
+     */
+    writeFile(filePath: string, content: unknown, fileType?: 'text' | 'notebook'): boolean;
+    /**
+     * Create a new file or directory
+     */
+    createFile(filePath: string, isDirectory?: boolean): FileInfo & {
+        is_directory: boolean;
+    };
+    /**
+     * Get the history file path for a notebook
+     */
+    private getHistoryPath;
+    /**
+     * Get the session state file path for a notebook
+     */
+    private getSessionPath;
+    /**
+     * Get the journal file path for a notebook (used for crash-safe commits)
+     */
+    private getJournalPath;
+    private readJournal;
+    private hasPendingCommit;
+    private getNebulaPaths;
+    /**
+     * Delete notebook-related metadata files (history, session)
+     */
+    private deleteNotebookMetadata;
+    /**
+     * Delete a file or directory
+     */
+    deleteFile(filePath: string): boolean;
+    /**
+     * Rename notebook-related metadata files
+     */
+    private renameNotebookMetadata;
+    /**
+     * Rename/move a file or directory
+     */
+    renameFile(oldPath: string, newPath: string): FileInfo;
+    /**
+     * Duplicate notebook-related metadata files
+     */
+    private duplicateNotebookMetadata;
+    /**
+     * Recursively copy a directory
+     */
+    private copyDirectoryRecursive;
+    /**
+     * Duplicate a file or directory with _copy suffix
+     */
+    duplicateFile(filePath: string): FileInfoResponse;
+    /**
+     * Upload a file to a directory
+     */
+    uploadFile(destDir: string, tempFilePath: string, originalName: string): Promise<FileInfoResponse>;
+    /**
+     * Convert Jupyter source to string
+     */
+    private sourceToString;
+    /**
+     * Convert string to Jupyter source format (array of lines)
+     */
+    private stringToSource;
+    /**
+     * Convert Jupyter outputs to Nebula format
+     */
+    private convertOutputs;
+    /**
+     * Convert Nebula outputs back to Jupyter format
+     */
+    private convertOutputsToJupyter;
+    /**
+     * Read a notebook and convert to internal cell format
+     */
+    getNotebookCells(notebookPath: string): NotebookCellsResponse;
+    /**
+     * Read a notebook and convert to internal cell format, resolving default kernel if needed
+     */
+    getNotebookCellsWithKernel(notebookPath: string): Promise<NotebookCellsResponse>;
+    /**
+     * Save cells to a notebook file
+     */
+    saveNotebookCells(notebookPath: string, cells: NebulaCell[], kernelName?: string, notebookMetadata?: Record<string, unknown>): SaveNotebookResult;
+    /**
+     * Save notebook cells and history in a single crash-safe commit.
+     * Uses a small journal + atomic writes to avoid partial files.
+     */
+    saveNotebookBundle(notebookPath: string, cells: NebulaCell[], kernelName?: string, history?: unknown[], session?: Record<string, unknown>, notebookMetadata?: Record<string, unknown>): Promise<SaveNotebookResult>;
+    /**
+     * Get notebook-level metadata
+     */
+    getNotebookMetadata(notebookPath: string): Record<string, unknown>;
+    /**
+     * Update notebook-level metadata without modifying cells
+     */
+    updateNotebookMetadata(notebookPath: string, metadataUpdates: Record<string, unknown>): Promise<{
+        success: boolean;
+        changed?: boolean;
+        mtime?: number;
+        error?: string;
+    }>;
+    private stripOutputsForHistorySnapshot;
+    private buildInitialHistory;
+    /**
+     * Set agent permission and ensure newly-permitted notebooks are immediately editable.
+     */
+    setAgentPermission(notebookPath: string, permitted: boolean): Promise<{
+        success: boolean;
+        error?: string;
+        status?: AgentPermissionSnapshot;
+    }>;
+    /**
+     * Derive agent permission status from persisted notebook metadata.
+     */
+    getAgentPermissionStatus(notebookPath: string): AgentPermissionSnapshot;
+    /**
+     * Check if a notebook is permitted for agent modifications
+     */
+    isAgentPermitted(notebookPath: string): boolean;
+    /**
+     * Check if a notebook has history tracking enabled
+     */
+    hasHistory(notebookPath: string): boolean;
+    /**
+     * Save operation history for a notebook
+     */
+    saveHistory(notebookPath: string, history: unknown[]): Promise<boolean>;
+    /**
+     * Load operation history for a notebook
+     */
+    loadHistory(notebookPath: string): unknown[];
+    /**
+     * Save session state for a notebook
+     */
+    saveSession(notebookPath: string, session: Record<string, unknown>): Promise<boolean>;
+    /**
+     * Load session state for a notebook
+     */
+    loadSession(notebookPath: string): Record<string, unknown>;
+}
+export declare const fsService: FilesystemService;