nebula-notebook 0.1.0

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

@@ -0,0 +1,77 @@
+"use strict";
+/**
+ * Resources API Routes
+ *
+ * Provides endpoints for system resource monitoring (RAM, GPU).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = resourceRoutes;
+const resource_service_1 = require("../resources/resource-service");
+const server_registry_1 = require("../cluster/server-registry");
+const resourceService = (0, resource_service_1.getResourceService)();
+async function resourceRoutes(fastify) {
+    /**
+     * GET /
+     *
+     * Get server resources (RAM, GPU).
+     * If server_id is provided and not local, fetches from remote server.
+     * Returns cached data - never blocks.
+     */
+    fastify.get('/', async (request, reply) => {
+        try {
+            const serverId = request.query.server_id;
+            const localServerId = server_registry_1.serverRegistry.getLocalServerId();
+            // Check if we need to fetch from a remote server
+            if (serverId && serverId !== localServerId && serverId !== 'local') {
+                const server = server_registry_1.serverRegistry.getServer(serverId);
+                if (!server) {
+                    return reply.code(404).send({ error: `Server not found: ${serverId}` });
+                }
+                if (server.status !== 'online') {
+                    return reply.code(503).send({ error: `Server is offline: ${serverId}` });
+                }
+                // Fetch from remote server
+                const response = await fetch(`${server.url}/api/resources`, {
+                    headers: process.env.NEBULA_CLUSTER_SECRET
+                        ? { 'X-Nebula-Cluster-Secret': process.env.NEBULA_CLUSTER_SECRET }
+                        : undefined,
+                });
+                if (!response.ok) {
+                    const error = await response.json().catch(() => ({ error: 'Unknown error' }));
+                    return reply.code(response.status).send({ error: error.error || 'Failed to fetch resources' });
+                }
+                const data = await response.json();
+                return reply.send(data);
+            }
+            // Return local resources
+            const resources = resourceService.getResources();
+            return reply.send({
+                ...resources,
+                isStale: resourceService.isStale(),
+            });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : 'Unknown error';
+            return reply.code(500).send({ error: message });
+        }
+    });
+    /**
+     * POST /refresh
+     *
+     * Force refresh resources (still has timeout protection).
+     * Use sparingly - normally cached data is sufficient.
+     */
+    fastify.post('/refresh', async (_request, reply) => {
+        try {
+            const resources = await resourceService.refreshResources();
+            return reply.send({
+                ...resources,
+                isStale: false,
+            });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : 'Unknown error';
+            return reply.code(500).send({ error: message });
+        }
+    });
+}

package/node-server/dist/scripts/show-auth-qr.d.ts

@@ -0,0 +1 @@
+export {};

package/node-server/dist/scripts/show-auth-qr.js

