nebula-notebook 0.1.0

package/node-server/dist/output/display-data.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripAutoplayFromHtml = stripAutoplayFromHtml;
+exports.normalizeMimeValue = normalizeMimeValue;
+exports.normalizeMimeBundle = normalizeMimeBundle;
+exports.pickPreferredMimeType = pickPreferredMimeType;
+exports.buildDisplayOutput = buildDisplayOutput;
+exports.convertMimeBundleToJupyter = convertMimeBundleToJupyter;
+const PREFERRED_MIME_TYPES = [
+    'application/vnd.nebula.web+json',
+    'application/vnd.plotly.v1+json',
+    'text/html',
+    'image/png',
+    'text/plain',
+];
+function stripAutoplayFromHtml(html) {
+    if (!html.includes('autoplay'))
+        return html;
+    return html.replace(/(<(?:audio|video)\b[^>]*?)\s+autoplay(?:=["'][^"']*["'])?/gi, '$1');
+}
+function isJsonValue(value, depth = 0) {
+    if (value === null ||
+        typeof value === 'string' ||
+        typeof value === 'number' ||
+        typeof value === 'boolean') {
+        return true;
+    }
+    // Assume deeply-nested structures are valid rather than risk a stack overflow.
+    // Plotly figures can nest 10+ levels deep in their default templates.
+    if (depth > 64) {
+        return typeof value === 'object';
+    }
+    if (Array.isArray(value)) {
+        return value.every((v) => isJsonValue(v, depth + 1));
+    }
+    if (typeof value === 'object') {
+        return Object.values(value).every((v) => isJsonValue(v, depth + 1));
+    }
+    return false;
+}
+function normalizeMimeValue(mimeType, value) {
+    let normalized = value;
+    if (Array.isArray(normalized) && normalized.every((item) => typeof item === 'string')) {
+        normalized = normalized.join('');
+    }
+    if (mimeType === 'text/html' && typeof normalized === 'string') {
+        normalized = stripAutoplayFromHtml(normalized);
+    }
+    // JSON-based MIME types (plotly, nebula-web, etc.) arrive from JSON.parse
+    // and are inherently valid JSON values. Skip the expensive recursive check
+    // which can stack-overflow on deeply-nested Plotly templates.
+    if (mimeType.endsWith('+json') && typeof normalized === 'object' && normalized !== null) {
+        return normalized;
+    }
+    return isJsonValue(normalized) ? normalized : null;
+}
+function normalizeMimeBundle(data) {
+    const bundle = {};
+    for (const [mimeType, value] of Object.entries(data)) {
+        const normalized = normalizeMimeValue(mimeType, value);
+        if (normalized !== null) {
+            bundle[mimeType] = normalized;
+        }
+        else if (value !== undefined) {
+            console.warn(`[display-data] Dropped MIME type "${mimeType}": normalizeMimeValue returned null (value type: ${typeof value}, isArray: ${Array.isArray(value)})`);
+        }
+    }
+    return bundle;
+}
+function pickPreferredMimeType(bundle) {
+    for (const mimeType of PREFERRED_MIME_TYPES) {
+        if (mimeType in bundle)
+            return mimeType;
+    }
+    const [firstMimeType] = Object.keys(bundle);
+    return firstMimeType ?? null;
+}
+function stringifyMimeValue(value) {
+    if (typeof value === 'string')
+        return value;
+    return JSON.stringify(value, null, 2);
+}
+function classifyOutputType(bundle, preferredMimeType) {
+    const mimeTypes = Object.keys(bundle);
+    if (preferredMimeType === 'image/png' &&
+        mimeTypes.every((mimeType) => mimeType === 'image/png' || mimeType === 'text/plain')) {
+        return 'image';
+    }
+    if (preferredMimeType === 'text/html' &&
+        mimeTypes.every((mimeType) => mimeType === 'text/html' || mimeType === 'text/plain')) {
+        return 'html';
+    }
+    if (preferredMimeType === 'text/plain' && mimeTypes.length === 1) {
+        return 'stdout';
+    }
+    return 'display_data';
+}
+function getDisplayContent(bundle, preferredMimeType, outputType) {
+    // For image and html types the content field IS the rendered data (base64 / markup),
+    // so we must return the preferred MIME value, not the text/plain fallback.
+    // For display_data / stdout the text/plain fallback is more useful (shown as error
+    // fallback text in plotly/nebula-web renderers).
+    if (outputType === 'image' || outputType === 'html') {
+        const preferredValue = bundle[preferredMimeType];
+        return preferredValue === undefined ? '' : stringifyMimeValue(preferredValue);
+    }
+    const fallbackText = bundle['text/plain'];
+    if (preferredMimeType !== 'text/plain' && fallbackText !== undefined) {
+        return stringifyMimeValue(fallbackText);
+    }
+    const preferredValue = bundle[preferredMimeType];
+    return preferredValue === undefined ? '' : stringifyMimeValue(preferredValue);
+}
+function buildDisplayOutput(data, metadata) {
+    const mimeBundle = normalizeMimeBundle(data);
+    const preferredMimeType = pickPreferredMimeType(mimeBundle);
+    if (!preferredMimeType) {
+        return null;
+    }
+    const normalizedMetadata = metadata && isJsonValue(metadata)
+        ? metadata
+        : undefined;
+    const type = classifyOutputType(mimeBundle, preferredMimeType);
+    return {
+        type,
+        content: getDisplayContent(mimeBundle, preferredMimeType, type),
+        mimeBundle,
+        metadata: normalizedMetadata,
+        preferredMimeType,
+    };
+}
+function convertMimeBundleToJupyter(bundle) {
+    return { ...bundle };
+}

