mrmd-server 0.1.0

package/src/events.js

@@ -0,0 +1,50 @@
+/**
+ * Event bus for server-side events that need to be pushed to clients
+ *
+ * Events:
+ * - files-update: File list changed
+ * - venv-found: Venv discovered during scan
+ * - venv-scan-done: Venv scan complete
+ * - project:changed: Project files changed
+ * - sync-server-died: Sync server crashed
+ */
+
+import { EventEmitter } from 'events';
+
+export class EventBus extends EventEmitter {
+  constructor() {
+    super();
+    this.setMaxListeners(100); // Allow many WebSocket connections
+  }
+
+  /**
+   * Emit an event to all connected clients
+   * @param {string} event - Event name
+   * @param {any} data - Event data
+   */
+  broadcast(event, data) {
+    this.emit('broadcast', { event, data });
+  }
+
+  // Convenience methods for specific events
+
+  filesUpdated(files) {
+    this.broadcast('files-update', { files });
+  }
+
+  venvFound(venv) {
+    this.broadcast('venv-found', venv);
+  }
+
+  venvScanDone() {
+    this.broadcast('venv-scan-done', {});
+  }
+
+  projectChanged(projectRoot) {
+    this.broadcast('project:changed', { projectRoot });
+  }
+
+  syncServerDied(data) {
+    this.broadcast('sync-server-died', data);
+  }
+}

package/src/index.js

@@ -0,0 +1,9 @@
+/**
+ * mrmd-server - HTTP server for mrmd
+ *
+ * Provides the same API as Electron's main process, but over HTTP.
+ * This allows running mrmd in any browser, accessing from anywhere.
+ */
+
+export { createServer, startServer } from './server.js';
+export { EventBus } from './events.js';

package/src/server-v2.js

@@ -0,0 +1,118 @@
+/**
+ * mrmd-server v2 - Uses shared handlers from mrmd-electron
+ *
+ * This version imports the handler definitions from mrmd-electron,
+ * so any new handlers added there automatically work here.
+ */
+
+import express from 'express';
+import cors from 'cors';
+import { createServer as createHttpServer } from 'http';
+import { WebSocketServer } from 'ws';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+import { createAuthMiddleware, generateToken } from './auth.js';
+import { EventBus } from './events.js';
+import { setupWebSocket } from './websocket.js';
+
+// Import shared handlers from mrmd-electron
+import {
+  handlers,
+  registerHttpHandlers,
+  generateHttpShim,
+} from '../../mrmd-electron/src/handlers/index.js';
+
+// Import services (these could also be shared)
+import { ProjectService } from '../../mrmd-electron/src/services/project-service.js';
+import { FileService } from '../../mrmd-electron/src/services/file-service.js';
+// ... other services
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+/**
+ * Create the mrmd server using shared handlers
+ */
+export function createServerV2(config) {
+  const {
+    port = 8080,
+    host = '0.0.0.0',
+    projectDir,
+    token = generateToken(),
+    noAuth = false,
+  } = config;
+
+  if (!projectDir) {
+    throw new Error('projectDir is required');
+  }
+
+  const app = express();
+  const server = createHttpServer(app);
+  const eventBus = new EventBus();
+
+  // Initialize services (same as Electron would)
+  const projectService = new ProjectService(projectDir);
+  const fileService = new FileService(projectDir);
+  // ... initialize other services
+
+  // Create context (same shape as Electron's context)
+  const context = {
+    projectDir: path.resolve(projectDir),
+    projectService,
+    fileService,
+    // sessionService,
+    // bashService,
+    // assetService,
+    // venvService,
+    // pythonService,
+    // runtimeService,
+    eventBus,
+    // shell: null, // No shell in server mode
+  };
+
+  // Middleware
+  app.use(cors({ origin: true, credentials: true }));
+  app.use(express.json({ limit: '50mb' }));
+
+  // Auth
+  const authMiddleware = createAuthMiddleware(token, noAuth);
+  app.use('/api', authMiddleware);
+
+  // Health check
+  app.get('/health', (req, res) => res.json({ status: 'ok' }));
+
+  // Register ALL handlers from mrmd-electron automatically!
+  registerHttpHandlers(app, context);
+
+  // Serve auto-generated http-shim.js
+  app.get('/http-shim.js', (req, res) => {
+    res.type('application/javascript');
+    res.send(generateHttpShim());
+  });
+
+  // WebSocket for events
+  const wss = new WebSocketServer({ server, path: '/events' });
+  setupWebSocket(wss, eventBus, token, noAuth);
+
+  return {
+    app,
+    server,
+    context,
+    token,
+
+    async start() {
+      return new Promise((resolve) => {
+        server.listen(port, host, () => {
+          console.log(`mrmd-server running at http://${host}:${port}`);
+          console.log(`Token: ${token}`);
+          resolve({ url: `http://${host}:${port}`, token });
+        });
+      });
+    },
+
+    async stop() {
+      wss.clients.forEach(client => client.close());
+      return new Promise((resolve) => server.close(resolve));
+    },
+  };
+}

