nebula-notebook 0.1.0

package/node-server/dist/routes/cluster.js

@@ -0,0 +1,94 @@
+"use strict";
+/**
+ * Cluster Management API Routes
+ *
+ * Endpoints for server registration and cluster management.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = clusterRoutes;
+const server_registry_1 = require("../cluster/server-registry");
+const resource_service_1 = require("../resources/resource-service");
+const resourceService = (0, resource_service_1.getResourceService)();
+async function clusterRoutes(fastify) {
+    /**
+     * GET /servers
+     * List all servers in the cluster (local + registered peers)
+     * Includes resource info for all servers
+     */
+    fastify.get('/servers', async (_request, reply) => {
+        // Get local resources (cached, never blocks)
+        const localResources = resourceService.getResources();
+        const clusterInfo = server_registry_1.serverRegistry.getClusterInfo(localResources);
+        return reply.send(clusterInfo);
+    });
+    /**
+     * POST /servers/register
+     * Register a peer server with this server
+     * Body can include { resources } for initial resource info
+     */
+    fastify.post('/servers/register', async (request, reply) => {
+        const { host, port, name, secret, resources } = request.body;
+        if (!host || !port) {
+            return reply.code(400).send({ error: 'host and port are required' });
+        }
+        const result = server_registry_1.serverRegistry.register({ host, port, name, secret, resources });
+        if (!result.success) {
+            return reply.code(403).send({ error: result.error });
+        }
+        return reply.send({
+            registered: true,
+            serverId: result.serverId,
+        });
+    });
+    /**
+     * DELETE /servers/:serverId
+     * Unregister a peer server
+     */
+    fastify.delete('/servers/:serverId', async (request, reply) => {
+        const { serverId } = request.params;
+        const { secret } = request.body;
+        // Validate secret if configured
+        const clusterSecret = process.env.NEBULA_CLUSTER_SECRET;
+        if (clusterSecret && secret !== clusterSecret) {
+            return reply.code(403).send({ error: 'Invalid cluster secret' });
+        }
+        const removed = server_registry_1.serverRegistry.unregister(serverId);
+        if (!removed) {
+            return reply.code(404).send({ error: 'Server not found' });
+        }
+        return reply.send({ unregistered: true });
+    });
+    /**
+     * POST /servers/:serverId/heartbeat
+     * Record heartbeat from a peer server
+     * Body can include { resources } for system resource info
+     */
+    fastify.post('/servers/:serverId/heartbeat', async (request, reply) => {
+        const { serverId } = request.params;
+        const { resources } = request.body;
+        const success = server_registry_1.serverRegistry.heartbeat(serverId, resources);
+        if (!success) {
+            return reply.code(404).send({ error: 'Server not found' });
+        }
+        return reply.send({ ok: true });
+    });
+    /**
+     * GET /servers/:serverId
+     * Get info about a specific server
+     */
+    fastify.get('/servers/:serverId', async (request, reply) => {
+        const { serverId } = request.params;
+        const server = server_registry_1.serverRegistry.getServer(serverId);
+        if (!server) {
+            return reply.code(404).send({ error: 'Server not found' });
+        }
+        return reply.send({
+            id: server.id,
+            name: server.name,
+            url: server.url,
+            status: server.status,
+            registeredAt: server.registeredAt,
+            lastHeartbeat: server.lastHeartbeat,
+        });
+    });
+}

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

@@ -0,0 +1,7 @@
+/**
+ * Filesystem API Routes
+ */
+import { FastifyInstance } from 'fastify';
+import { fsService } from '../fs/fs-service';
+export default function fsRoutes(fastify: FastifyInstance): Promise<void>;
+export { fsService };

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