package/node-server/dist/resources/resource-service.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Resource Service
+ *
+ * Collects system resources (RAM, GPU) with defensive timeouts.
+ * Resource collection is OPTIONAL and must NEVER block core functionality.
+ */
+export interface GPUDevice {
+    index: number;
+    name: string;
+    memoryUsed: number;
+    memoryTotal: number;
+    utilization?: number;
+    temperature?: number;
+}
+export interface GPUInfo {
+    vendor: 'nvidia' | 'amd';
+    devices: GPUDevice[];
+    totalUsed: number;
+    totalMemory: number;
+}
+export interface RAMInfo {
+    used: number;
+    total: number;
+    percent: number;
+}
+export interface ServerResources {
+    hostname: string;
+    ram: RAMInfo;
+    gpus: GPUInfo | null;
+    gpuError?: 'timeout' | 'not_found' | 'parse_error' | 'command_failed';
+    collectedAt: number;
+}
+/**
+ * Resource Service - Singleton
+ *
+ * Provides cached, non-blocking access to system resources.
+ */
+declare class ResourceService {
+    private cache;
+    private cacheTime;
+    private collecting;
+    private hostname;
+    private hasLoggedOnce;
+    constructor();
+    /**
+     * Get resources - NEVER blocks, returns cached or empty
+     * Triggers async collection if cache is stale
+     */
+    getResources(): ServerResources;
+    /**
+     * Force refresh - waits for collection but still has timeout protection
+     * Use sparingly (e.g., on explicit user request)
+     */
+    refreshResources(): Promise<ServerResources>;
+    /**
+     * Check if cached data is stale
+     */
+    isStale(): boolean;
+    /**
+     * Get empty resources (fallback)
+     */
+    private getEmptyResources;
+    /**
+     * Async collection - runs in background, updates cache
+     */
+    private collectAsync;
+}
+export declare function getResourceService(): ResourceService;
+export { ResourceService };

package/node-server/dist/resources/resource-service.js