package/src/server.js

@@ -0,0 +1,297 @@
+/**
+ * Express server that mirrors Electron's electronAPI
+ */
+
+import express from 'express';
+import cors from 'cors';
+import { createServer as createHttpServer } from 'http';
+import { WebSocketServer } from 'ws';
+import path from 'path';
+import fs from 'fs/promises';
+import { existsSync } from 'fs';
+import { fileURLToPath } from 'url';
+
+import { createAuthMiddleware, generateToken } from './auth.js';
+import { EventBus } from './events.js';
+import { createProjectRoutes } from './api/project.js';
+import { createSessionRoutes } from './api/session.js';
+import { createBashRoutes } from './api/bash.js';
+import { createFileRoutes } from './api/file.js';
+import { createAssetRoutes } from './api/asset.js';
+import { createSystemRoutes } from './api/system.js';
+import { createRuntimeRoutes } from './api/runtime.js';
+import { createJuliaRoutes } from './api/julia.js';
+import { createPtyRoutes } from './api/pty.js';
+import { createNotebookRoutes } from './api/notebook.js';
+import { setupWebSocket } from './websocket.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+/**
+ * @typedef {Object} ServerConfig
+ * @property {number} port - HTTP port (default: 8080)
+ * @property {string} host - Bind host (default: '0.0.0.0')
+ * @property {string} projectDir - Root project directory
+ * @property {string} [token] - Auth token (generated if not provided)
+ * @property {boolean} [noAuth] - Disable auth (for local dev only!)
+ * @property {string} [staticDir] - Custom static files directory
+ * @property {string} [electronDir] - Path to mrmd-electron for index.html
+ * @property {number} [syncPort] - mrmd-sync port (default: 4444)
+ * @property {number} [pythonPort] - mrmd-python port (default: 8000)
+ * @property {number} [aiPort] - mrmd-ai port (default: 51790)
+ */
+
+/**
+ * Create the mrmd server (async)
+ * @param {ServerConfig} config
+ */
+export async function createServer(config) {
+  const {
+    port = 8080,
+    host = '0.0.0.0',
+    projectDir,
+    token = generateToken(),
+    noAuth = false,
+    staticDir,
+    electronDir,
+    syncPort = 4444,
+    pythonPort = 8000,
+    aiPort = 51790,
+  } = config;
+
+  if (!projectDir) {
+    throw new Error('projectDir is required');
+  }
+
+  const app = express();
+  const server = createHttpServer(app);
+  const eventBus = new EventBus();
+
+  // Service context passed to all route handlers
+  const context = {
+    projectDir: path.resolve(projectDir),
+    syncPort,
+    pythonPort,
+    aiPort,
+    eventBus,
+    // These will be populated by services
+    syncProcess: null,
+    pythonProcess: null,
+    monitorProcesses: new Map(),
+    watchers: new Map(),
+  };
+
+  // Middleware
+  app.use(cors({
+    origin: true,
+    credentials: true,
+  }));
+  app.use(express.json({ limit: '50mb' }));
+
+  // Auth middleware (skip for static files and health check)
+  const authMiddleware = createAuthMiddleware(token, noAuth);
+  app.use('/api', authMiddleware);
+
+  // Health check (no auth)
+  app.get('/health', (req, res) => {
+    res.json({ status: 'ok', version: '0.1.0' });
+  });
+
+  // Token info endpoint (no auth - used to validate tokens)
+  app.get('/auth/validate', (req, res) => {
+    const providedToken = req.query.token || req.headers.authorization?.replace('Bearer ', '');
+    if (noAuth || providedToken === token) {
+      res.json({ valid: true });
+    } else {
+      res.status(401).json({ valid: false });
+    }
+  });
+
+  // API routes - mirror electronAPI structure
+  app.use('/api/project', createProjectRoutes(context));
+  app.use('/api/session', createSessionRoutes(context));
+  app.use('/api/bash', createBashRoutes(context));
+  app.use('/api/file', createFileRoutes(context));
+  app.use('/api/asset', createAssetRoutes(context));
+  app.use('/api/system', createSystemRoutes(context));
+  app.use('/api/runtime', createRuntimeRoutes(context));
+  app.use('/api/julia', createJuliaRoutes(context));
+  app.use('/api/pty', createPtyRoutes(context));
+  app.use('/api/notebook', createNotebookRoutes(context));
+
+  // Serve http-shim.js
+  app.get('/http-shim.js', (req, res) => {
+    res.sendFile(path.join(__dirname, '../static/http-shim.js'));
+  });
+
+  // Find mrmd-electron directory for UI assets
+  const electronPath = electronDir || findElectronDir(__dirname);
+
+  if (electronPath) {
+    // Serve mrmd-electron assets (fonts, icons)
+    app.use('/assets', express.static(path.join(electronPath, 'assets')));
+
+    // Serve mrmd-editor dist
+    const editorDistPath = path.join(electronPath, '../mrmd-editor/dist');
+    app.use('/dist', express.static(editorDistPath));
+
+    // Serve transformed index.html at root
+    app.get('/', async (req, res) => {
+      try {
+        const indexPath = path.join(electronPath, 'index.html');
+        let html = await fs.readFile(indexPath, 'utf-8');
+
+        // Transform for browser mode:
+        // 1. Inject http-shim.js as first script in head
+        // 2. Update CSP to allow HTTP connections to this server
+        html = transformIndexHtml(html, host, port);
+
+        res.type('html').send(html);
+      } catch (err) {
+        console.error('[index.html]', err);
+        res.sendFile(path.join(__dirname, '../static/index.html'));
+      }
+    });
+  } else {
+    // Fallback: serve placeholder
+    console.warn('[server] mrmd-electron not found, serving placeholder UI');
+    app.use(express.static(path.join(__dirname, '../static')));
+  }
+
+  // Serve custom static files if provided
+  if (staticDir) {
+    app.use(express.static(staticDir));
+  }
+
+  // WebSocket for push events
+  const wss = new WebSocketServer({ server, path: '/events' });
+  setupWebSocket(wss, eventBus, token, noAuth);
+
+  return {
+    app,
+    server,
+    context,
+    eventBus,
+    token,
+    electronPath,
+
+    /**
+     * Start the server
+     */
+    async start() {
+      return new Promise((resolve) => {
+        server.listen(port, host, () => {
+          const url = `http://${host === '0.0.0.0' ? 'localhost' : host}:${port}`;
+          console.log('');
+          console.log('\x1b[36m  mrmd-server\x1b[0m');
+          console.log('  ' + '─'.repeat(50));
+          console.log(`  Server:     ${url}`);
+          console.log(`  Project:    ${context.projectDir}`);
+          if (electronPath) {
+            console.log(`  UI:         ${electronPath}`);
+          }
+          if (!noAuth) {
+            console.log(`  Token:      ${token}`);
+            console.log('');
+            console.log(`  \x1b[33mAccess URL:\x1b[0m`);
+            console.log(`  ${url}?token=${token}`);
+          }
+          console.log('');
+          resolve({ url, token });
+        });
+      });
+    },
+
+    /**
+     * Stop the server
+     */
+    async stop() {
+      // Clean up watchers
+      for (const watcher of context.watchers.values()) {
+        await watcher.close();
+      }
+
+      // Kill child processes
+      if (context.syncProcess) {
+        context.syncProcess.kill();
+      }
+      if (context.pythonProcess) {
+        context.pythonProcess.kill();
+      }
+      for (const proc of context.monitorProcesses.values()) {
+        proc.kill();
+      }
+
+      // Close WebSocket connections
+      wss.clients.forEach(client => client.close());
+
+      // Close server
+      return new Promise((resolve) => {
+        server.close(resolve);
+      });
+    },
+  };
+}
+
+/**
+ * Find mrmd-electron directory
+ */
+function findElectronDir(fromDir) {
+  const candidates = [
+    path.join(fromDir, '../../mrmd-electron'),
+    path.join(fromDir, '../../../mrmd-electron'),
+    path.join(process.cwd(), '../mrmd-electron'),
+    path.join(process.cwd(), 'mrmd-electron'),
+    // In npx/installed context, it might be in node_modules
+    path.join(fromDir, '../../node_modules/mrmd-electron'),
+    path.join(process.cwd(), 'node_modules/mrmd-electron'),
+  ];
+
+  for (const candidate of candidates) {
+    const indexPath = path.join(candidate, 'index.html');
+    if (existsSync(indexPath)) {
+      return path.resolve(candidate);
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Transform index.html for browser mode
+ * - Inject http-shim.js as first script
+ * - Update CSP to allow HTTP connections
+ */
+function transformIndexHtml(html, host, port) {
+  // 1. Inject http-shim.js right after <head>
+  const shimScript = `
+  <!-- HTTP shim for browser mode (injected by mrmd-server) -->
+  <script src="/http-shim.js"></script>
+`;
+  html = html.replace('<head>', '<head>' + shimScript);
+
+  // 2. Update CSP to allow connections to this server and any host
+  // Replace the strict CSP with a more permissive one for HTTP mode
+  const browserCSP = `default-src 'self' 'unsafe-inline' 'unsafe-eval' data: blob: ws: wss: http: https:; connect-src 'self' ws: wss: http: https: data: blob:; script-src 'self' 'unsafe-inline' 'unsafe-eval' https://esm.sh https://unpkg.com https://cdn.jsdelivr.net https://cdnjs.cloudflare.com blob: http:; font-src 'self' https://fonts.gstatic.com https://www.openresponses.org data:; style-src 'self' 'unsafe-inline' https://fonts.googleapis.com https:; img-src 'self' data: blob: https: http:; frame-src 'self' blob: data:`;
+
+  html = html.replace(
+    /<meta http-equiv="Content-Security-Policy" content="[^"]*">/,
+    `<meta http-equiv="Content-Security-Policy" content="${browserCSP}">`
+  );
+
+  // 3. Remove Electron-specific CSS (window drag regions)
+  html = html.replace(/-webkit-app-region:\s*drag;/g, '/* -webkit-app-region: drag; */');
+  html = html.replace(/-webkit-app-region:\s*no-drag;/g, '/* -webkit-app-region: no-drag; */');
+
+  return html;
+}
+
+/**
+ * Convenience function to create and start server
+ * @param {ServerConfig} config
+ */
+export async function startServer(config) {
+  const server = await createServer(config);
+  await server.start();
+  return server;
+}

package/src/websocket.js

@@ -0,0 +1,85 @@
+/**
+ * WebSocket handler for push events
+ *
+ * Clients connect to /events?token=xxx and receive JSON messages:
+ * { "event": "project:changed", "data": { ... } }
+ */
+
+import { validateWsToken } from './auth.js';
+
+/**
+ * Setup WebSocket server
+ * @param {import('ws').WebSocketServer} wss
+ * @param {import('./events.js').EventBus} eventBus
+ * @param {string} validToken
+ * @param {boolean} noAuth
+ */
+export function setupWebSocket(wss, eventBus, validToken, noAuth) {
+  // Track connected clients
+  const clients = new Set();
+
+  wss.on('connection', (ws, req) => {
+    // Validate token from query string
+    const url = new URL(req.url, 'http://localhost');
+    const token = url.searchParams.get('token');
+
+    if (!validateWsToken(token, validToken, noAuth)) {
+      ws.close(4001, 'Invalid token');
+      return;
+    }
+
+    clients.add(ws);
+    console.log(`[WS] Client connected (${clients.size} total)`);
+
+    // Send welcome message
+    ws.send(JSON.stringify({
+      event: 'connected',
+      data: { message: 'Connected to mrmd-server events' },
+    }));
+
+    ws.on('close', () => {
+      clients.delete(ws);
+      console.log(`[WS] Client disconnected (${clients.size} total)`);
+    });
+
+    ws.on('error', (err) => {
+      console.error('[WS] Error:', err.message);
+      clients.delete(ws);
+    });
+
+    // Handle ping/pong for connection health
+    ws.isAlive = true;
+    ws.on('pong', () => {
+      ws.isAlive = true;
+    });
+  });
+
+  // Broadcast events to all connected clients
+  eventBus.on('broadcast', ({ event, data }) => {
+    const message = JSON.stringify({ event, data });
+    for (const client of clients) {
+      if (client.readyState === 1) { // OPEN
+        client.send(message);
+      }
+    }
+  });
+
+  // Ping clients periodically to detect dead connections
+  const pingInterval = setInterval(() => {
+    for (const client of clients) {
+      if (!client.isAlive) {
+        client.terminate();
+        clients.delete(client);
+        continue;
+      }
+      client.isAlive = false;
+      client.ping();
+    }
+  }, 30000);
+
+  wss.on('close', () => {
+    clearInterval(pingInterval);
+  });
+
+  return { clients };
+}