nebula-notebook 0.1.0

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

@@ -0,0 +1,254 @@
+"use strict";
+/**
+ * Terminal Server - Routes and WebSocket setup for PTY management
+ */
+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.setupTerminalRoutes = setupTerminalRoutes;
+exports.setupTerminalWebSocket = setupTerminalWebSocket;
+exports.cleanupTerminals = cleanupTerminals;
+const ws_1 = require("ws");
+const path = __importStar(require("path"));
+const pty_manager_1 = require("./pty-manager");
+const fs_service_1 = require("../fs/fs-service");
+// Get configured root directory for terminals
+function getDefaultCwd() {
+    return fs_service_1.fsService.normalizePath('~');
+}
+// Nebula repo root on the server (parent of node-server). Surfaced so the UI
+// can show a path-qualified MCP setup command — agents/users won't know where
+// the repo lives, and `npm run setup-mcp` only works from inside it.
+// Works from both src/ (tsx) and dist/ (build): each is 3 levels deep.
+const NEBULA_REPO_ROOT = path.resolve(__dirname, '..', '..', '..');
+// Track WebSocket connections by terminal ID
+const wsConnections = new Map();
+/**
+ * Setup terminal REST routes as a Fastify plugin
+ */
+async function setupTerminalRoutes(fastify) {
+    // Terminal health check (includes terminal count and repo root for the
+    // path-qualified MCP setup hint shown in the agent terminal UI)
+    fastify.get('/api/terminals/health', async (_request, reply) => {
+        return reply.send({ status: 'ok', terminals: pty_manager_1.ptyManager.list().length, repo_root: NEBULA_REPO_ROOT });
+    });
+    // List all terminals
+    fastify.get('/api/terminals', async (_request, reply) => {
+        return reply.send(pty_manager_1.ptyManager.list());
+    });
+    // Create a new terminal
+    fastify.post('/api/terminals', async (request, reply) => {
+        const options = request.body || {};
+        // Use configured root directory as default cwd
+        const finalOptions = { cwd: getDefaultCwd(), ...options };
+        try {
+            const terminal = pty_manager_1.ptyManager.create(finalOptions);
+            console.log(`[Terminal] Created terminal ${terminal.id} (PID: ${terminal.pid})`);
+            return reply.code(201).send(terminal);
+        }
+        catch (error) {
+            console.error('[Terminal] Failed to create terminal:', error);
+            return reply.code(500).send({
+                error: 'Failed to create terminal',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            });
+        }
+    });
+    // Get or create a named terminal (for persistent terminals via URL)
+    fastify.post('/api/terminals/named/:name', async (request, reply) => {
+        const { name } = request.params;
+        const options = request.body || {};
+        // Use configured root directory as default cwd
+        const finalOptions = { cwd: getDefaultCwd(), ...options };
+        try {
+            const terminal = pty_manager_1.ptyManager.getOrCreate(name, finalOptions);
+            console.log(`[Terminal] Get/create named terminal '${name}' -> ${terminal.id}`);
+            return reply.send(terminal);
+        }
+        catch (error) {
+            console.error('[Terminal] Failed to get/create named terminal:', error);
+            return reply.code(500).send({
+                error: 'Failed to get/create terminal',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            });
+        }
+    });
+    // Get terminal info
+    fastify.get('/api/terminals/:id', async (request, reply) => {
+        const terminal = pty_manager_1.ptyManager.getTerminalInfo(request.params.id);
+        if (!terminal) {
+            return reply.code(404).send({ error: 'Terminal not found' });
+        }
+        return reply.send(terminal);
+    });
+    // Delete/close a terminal
+    fastify.delete('/api/terminals/:id', async (request, reply) => {
+        const success = pty_manager_1.ptyManager.kill(request.params.id);
+        if (!success) {
+            return reply.code(404).send({ error: 'Terminal not found' });
+        }
+        console.log(`[Terminal] Closed terminal ${request.params.id}`);
+        return reply.send({ status: 'ok' });
+    });
+    // Resize terminal
+    fastify.post('/api/terminals/:id/resize', async (request, reply) => {
+        const { cols, rows } = request.body;
+        if (!cols || !rows) {
+            return reply.code(400).send({ error: 'cols and rows are required' });
+        }
+        const success = pty_manager_1.ptyManager.resize(request.params.id, cols, rows);
+        if (!success) {
+            return reply.code(404).send({ error: 'Terminal not found' });
+        }
+        return reply.send({ status: 'ok', cols, rows });
+    });
+}
+/**
+ * Setup terminal WebSocket server with noServer mode
+ * Returns the WSS so the upgrade can be handled externally
+ */
+function setupTerminalWebSocket(server) {
+    // Use noServer mode to avoid conflicts with kernel WebSocket
+    const wss = new ws_1.WebSocketServer({
+        noServer: true,
+        perMessageDeflate: false, // Disable compression
+    });
+    // Handle upgrade requests for /ws path
+    server.on('upgrade', (request, socket, head) => {
+        const pathname = new URL(request.url || '', `http://${request.headers.host}`).pathname;
+        if (pathname === '/ws') {
+            // Authenticate WebSocket connection
+            const { authWebSocketMiddleware } = require('../auth');
+            if (!authWebSocketMiddleware(request)) {
+                socket.write('HTTP/1.1 401 Unauthorized\r\n\r\n');
+                socket.destroy();
+                return;
+            }
+            wss.handleUpgrade(request, socket, head, (ws) => {
+                wss.emit('connection', ws, request);
+            });
+        }
+        // Don't destroy socket for non-matching paths - let other handlers deal with it
+    });
+    wss.on('connection', (ws, req) => {
+        // Extract terminal ID from URL query
+        const url = new URL(req.url || '', `http://${req.headers.host}`);
+        const terminalId = url.searchParams.get('id');
+        if (!terminalId) {
+            ws.close(4000, 'Terminal ID required');
+            return;
+        }
+        const session = pty_manager_1.ptyManager.get(terminalId);
+        if (!session) {
+            ws.close(4004, 'Terminal not found');
+            return;
+        }
+        console.log(`[Terminal] WebSocket connected to terminal ${terminalId}`);
+        // Track this connection
+        if (!wsConnections.has(terminalId)) {
+            wsConnections.set(terminalId, new Set());
+        }
+        const connections = wsConnections.get(terminalId);
+        connections.add(ws);
+        // Send buffered output for reconnection
+        const buffer = pty_manager_1.ptyManager.getOutputBuffer(terminalId);
+        if (buffer) {
+            const replayMsg = { type: 'replay', data: buffer };
+            ws.send(JSON.stringify(replayMsg));
+        }
+        // Collaborative mode: broadcast output to ALL connected clients
+        const broadcastOutput = (data) => {
+            const msg = { type: 'output', data };
+            const msgStr = JSON.stringify(msg);
+            for (const conn of connections) {
+                if (conn.readyState === ws_1.WebSocket.OPEN) {
+                    conn.send(msgStr);
+                }
+            }
+        };
+        pty_manager_1.ptyManager.setOnData(terminalId, broadcastOutput);
+        // Set up exit listener - broadcast to all connections
+        pty_manager_1.ptyManager.setOnExit(terminalId, (code) => {
+            const msg = { type: 'exit', code };
+            const msgStr = JSON.stringify(msg);
+            for (const conn of connections) {
+                if (conn.readyState === ws_1.WebSocket.OPEN) {
+                    conn.send(msgStr);
+                }
+            }
+        });
+        // Handle incoming messages
+        ws.on('message', (rawData) => {
+            try {
+                const message = JSON.parse(rawData.toString());
+                switch (message.type) {
+                    case 'input':
+                        pty_manager_1.ptyManager.write(terminalId, message.data);
+                        break;
+                    case 'resize':
+                        pty_manager_1.ptyManager.resize(terminalId, message.cols, message.rows);
+                        break;
+                    default:
+                        console.warn(`[Terminal] Unknown message type:`, message);
+                }
+            }
+            catch (error) {
+                console.error('[Terminal] Failed to parse message:', error);
+            }
+        });
+        // Handle disconnection
+        ws.on('close', () => {
+            console.log(`[Terminal] WebSocket disconnected from terminal ${terminalId}`);
+            const connections = wsConnections.get(terminalId);
+            if (connections) {
+                connections.delete(ws);
+                if (connections.size === 0) {
+                    wsConnections.delete(terminalId);
+                    // Clear the data listener when no connections
+                    pty_manager_1.ptyManager.setOnData(terminalId, null);
+                }
+            }
+        });
+        ws.on('error', (error) => {
+            console.error(`[Terminal] WebSocket error for terminal ${terminalId}:`, error);
+        });
+    });
+    return wss;
+}
+/**
+ * Cleanup all terminals (call on shutdown)
+ */
+function cleanupTerminals() {
+    pty_manager_1.ptyManager.killAll();
+}

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