@@ -0,0 +1,363 @@
+"use strict";
+/**
+ * Resource Service
+ *
+ * Collects system resources (RAM, GPU) with defensive timeouts.
+ * Resource collection is OPTIONAL and must NEVER block core functionality.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceService = void 0;
+exports.getResourceService = getResourceService;
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const os_1 = __importDefault(require("os"));
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+// Constants
+const GPU_COMMAND_TIMEOUT_MS = 3000; // 3 seconds - kill if hung
+const CACHE_TTL_MS = 30000; // 30 seconds cache
+const STALE_THRESHOLD_MS = 60000; // 60 seconds before marking stale
+/**
+ * Execute command with strict timeout
+ * Returns null on any failure - never throws
+ * Silent on command-not-found errors (expected on systems without GPU tools)
+ */
+async function execWithTimeout(cmd, timeoutMs = GPU_COMMAND_TIMEOUT_MS) {
+    try {
+        const { stdout, stderr } = await execAsync(cmd, {
+            timeout: timeoutMs,
+            killSignal: 'SIGKILL',
+            maxBuffer: 1024 * 1024, // 1MB buffer
+        });
+        return { stdout: stdout.trim(), error: stderr?.trim() };
+    }
+    catch (err) {
+        if (err.killed) {
+            // Only log actual timeouts - these are important
+            console.warn(`[ResourceService] Command timed out after ${timeoutMs}ms: ${cmd.split(' ')[0]}`);
+        }
+        // Don't log command-not-found or other errors - expected on systems without GPU tools
+        return null;
+    }
+}
+/**
+ * Collect RAM info using Node.js os module (always available, instant)
+ */
+function collectRAM() {
+    const total = os_1.default.totalmem();
+    const free = os_1.default.freemem();
+    const used = total - free;
+    return {
+        used: Math.round((used / (1024 ** 3)) * 100) / 100, // GB, 2 decimals
+        total: Math.round((total / (1024 ** 3)) * 100) / 100, // GB, 2 decimals
+        percent: Math.round((used / total) * 100),
+    };
+}
+/**
+ * Parse nvidia-smi CSV output
+ */
+function parseNvidiaSmi(stdout) {
+    try {
+        const lines = stdout.trim().split('\n').filter(line => line.trim());
+        if (lines.length === 0)
+            return null;
+        const devices = [];
+        let totalUsed = 0;
+        let totalMemory = 0;
+        for (const line of lines) {
+            // Format: index, name, memory.used [MiB], memory.total [MiB], utilization.gpu [%], temperature.gpu
+            const parts = line.split(',').map(s => s.trim());
+            if (parts.length < 4)
+                continue;
+            const index = parseInt(parts[0], 10);
+            const name = parts[1];
+            const memUsedMB = parseInt(parts[2], 10);
+            const memTotalMB = parseInt(parts[3], 10);
+            const utilization = parts[4] ? parseInt(parts[4], 10) : undefined;
+            const temperature = parts[5] ? parseInt(parts[5], 10) : undefined;
+            if (isNaN(index) || isNaN(memUsedMB) || isNaN(memTotalMB))
+                continue;
+            const memUsedGB = Math.round((memUsedMB / 1024) * 100) / 100;
+            const memTotalGB = Math.round((memTotalMB / 1024) * 100) / 100;
+            devices.push({
+                index,
+                name,
+                memoryUsed: memUsedGB,
+                memoryTotal: memTotalGB,
+                utilization: isNaN(utilization) ? undefined : utilization,
+                temperature: isNaN(temperature) ? undefined : temperature,
+            });
+            totalUsed += memUsedGB;
+            totalMemory += memTotalGB;
+        }
+        if (devices.length === 0)
+            return null;
+        return {
+            vendor: 'nvidia',
+            devices,
+            totalUsed: Math.round(totalUsed * 100) / 100,
+            totalMemory: Math.round(totalMemory * 100) / 100,
+        };
+    }
+    catch (err) {
+        console.warn('[ResourceService] Failed to parse nvidia-smi output:', err);
+        return null;
+    }
+}
+/**
+ * Parse rocm-smi output for AMD GPUs
+ * Handles multiple output formats across rocm-smi versions
+ */
+function parseRocmSmi(stdout) {
+    try {
+        const devices = [];
+        const deviceMap = new Map();
+        const lines = stdout.trim().split('\n');
+        for (const line of lines) {
+            // Format 1: GPU[0] : vram Total Memory (B): 17163091968
+            const gpuBracketMatch = line.match(/GPU\[(\d+)\]/);
+            if (gpuBracketMatch) {
+                const index = parseInt(gpuBracketMatch[1], 10);
+                if (!deviceMap.has(index)) {
+                    deviceMap.set(index, { index, name: `AMD GPU ${index}` });
+                }
+                const device = deviceMap.get(index);
+                // Match memory values (in bytes) - handles "Total Memory" and "Used Memory"
+                if (line.includes('Total Memory') && !line.includes('Used')) {
+                    const match = line.match(/:\s*(\d+)\s*$/);
+                    if (match) {
+                        device.memoryTotal = Math.round((parseInt(match[1], 10) / (1024 ** 3)) * 100) / 100;
+                    }
+                }
+                else if (line.includes('Used Memory') || line.includes('Total Used')) {
+                    const match = line.match(/:\s*(\d+)\s*$/);
+                    if (match) {
+                        device.memoryUsed = Math.round((parseInt(match[1], 10) / (1024 ** 3)) * 100) / 100;
+                    }
+                }
+                continue;
+            }
+            // Format 2: Table format with GPU index in first column
+            // GPU  Temp   AvgPwr  SCLK    MCLK     Fan  Perf  PwrCap  VRAM%  GPU%
+            // 0    45c    35.0W   300Mhz  1200Mhz  0%   auto  250.0W  5%     0%
+            const tableMatch = line.match(/^(\d+)\s+\d+c/);
+            if (tableMatch) {
+                const index = parseInt(tableMatch[1], 10);
+                if (!deviceMap.has(index)) {
+                    deviceMap.set(index, { index, name: `AMD GPU ${index}` });
+                }
+                // Extract VRAM% if present
+                const vramMatch = line.match(/(\d+)%\s+\d+%\s*$/);
+                if (vramMatch) {
+                    const device = deviceMap.get(index);
+                    // We only get percentage, not absolute values in this format
+                    device.utilization = parseInt(vramMatch[1], 10);
+                }
+            }
+        }
+        let totalUsed = 0;
+        let totalMemory = 0;
+        for (const [, device] of deviceMap) {
+            // Accept device if we have both memory values, or at least an index
+            if (device.memoryUsed !== undefined && device.memoryTotal !== undefined) {
+                devices.push(device);
+                totalUsed += device.memoryUsed;
+                totalMemory += device.memoryTotal;
+            }
+        }
+        if (devices.length === 0)
+            return null;
+        return {
+            vendor: 'amd',
+            devices: devices.sort((a, b) => a.index - b.index),
+            totalUsed: Math.round(totalUsed * 100) / 100,
+            totalMemory: Math.round(totalMemory * 100) / 100,
+        };
+    }
+    catch {
+        // Silent failure - parsing errors are not critical
+        return null;
+    }
+}
+/**
+ * Parse rocm-smi --showproductname output to get GPU names
+ * Updates devices array in place
+ * Format: GPU[0]          : Card Series:          AMD Instinct MI300X
+ */
+function parseRocmSmiNames(stdout, devices) {
+    try {
+        const lines = stdout.trim().split('\n');
+        for (const line of lines) {
+            // Match "GPU[X] : Card Series: <name>" with flexible whitespace
+            const match = line.match(/GPU\[(\d+)\]\s*:\s*Card\s+Series\s*:\s*(.+)/i);
+            if (match) {
+                const index = parseInt(match[1], 10);
+                const name = match[2].trim();
+                // Find device and update name
+                const device = devices.find(d => d.index === index);
+                if (device && name) {
+                    device.name = name;
+                }
+            }
+        }
+    }
+    catch {
+        // Silent - names are optional
+    }
+}
+// Cache for AMD GPU names (they don't change)
+let amdGpuNamesCache = null;
+/**
+ * Collect GPU info - tries nvidia-smi first, then rocm-smi
+ * Returns null if no GPU or collection fails
+ * Only reports errors for actual problems (timeouts), not for missing tools
+ */
+async function collectGPUs() {
+    // Try NVIDIA first (more common)
+    const nvidiaCmd = 'nvidia-smi --query-gpu=index,name,memory.used,memory.total,utilization.gpu,temperature.gpu --format=csv,nounits,noheader';
+    const nvidiaResult = await execWithTimeout(nvidiaCmd);
+    if (nvidiaResult?.stdout) {
+        const gpus = parseNvidiaSmi(nvidiaResult.stdout);
+        if (gpus)
+            return { gpus };
+        // Output exists but couldn't parse - continue to try rocm-smi
+    }
+    // Try AMD ROCm - get memory info
+    const rocmMemResult = await execWithTimeout('rocm-smi --showmeminfo vram');
+    if (rocmMemResult?.stdout) {
+        const gpus = parseRocmSmi(rocmMemResult.stdout);
+        if (gpus) {
+            // Get GPU names from cache or fetch once
+            if (!amdGpuNamesCache) {
+                const rocmNameResult = await execWithTimeout('rocm-smi --showproductname');
+                if (rocmNameResult?.stdout) {
+                    amdGpuNamesCache = new Map();
+                    parseRocmSmiNames(rocmNameResult.stdout, gpus.devices);
+                    // Cache the names
+                    for (const device of gpus.devices) {
+                        amdGpuNamesCache.set(device.index, device.name);
+                    }
+                }
+            }
+            else {
+                // Use cached names
+                for (const device of gpus.devices) {
+                    const cachedName = amdGpuNamesCache.get(device.index);
+                    if (cachedName) {
+                        device.name = cachedName;
+                    }
+                }
+            }
+            return { gpus };
+        }
+        // Output exists but couldn't parse - no error, just no GPUs found
+    }
+    // No GPU tools found or no parseable output - this is fine, not an error
+    return { gpus: null };
+}
+/**
+ * Resource Service - Singleton
+ *
+ * Provides cached, non-blocking access to system resources.
+ */
+class ResourceService {
+    cache = null;
+    cacheTime = 0;
+    collecting = false;
+    hostname;
+    hasLoggedOnce = false;
+    constructor() {
+        this.hostname = os_1.default.hostname();
+    }
+    /**
+     * Get resources - NEVER blocks, returns cached or empty
+     * Triggers async collection if cache is stale
+     */
+    getResources() {
+        const now = Date.now();
+        // Trigger async collection if cache is stale and not already collecting
+        if (!this.collecting && (now - this.cacheTime) > CACHE_TTL_MS) {
+            this.collectAsync();
+        }
+        // Return cached data or empty resources (never block)
+        return this.cache ?? this.getEmptyResources();
+    }
+    /**
+     * Force refresh - waits for collection but still has timeout protection
+     * Use sparingly (e.g., on explicit user request)
+     */
+    async refreshResources() {
+        await this.collectAsync();
+        return this.cache ?? this.getEmptyResources();
+    }
+    /**
+     * Check if cached data is stale
+     */
+    isStale() {
+        return (Date.now() - this.cacheTime) > STALE_THRESHOLD_MS;
+    }
+    /**
+     * Get empty resources (fallback)
+     */
+    getEmptyResources() {
+        return {
+            hostname: this.hostname,
+            ram: collectRAM(), // RAM is always instant and available
+            gpus: null,
+            collectedAt: Date.now(),
+        };
+    }
+    /**
+     * Async collection - runs in background, updates cache
+     */
+    async collectAsync() {
+        if (this.collecting)
+            return;
+        this.collecting = true;
+        try {
+            // RAM is instant, GPU may timeout (that's OK)
+            const [ram, gpuResult] = await Promise.all([
+                Promise.resolve(collectRAM()),
+                collectGPUs(),
+            ]);
+            this.cache = {
+                hostname: this.hostname,
+                ram,
+                gpus: gpuResult.gpus,
+                gpuError: gpuResult.error,
+                collectedAt: Date.now(),
+            };
+            this.cacheTime = Date.now();
+            // Only log once on startup
+            if (!this.hasLoggedOnce) {
+                this.hasLoggedOnce = true;
+                if (gpuResult.gpus) {
+                    console.log(`[ResourceService] RAM ${ram.total}GB, GPU ${gpuResult.gpus.totalMemory}GB (${gpuResult.gpus.devices.length} ${gpuResult.gpus.vendor} device${gpuResult.gpus.devices.length > 1 ? 's' : ''})`);
+                }
+                else {
+                    console.log(`[ResourceService] RAM ${ram.total}GB, no GPU`);
+                }
+            }
+        }
+        catch (err) {
+            console.error('[ResourceService] Collection failed:', err);
+            // Still update RAM at least
+            this.cache = this.getEmptyResources();
+            this.cacheTime = Date.now();
+        }
+        finally {
+            this.collecting = false;
+        }
+    }
+}
+exports.ResourceService = ResourceService;
+// Singleton instance
+let instance = null;
+function getResourceService() {
+    if (!instance) {
+        instance = new ResourceService();
+    }
+    return instance;
+}

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