@@ -0,0 +1,81 @@
+"use strict";
+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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const otplib_1 = require("otplib");
+const qrcode = __importStar(require("qrcode-terminal"));
+const AUTH_CONFIG_FILE = path_1.default.join(os_1.default.homedir(), '.nebula', 'auth.json');
+const ISSUER = 'NebulaNotebook';
+const ACCOUNT_NAME = 'local';
+function fail(message) {
+    console.error(message);
+    process.exit(1);
+}
+function readAuthConfig() {
+    if (!fs_1.default.existsSync(AUTH_CONFIG_FILE)) {
+        fail(`[Auth] Config not found: ${AUTH_CONFIG_FILE}\n[Auth] Start the Nebula server once to initialize 2FA.`);
+    }
+    try {
+        const raw = fs_1.default.readFileSync(AUTH_CONFIG_FILE, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        fail(`[Auth] Failed to read ${AUTH_CONFIG_FILE}: ${detail}`);
+    }
+}
+function main() {
+    const config = readAuthConfig();
+    const secret = typeof config.totpSecret === 'string' ? config.totpSecret.trim() : '';
+    if (!secret) {
+        fail(`[Auth] Missing \"totpSecret\" in ${AUTH_CONFIG_FILE}`);
+    }
+    const otpAuthUrl = otplib_1.authenticator.keyuri(ACCOUNT_NAME, ISSUER, secret);
+    console.log('\n' + '='.repeat(60));
+    console.log('  NEBULA NOTEBOOK - 2FA QR');
+    console.log('='.repeat(60));
+    console.log('\nScan this QR code with your authenticator app:\n');
+    qrcode.generate(otpAuthUrl, { small: true });
+    console.log('\nOr enter this key manually: ' + secret);
+    console.log(`\nConfig: ${AUTH_CONFIG_FILE}`);
+    console.log(`[Auth] setupComplete=${config.setupComplete === true ? 'true' : 'false'}`);
+    console.log('='.repeat(60) + '\n');
+}
+main();

package/node-server/dist/terminal/pty-manager.d.ts

@@ -0,0 +1,100 @@
+/**
+ * PTY Manager - Manages terminal sessions using node-pty
+ */
+import * as pty from '@homebridge/node-pty-prebuilt-multiarch';
+import { TerminalInfo } from './types';
+interface TerminalSession {
+    id: string;
+    pty: pty.IPty;
+    cwd: string;
+    shell: string;
+    cols: number;
+    rows: number;
+    created: number;
+    lastActivity: number;
+    outputBuffer: string;
+    onData: ((data: string) => void) | null;
+    onExit: ((code: number) => void) | null;
+}
+export declare class PtyManager {
+    private sessions;
+    /**
+     * Get the default shell for the current platform
+     */
+    private getDefaultShell;
+    /**
+     * Normalize a terminal name to a valid ID
+     * - Lowercase
+     * - Only alphanumeric, hyphens, underscores
+     * - Max 32 chars
+     * - Falls back to 'default' if empty/invalid
+     */
+    normalizeTerminalName(name: string): string;
+    /**
+     * Create a new terminal session
+     */
+    create(options?: {
+        id?: string;
+        cwd?: string;
+        shell?: string;
+        cols?: number;
+        rows?: number;
+    }): TerminalInfo;
+    /**
+     * Get terminal info from session
+     */
+    private getInfo;
+    /**
+     * Get a terminal session by ID
+     */
+    get(id: string): TerminalSession | undefined;
+    /**
+     * Get terminal info by ID
+     */
+    getTerminalInfo(id: string): TerminalInfo | undefined;
+    /**
+     * List all active terminals
+     */
+    list(): TerminalInfo[];
+    /**
+     * Write data to a terminal
+     */
+    write(id: string, data: string): boolean;
+    /**
+     * Resize a terminal
+     */
+    resize(id: string, cols: number, rows: number): boolean;
+    /**
+     * Get or create a terminal by name
+     * If a terminal with the normalized name exists, return it
+     * Otherwise create a new one with that name
+     */
+    getOrCreate(name: string, options?: {
+        cwd?: string;
+        shell?: string;
+        cols?: number;
+        rows?: number;
+    }): TerminalInfo;
+    /**
+     * Kill a terminal session
+     */
+    kill(id: string): boolean;
+    /**
+     * Set data listener for a terminal (for WebSocket connection)
+     */
+    setOnData(id: string, callback: ((data: string) => void) | null): void;
+    /**
+     * Set exit listener for a terminal
+     */
+    setOnExit(id: string, callback: ((code: number) => void) | null): void;
+    /**
+     * Get buffered output for reconnection
+     */
+    getOutputBuffer(id: string): string;
+    /**
+     * Kill all terminal sessions (for cleanup)
+     */
+    killAll(): void;
+}
+export declare const ptyManager: PtyManager;
+export {};

package/node-server/dist/terminal/pty-manager.js

@@ -0,0 +1,246 @@
+"use strict";
+/**
+ * PTY Manager - Manages terminal sessions using node-pty
+ */
+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.ptyManager = exports.PtyManager = void 0;
+const pty = __importStar(require("@homebridge/node-pty-prebuilt-multiarch"));
+const uuid_1 = require("uuid");
+const types_1 = require("./types");
+class PtyManager {
+    sessions = new Map();
+    /**
+     * Get the default shell for the current platform
+     */
+    getDefaultShell() {
+        if (process.platform === 'win32') {
+            return process.env.COMSPEC || 'cmd.exe';
+        }
+        return process.env.SHELL || '/bin/bash';
+    }
+    /**
+     * Normalize a terminal name to a valid ID
+     * - Lowercase
+     * - Only alphanumeric, hyphens, underscores
+     * - Max 32 chars
+     * - Falls back to 'default' if empty/invalid
+     */
+    normalizeTerminalName(name) {
+        const normalized = name
+            .toLowerCase()
+            .replace(/[^a-z0-9_-]/g, '-')
+            .replace(/-+/g, '-')
+            .replace(/^-|-$/g, '')
+            .slice(0, 32);
+        return normalized || 'default';
+    }
+    /**
+     * Create a new terminal session
+     */
+    create(options) {
+        const id = options?.id ? this.normalizeTerminalName(options.id) : (0, uuid_1.v4)();
+        const shell = options?.shell || this.getDefaultShell();
+        const cwd = options?.cwd || process.cwd();
+        const cols = options?.cols || 80;
+        const rows = options?.rows || 24;
+        // Spawn PTY process
+        const ptyProcess = pty.spawn(shell, [], {
+            name: 'xterm-256color',
+            cols,
+            rows,
+            cwd,
+            env: {
+                ...process.env,
+                TERM: 'xterm-256color',
+                COLORTERM: 'truecolor',
+            },
+        });
+        const session = {
+            id,
+            pty: ptyProcess,
+            cwd,
+            shell,
+            cols,
+            rows,
+            created: Date.now(),
+            lastActivity: Date.now(),
+            outputBuffer: '',
+            onData: null,
+            onExit: null,
+        };
+        // Handle PTY output
+        ptyProcess.onData((data) => {
+            session.lastActivity = Date.now();
+            // Append to output buffer for reconnection
+            session.outputBuffer += data;
+            // Trim buffer if too large
+            if (session.outputBuffer.length > types_1.OUTPUT_BUFFER_MAX_SIZE) {
+                session.outputBuffer = session.outputBuffer.slice(-types_1.OUTPUT_BUFFER_TRIM_SIZE);
+            }
+            // Forward to listener if connected
+            if (session.onData) {
+                session.onData(data);
+            }
+        });
+        // Handle PTY exit
+        ptyProcess.onExit(({ exitCode }) => {
+            if (session.onExit) {
+                session.onExit(exitCode);
+            }
+            this.sessions.delete(id);
+        });
+        this.sessions.set(id, session);
+        return this.getInfo(session);
+    }
+    /**
+     * Get terminal info from session
+     */
+    getInfo(session) {
+        return {
+            id: session.id,
+            pid: session.pty.pid,
+            cwd: session.cwd,
+            shell: session.shell,
+            cols: session.cols,
+            rows: session.rows,
+            created: session.created,
+            lastActivity: session.lastActivity,
+        };
+    }
+    /**
+     * Get a terminal session by ID
+     */
+    get(id) {
+        return this.sessions.get(id);
+    }
+    /**
+     * Get terminal info by ID
+     */
+    getTerminalInfo(id) {
+        const session = this.sessions.get(id);
+        return session ? this.getInfo(session) : undefined;
+    }
+    /**
+     * List all active terminals
+     */
+    list() {
+        return Array.from(this.sessions.values()).map((s) => this.getInfo(s));
+    }
+    /**
+     * Write data to a terminal
+     */
+    write(id, data) {
+        const session = this.sessions.get(id);
+        if (!session)
+            return false;
+        session.pty.write(data);
+        session.lastActivity = Date.now();
+        return true;
+    }
+    /**
+     * Resize a terminal
+     */
+    resize(id, cols, rows) {
+        const session = this.sessions.get(id);
+        if (!session)
+            return false;
+        session.pty.resize(cols, rows);
+        session.cols = cols;
+        session.rows = rows;
+        session.lastActivity = Date.now();
+        return true;
+    }
+    /**
+     * Get or create a terminal by name
+     * If a terminal with the normalized name exists, return it
+     * Otherwise create a new one with that name
+     */
+    getOrCreate(name, options) {
+        const normalizedId = this.normalizeTerminalName(name);
+        const existing = this.sessions.get(normalizedId);
+        if (existing) {
+            return this.getInfo(existing);
+        }
+        return this.create({ ...options, id: normalizedId });
+    }
+    /**
+     * Kill a terminal session
+     */
+    kill(id) {
+        const session = this.sessions.get(id);
+        if (!session)
+            return false;
+        session.pty.kill();
+        this.sessions.delete(id);
+        return true;
+    }
+    /**
+     * Set data listener for a terminal (for WebSocket connection)
+     */
+    setOnData(id, callback) {
+        const session = this.sessions.get(id);
+        if (session) {
+            session.onData = callback;
+        }
+    }
+    /**
+     * Set exit listener for a terminal
+     */
+    setOnExit(id, callback) {
+        const session = this.sessions.get(id);
+        if (session) {
+            session.onExit = callback;
+        }
+    }
+    /**
+     * Get buffered output for reconnection
+     */
+    getOutputBuffer(id) {
+        const session = this.sessions.get(id);
+        return session?.outputBuffer || '';
+    }
+    /**
+     * Kill all terminal sessions (for cleanup)
+     */
+    killAll() {
+        for (const [id] of this.sessions) {
+            this.kill(id);
+        }
+    }
+}
+exports.PtyManager = PtyManager;
+// Singleton instance
+exports.ptyManager = new PtyManager();

package/node-server/dist/terminal/server.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Terminal Server - Routes and WebSocket setup for PTY management
+ */
+import { FastifyInstance } from 'fastify';
+import { WebSocketServer } from 'ws';
+import { Server as HttpServer } from 'http';
+/**
+ * Setup terminal REST routes as a Fastify plugin
+ */
+export declare function setupTerminalRoutes(fastify: FastifyInstance): Promise<void>;
+/**
+ * Setup terminal WebSocket server with noServer mode
+ * Returns the WSS so the upgrade can be handled externally
+ */
+export declare function setupTerminalWebSocket(server: HttpServer): WebSocketServer;
+/**
+ * Cleanup all terminals (call on shutdown)
+ */
+export declare function cleanupTerminals(): void;