@@ -0,0 +1,392 @@
+"use strict";
+/**
+ * Filesystem API Routes
+ */
+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 = void 0;
+exports.default = fsRoutes;
+const fs_service_1 = require("../fs/fs-service");
+Object.defineProperty(exports, "fsService", { enumerable: true, get: function () { return fs_service_1.fsService; } });
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const nodeFs = __importStar(require("fs"));
+async function fsRoutes(fastify) {
+    /**
+     * List directory contents
+     */
+    fastify.get('/fs/list', async (request, reply) => {
+        try {
+            const dirPath = request.query.path || '~';
+            const result = fs_service_1.fsService.listDirectory(dirPath);
+            return reply.send(result);
+        }
+        catch (err) {
+            if (err instanceof Error) {
+                if (err.message.includes('not found') || err.message.includes('ENOENT')) {
+                    return reply.code(404).send({ detail: err.message });
+                }
+                else if (err.message.includes('permission') || err.message.includes('EACCES')) {
+                    return reply.code(403).send({ detail: err.message });
+                }
+                else {
+                    return reply.code(500).send({ detail: err.message });
+                }
+            }
+            else {
+                return reply.code(500).send({ detail: 'Unknown error' });
+            }
+        }
+    });
+    /**
+     * Get current server root directory
+     */
+    fastify.get('/fs/root', async (_request, reply) => {
+        return reply.send({ root: fs_service_1.fsService.getRootDirectory() });
+    });
+    /**
+     * Set server root directory
+     */
+    fastify.post('/fs/root', async (request, reply) => {
+        const { root } = request.body || {};
+        if (!root || typeof root !== 'string') {
+            return reply.code(400).send({ detail: 'root is required' });
+        }
+        try {
+            const updated = fs_service_1.fsService.setRootDirectory(root);
+            return reply.send({ root: updated });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : 'Failed to set root';
+            return reply.code(400).send({ detail: message });
+        }
+    });
+    /**
+     * Get directory modification time
+     */
+    fastify.get('/fs/mtime', async (request, reply) => {
+        try {
+            const dirPath = request.query.path || '~';
+            const result = fs_service_1.fsService.getDirectoryMtime(dirPath);
+            return reply.send(result);
+        }
+        catch (err) {
+            if (err instanceof Error && err.message.includes('not found')) {
+                return reply.code(404).send({ detail: err.message });
+            }
+            else {
+                const message = err instanceof Error ? err.message : 'Unknown error';
+                return reply.code(500).send({ detail: message });
+            }
+        }
+    });
+    /**
+     * Get file modification time
+     */
+    fastify.get('/fs/file-mtime', async (request, reply) => {
+        try {
+            const filePath = request.query.path;
+            if (!filePath) {
+                return reply.code(400).send({ detail: 'path query parameter is required' });
+            }
+            const result = fs_service_1.fsService.getFileMtime(filePath);
+            return reply.send(result);
+        }
+        catch (err) {
+            if (err instanceof Error && err.message.includes('not found')) {
+                return reply.code(404).send({ detail: err.message });
+            }
+            else {
+                const message = err instanceof Error ? err.message : 'Unknown error';
+                return reply.code(500).send({ detail: message });
+            }
+        }
+    });
+    /**
+     * Read file contents
+     */
+    fastify.get('/fs/read', async (request, reply) => {
+        try {
+            const filePath = request.query.path;
+            if (!filePath) {
+                return reply.code(400).send({ detail: 'path query parameter is required' });
+            }
+            const result = fs_service_1.fsService.readFile(filePath);
+            return reply.send(result);
+        }
+        catch (err) {
+            if (err instanceof Error) {
+                if (err.message.includes('not found') || err.message.includes('ENOENT')) {
+                    return reply.code(404).send({ detail: err.message });
+                }
+                else if (err.message.includes('directory') || err.message.includes('EISDIR')) {
+                    return reply.code(400).send({ detail: err.message });
+                }
+                else {
+                    return reply.code(500).send({ detail: err.message });
+                }
+            }
+            else {
+                return reply.code(500).send({ detail: 'Unknown error' });
+            }
+        }
+    });
+    /**
+     * Write content to a file
+     */
+    fastify.post('/fs/write', async (request, reply) => {
+        try {
+            const { path: filePath, content, file_type = 'text' } = request.body;
+            if (!filePath) {
+                return reply.code(400).send({ detail: 'path is required' });
+            }
+            fs_service_1.fsService.writeFile(filePath, content, file_type);
+            return reply.send({ status: 'ok', path: filePath });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : 'Unknown error';
+            return reply.code(500).send({ detail: message });
+        }
+    });
+    /**
+     * Create a new file or directory
+     */
+    fastify.post('/fs/create', async (request, reply) => {
+        try {
+            const { path: filePath, is_directory = false } = request.body;
+            if (!filePath) {
+                return reply.code(400).send({ detail: 'path is required' });
+            }
+            const info = fs_service_1.fsService.createFile(filePath, is_directory);
+            return reply.send({ status: 'ok', file: info });
+        }
+        catch (err) {
+            if (err instanceof Error && err.message.includes('exists')) {
+                return reply.code(409).send({ detail: err.message });
+            }
+            else {
+                const message = err instanceof Error ? err.message : 'Unknown error';
+                return reply.code(500).send({ detail: message });
+            }
+        }
+    });
+    /**
+     * Delete a file or directory
+     */
+    fastify.delete('/fs/delete', async (request, reply) => {
+        try {
+            const filePath = request.query.path;
+            if (!filePath) {
+                return reply.code(400).send({ detail: 'path query parameter is required' });
+            }
+            fs_service_1.fsService.deleteFile(filePath);
+            return reply.send({ status: 'ok' });
+        }
+        catch (err) {
+            if (err instanceof Error && err.message.includes('not found')) {
+                return reply.code(404).send({ detail: err.message });
+            }
+            else {
+                const message = err instanceof Error ? err.message : 'Unknown error';
+                return reply.code(500).send({ detail: message });
+            }
+        }
+    });
+    /**
+     * Rename/move a file or directory
+     */
+    fastify.post('/fs/rename', async (request, reply) => {
+        try {
+            const { old_path, new_path } = request.body;
+            if (!old_path || !new_path) {
+                return reply.code(400).send({ detail: 'old_path and new_path are required' });
+            }
+            const info = fs_service_1.fsService.renameFile(old_path, new_path);
+            return reply.send({ status: 'ok', file: info });
+        }
+        catch (err) {
+            if (err instanceof Error) {
+                if (err.message.includes('not found')) {
+                    return reply.code(404).send({ detail: err.message });
+                }
+                else if (err.message.includes('exists')) {
+                    return reply.code(409).send({ detail: err.message });
+                }
+                else {
+                    return reply.code(500).send({ detail: err.message });
+                }
+            }
+            else {
+                return reply.code(500).send({ detail: 'Unknown error' });
+            }
+        }
+    });
+    /**
+     * Duplicate a file or directory
+     */
+    fastify.post('/fs/duplicate', async (request, reply) => {
+        try {
+            const { path: filePath } = request.body;
+            if (!filePath) {
+                return reply.code(400).send({ detail: 'path is required' });
+            }
+            const info = fs_service_1.fsService.duplicateFile(filePath);
+            return reply.send({ status: 'ok', file: info });
+        }
+        catch (err) {
+            if (err instanceof Error) {
+                if (err.message.includes('not found')) {
+                    return reply.code(404).send({ detail: err.message });
+                }
+                else {
+                    return reply.code(500).send({ detail: err.message });
+                }
+            }
+            else {
+                return reply.code(500).send({ detail: 'Unknown error' });
+            }
+        }
+    });
+    /**
+     * Download a file (raw stream with proper headers)
+     */
+    fastify.get('/fs/download', async (request, reply) => {
+        try {
+            const filePath = request.query.path;
+            if (!filePath) {
+                return reply.code(400).send({ detail: 'path query parameter is required' });
+            }
+            const normalizedPath = fs_service_1.fsService.normalizePath(filePath);
+            if (!nodeFs.existsSync(normalizedPath)) {
+                return reply.code(404).send({ detail: `File not found: ${normalizedPath}` });
+            }
+            const stat = nodeFs.statSync(normalizedPath);
+            if (stat.isDirectory()) {
+                return reply.code(400).send({ detail: 'Cannot download a directory' });
+            }
+            const filename = path.basename(normalizedPath);
+            const extension = path.extname(normalizedPath).toLowerCase();
+            // Set content type based on extension
+            const mimeTypes = {
+                '.txt': 'text/plain',
+                '.json': 'application/json',
+                '.ipynb': 'application/json',
+                '.py': 'text/x-python',
+                '.js': 'application/javascript',
+                '.ts': 'application/typescript',
+                '.html': 'text/html',
+                '.css': 'text/css',
+                '.csv': 'text/csv',
+                '.md': 'text/markdown',
+                '.png': 'image/png',
+                '.jpg': 'image/jpeg',
+                '.jpeg': 'image/jpeg',
+                '.gif': 'image/gif',
+                '.svg': 'image/svg+xml',
+                '.pdf': 'application/pdf',
+                '.zip': 'application/zip',
+            };
+            const contentType = mimeTypes[extension] || 'application/octet-stream';
+            const stream = nodeFs.createReadStream(normalizedPath);
+            return reply
+                .header('Content-Type', contentType)
+                .header('Content-Disposition', `attachment; filename="${filename}"`)
+                .header('Content-Length', stat.size)
+                .send(stream);
+        }
+        catch (err) {
+            if (err instanceof Error) {
+                if (err.message.includes('not found') || err.message.includes('ENOENT')) {
+                    return reply.code(404).send({ detail: err.message });
+                }
+                else {
+                    return reply.code(500).send({ detail: err.message });
+                }
+            }
+            else {
+                return reply.code(500).send({ detail: 'Unknown error' });
+            }
+        }
+    });
+    /**
+     * Upload a file
+     * Uses @fastify/multipart (registered in index.ts)
+     */
+    fastify.post('/fs/upload', async (request, reply) => {
+        try {
+            const data = await request.file();
+            if (!data) {
+                return reply.code(400).send({ detail: 'file is required' });
+            }
+            // Read the dest path from the fields
+            const destPathField = data.fields.path;
+            const destPath = destPathField && 'value' in destPathField ? destPathField.value : undefined;
+            if (!destPath) {
+                return reply.code(400).send({ detail: 'path is required' });
+            }
+            // Save the uploaded file to a temp location first
+            const tmpPath = path.join(os.tmpdir(), `upload-${Date.now()}-${data.filename}`);
+            const writeStream = nodeFs.createWriteStream(tmpPath);
+            await new Promise((resolve, reject) => {
+                data.file.pipe(writeStream);
+                writeStream.on('finish', resolve);
+                writeStream.on('error', reject);
+            });
+            const info = await fs_service_1.fsService.uploadFile(destPath, tmpPath, data.filename);
+            // Clean up temp file
+            try {
+                nodeFs.unlinkSync(tmpPath);
+            }
+            catch { /* ignore */ }
+            return reply.send({ status: 'ok', file: info });
+        }
+        catch (err) {
+            if (err instanceof Error) {
+                if (err.message.includes('not found')) {
+                    return reply.code(404).send({ detail: err.message });
+                }
+                else if (err.message.includes('permission')) {
+                    return reply.code(403).send({ detail: err.message });
+                }
+                else {
+                    return reply.code(500).send({ detail: err.message });
+                }
+            }
+            else {
+                return reply.code(500).send({ detail: 'Unknown error' });
+            }
+        }
+    });
+}

package/node-server/dist/routes/kernel.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Kernel API Routes
+ */
+import { FastifyInstance } from 'fastify';
+import { WebSocketServer } from 'ws';
+import { KernelService } from '../kernel/kernel-service';
+declare const kernelService: KernelService;
+/**
+ * Setup WebSocket handler for kernel execution
+ */
+export declare function setupKernelWebSocket(wss: WebSocketServer): void;
+export default function kernelRoutes(fastify: FastifyInstance): Promise<void>;
+export { kernelService };