@@ -0,0 +1,5 @@
+/**
+ * Auth Routes - API endpoints for 2FA authentication
+ */
+import { FastifyInstance } from 'fastify';
+export default function authRoutes(fastify: FastifyInstance): Promise<void>;

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

@@ -0,0 +1,61 @@
+"use strict";
+/**
+ * Auth Routes - API endpoints for 2FA authentication
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = authRoutes;
+const auth_service_1 = require("../auth/auth-service");
+const auth_middleware_1 = require("../auth/auth-middleware");
+async function authRoutes(fastify) {
+    /**
+     * GET /auth/status
+     * Check if 2FA is configured and if the current request is authenticated
+     */
+    fastify.get('/auth/status', async (request, reply) => {
+        // Extract token from Authorization header or query parameter
+        let token;
+        const authHeader = request.headers.authorization;
+        if (authHeader?.startsWith('Bearer ')) {
+            token = authHeader.slice(7);
+        }
+        const status = auth_service_1.authService.getAuthStatus(token);
+        return reply.send(status);
+    });
+    /**
+     * POST /auth/verify
+     * Verify a TOTP code and issue a session token
+     */
+    fastify.post('/auth/verify', async (request, reply) => {
+        const { code, trustBrowser } = request.body;
+        if (!code || typeof code !== 'string') {
+            return reply.code(400).send({
+                error: 'invalid_request',
+                message: 'Verification code is required',
+            });
+        }
+        // Clean the code (remove spaces)
+        const cleanCode = code.replace(/\s/g, '');
+        if (!/^\d{6}$/.test(cleanCode)) {
+            return reply.code(400).send({
+                error: 'invalid_format',
+                message: 'Code must be 6 digits',
+            });
+        }
+        const result = auth_service_1.authService.verifyCode(cleanCode, !!trustBrowser);
+        if (result.success) {
+            // Persist token so MCP servers and CLI tools can auto-authenticate
+            if (result.token)
+                (0, auth_middleware_1.persistSessionToken)(result.token);
+            return reply.send({
+                success: true,
+                token: result.token,
+            });
+        }
+        else {
+            return reply.code(401).send({
+                success: false,
+                error: result.error,
+            });
+        }
+    });
+}

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

@@ -0,0 +1,7 @@
+/**
+ * Cluster Management API Routes
+ *
+ * Endpoints for server registration and cluster management.
+ */
+import { FastifyInstance } from 'fastify';
+export default function clusterRoutes(fastify: FastifyInstance): Promise<void>;