@@ -0,0 +1,50 @@
+/**
+ * Terminal Server Types
+ */
+export interface TerminalInfo {
+    id: string;
+    pid: number;
+    cwd: string;
+    shell: string;
+    cols: number;
+    rows: number;
+    created: number;
+    lastActivity: number;
+}
+export interface CreateTerminalRequest {
+    cwd?: string;
+    shell?: string;
+    cols?: number;
+    rows?: number;
+}
+export interface ResizeTerminalRequest {
+    cols: number;
+    rows: number;
+}
+export type ClientMessage = {
+    type: 'input';
+    data: string;
+} | {
+    type: 'resize';
+    cols: number;
+    rows: number;
+};
+export type ServerMessage = {
+    type: 'output';
+    data: string;
+} | {
+    type: 'replay';
+    data: string;
+} | {
+    type: 'exit';
+    code: number;
+} | {
+    type: 'error';
+    message: string;
+} | {
+    type: 'inactive';
+} | {
+    type: 'active';
+};
+export declare const OUTPUT_BUFFER_MAX_SIZE = 100000;
+export declare const OUTPUT_BUFFER_TRIM_SIZE = 50000;

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

@@ -0,0 +1,9 @@
+"use strict";
+/**
+ * Terminal Server Types
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OUTPUT_BUFFER_TRIM_SIZE = exports.OUTPUT_BUFFER_MAX_SIZE = void 0;
+// Output buffer settings
+exports.OUTPUT_BUFFER_MAX_SIZE = 100000; // ~100KB of scrollback
+exports.OUTPUT_BUFFER_TRIM_SIZE = 50000; // Trim to ~50KB when exceeded

package/node-server/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "nebula-node-server",
+  "version": "1.0.0",
+  "description": "Node.js server for Nebula Notebook (terminals, filesystem, kernels, LLM)",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "node --watch --import tsx src/index.ts",
+    "auth:qr": "tsx src/scripts/show-auth-qr.ts",
+    "test": "vitest",
+    "test:run": "vitest run"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.32.0",
+    "@fastify/cors": "^11.2.0",
+    "@fastify/multipart": "^9.4.0",
+    "@fastify/static": "^9.0.0",
+    "@fastify/websocket": "^11.2.0",
+    "@google/genai": "^0.7.0",
+    "@homebridge/node-pty-prebuilt-multiarch": "^0.14.0",
+    "better-sqlite3": "^11.0.0",
+    "fastify": "^5.8.2",
+    "jsonwebtoken": "^9.0.2",
+    "openai": "^4.77.0",
+    "otplib": "^12.0.1",
+    "qrcode-terminal": "^0.12.0",
+    "uuid": "^9.0.1",
+    "ws": "^8.16.0",
+    "zeromq": "^6.4.2"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.8",
+    "@types/jsonwebtoken": "^9.0.5",
+    "@types/node": "^20.10.0",
+    "@types/qrcode-terminal": "^0.12.2",
+    "@types/supertest": "^6.0.3",
+    "@types/uuid": "^9.0.7",
+    "@types/ws": "^8.5.10",
+    "supertest": "^7.2.2",
+    "tsx": "^4.7.0",
+    "typescript": "^5.3.0",
+    "vitest": "^4.0.16"
+  }
+}

package/package.json

@@ -0,0 +1,99 @@
+{
+  "name": "nebula-notebook",
+  "version": "0.1.0",
+  "description": "AI-native notebook computing environment \u2014 real Jupyter kernels, real filesystem, built to be driven by agents (Claude Code / Codex) via MCP",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jzthree/nebula-notebook.git"
+  },
+  "keywords": [
+    "notebook",
+    "jupyter",
+    "ai",
+    "agent",
+    "mcp",
+    "claude",
+    "kernel"
+  ],
+  "bin": {
+    "nebula-notebook": "bin/nebula-notebook.js"
+  },
+  "files": [
+    "bin",
+    "dist",
+    "node-server/dist/**",
+    "node-server/package.json",
+    "scripts/postinstall.cjs"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "dev": "concurrently --kill-others --kill-signal SIGTERM --raw \"cd node-server && PORT=${VITE_API_PORT:-8000} npm run dev\" \"VITE_API_PORT=${VITE_API_PORT:-8000} vite\"",
+    "start": "npm run dev",
+    "prod": "cd node-server && PORT=3000 npm run dev",
+    "auth:qr": "cd node-server && npm run auth:qr",
+    "build": "vite build",
+    "preview": "vite preview",
+    "node-server": "cd node-server && npm run dev",
+    "node-server:build": "cd node-server && npm run build",
+    "mcp": "npm --prefix packages/mcp run mcp",
+    "mcp:build": "npm --prefix packages/mcp run build",
+    "mcp:test": "npm --prefix packages/mcp test",
+    "setup-mcp": "npm --prefix packages/mcp run setup-mcp",
+    "setup": "node setup.cjs",
+    "postinstall": "node scripts/postinstall.cjs",
+    "prepublishOnly": "npm run build && npm run node-server:build",
+    "stop": "lsof -ti:3000,3001,8000 | xargs kill -9 2>/dev/null; echo 'Servers stopped'",
+    "test": "vitest",
+    "test:run": "vitest run"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.32.0",
+    "@fastify/cors": "^11.2.0",
+    "@fastify/multipart": "^9.4.0",
+    "@fastify/static": "^9.0.0",
+    "@fastify/websocket": "^11.2.0",
+    "@google/genai": "^0.7.0",
+    "@homebridge/node-pty-prebuilt-multiarch": "^0.14.0",
+    "better-sqlite3": "^11.0.0",
+    "fastify": "^5.8.2",
+    "jsonwebtoken": "^9.0.2",
+    "openai": "^4.77.0",
+    "otplib": "^12.0.1",
+    "qrcode-terminal": "^0.12.0",
+    "uuid": "^9.0.1",
+    "ws": "^8.16.0",
+    "zeromq": "^6.4.2"
+  },
+  "devDependencies": {
+    "@codemirror/lang-markdown": "^6.5.0",
+    "@codemirror/lang-python": "^6.2.1",
+    "@playwright/test": "^1.57.0",
+    "@tailwindcss/vite": "^4.2.1",
+    "@testing-library/jest-dom": "^6.9.1",
+    "@testing-library/react": "^16.3.1",
+    "@types/diff-match-patch": "^1.0.36",
+    "@types/node": "^22.14.0",
+    "@types/react": "^19.2.7",
+    "@types/react-dom": "^19.2.3",
+    "@uiw/react-codemirror": "^4.25.4",
+    "@vitejs/plugin-react": "^5.0.0",
+    "@xterm/addon-fit": "^0.11.0",
+    "@xterm/addon-web-links": "^0.12.0",
+    "@xterm/xterm": "^6.0.0",
+    "ansi-to-html": "^0.7.2",
+    "concurrently": "^9.1.0",
+    "diff-match-patch": "^1.0.5",
+    "jsdom": "^27.3.0",
+    "lucide-react": "^0.561.0",
+    "react": "^19.2.3",
+    "react-dom": "^19.2.3",
+    "tailwindcss": "^4.2.1",
+    "typescript": "~5.8.2",
+    "vite": "^6.2.0",
+    "vitest": "^4.0.16"
+  }
+}

package/scripts/postinstall.cjs

@@ -0,0 +1,26 @@
+/**
+ * Repo-checkout convenience: install the node-server and packages/mcp
+ * subpackage dependencies after a root `npm install`.
+ *
+ * Skipped entirely when nebula-notebook is installed from npm as a
+ * dependency — the published package is self-contained (server runtime
+ * deps live in the root package.json; dist artifacts are prebuilt).
+ */
+const path = require('path');
+const fs = require('fs');
+const { execSync } = require('child_process');
+
+if (__dirname.split(path.sep).includes('node_modules')) {
+  process.exit(0);
+}
+
+const root = path.join(__dirname, '..');
+for (const dir of ['node-server', path.join('packages', 'mcp')]) {
+  const pkg = path.join(root, dir, 'package.json');
+  if (!fs.existsSync(pkg)) continue;
+  try {
+    execSync('npm install', { cwd: path.join(root, dir), stdio: 'inherit' });
+  } catch {
+    console.warn(`⚠️  postinstall: npm install failed in ${dir}`);
+  }
+}