mrmd-server 0.1.0 → 0.1.1

package/src/api/system.js

@@ -8,7 +8,8 @@ import { Router } from 'express';
 import os from 'os';
 import path from 'path';
 import fs from 'fs/promises';
-import { spawn } from 'child_process';
+import { existsSync } from 'fs';
+import { spawn, execSync } from 'child_process';
 
 /**
  * Create system routes
@@ -26,6 +27,105 @@ export function createSystemRoutes(ctx) {
     res.json({ homeDir: os.homedir() });
   });
 
+  /**
+   * GET /api/system/info
+   * Get system and app info including uv status
+   * Mirrors: electronAPI.system.info()
+   */
+  router.get('/info', async (req, res) => {
+    try {
+      // Check uv availability
+      let uvInfo = { installed: false };
+      try {
+        const uvVersion = execSync('uv --version', { encoding: 'utf-8' }).trim();
+        const uvPath = execSync('which uv', { encoding: 'utf-8' }).trim();
+        uvInfo = {
+          installed: true,
+          version: uvVersion.replace('uv ', ''),
+          path: uvPath,
+        };
+      } catch {}
+
+      // Get Node.js version
+      const nodeVersion = process.version;
+
+      res.json({
+        appVersion: '0.1.0',
+        platform: os.platform(),
+        arch: os.arch(),
+        nodeVersion,
+        pythonDeps: ['ipython', 'starlette', 'uvicorn', 'sse-starlette'],
+        uv: uvInfo,
+        serverMode: true, // Indicates this is running in server mode, not Electron
+      });
+    } catch (err) {
+      console.error('[system:info]', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  /**
+   * POST /api/system/ensure-uv
+   * Ensure uv is installed (auto-install if missing)
+   * Mirrors: electronAPI.system.ensureUv()
+   */
+  router.post('/ensure-uv', async (req, res) => {
+    try {
+      // Check if uv is already installed
+      try {
+        const uvVersion = execSync('uv --version', { encoding: 'utf-8' }).trim();
+        const uvPath = execSync('which uv', { encoding: 'utf-8' }).trim();
+        return res.json({
+          success: true,
+          path: uvPath,
+          version: uvVersion.replace('uv ', ''),
+          alreadyInstalled: true,
+        });
+      } catch {}
+
+      // Try to install uv using the official installer
+      const installScript = 'curl -LsSf https://astral.sh/uv/install.sh | sh';
+
+      const proc = spawn('sh', ['-c', installScript], {
+        stdio: ['pipe', 'pipe', 'pipe'],
+      });
+
+      let stdout = '';
+      let stderr = '';
+
+      proc.stdout.on('data', (data) => { stdout += data; });
+      proc.stderr.on('data', (data) => { stderr += data; });
+
+      await new Promise((resolve, reject) => {
+        proc.on('close', (code) => {
+          if (code === 0) resolve();
+          else reject(new Error(`Install failed with code ${code}: ${stderr}`));
+        });
+      });
+
+      // Verify installation
+      const uvPath = path.join(os.homedir(), '.local', 'bin', 'uv');
+      if (existsSync(uvPath)) {
+        try {
+          const uvVersion = execSync(`${uvPath} --version`, { encoding: 'utf-8' }).trim();
+          return res.json({
+            success: true,
+            path: uvPath,
+            version: uvVersion.replace('uv ', ''),
+          });
+        } catch {}
+      }
+
+      res.json({
+        success: false,
+        error: 'Installation completed but uv not found',
+      });
+    } catch (err) {
+      console.error('[system:ensureUv]', err);
+      res.status(500).json({ success: false, error: err.message });
+    }
+  });
+
   /**
    * GET /api/system/recent
    * Get recent files and venvs
@@ -117,6 +217,104 @@ export function createSystemRoutes(ctx) {
     }
   });
 
+  /**
+   * POST /api/system/create-venv
+   * Create a new Python virtual environment
+   * Mirrors: electronAPI.createVenv(venvPath)
+   */
+  router.post('/create-venv', async (req, res) => {
+    try {
+      const { venvPath } = req.body;
+      if (!venvPath) {
+        return res.status(400).json({ error: 'venvPath required' });
+      }
+
+      const resolvedPath = path.resolve(venvPath);
+
+      // Check if venv already exists
+      if (existsSync(path.join(resolvedPath, 'bin', 'activate'))) {
+        return res.json({
+          success: true,
+          path: resolvedPath,
+          message: 'Virtual environment already exists',
+        });
+      }
+
+      // Create parent directory if needed
+      await fs.mkdir(path.dirname(resolvedPath), { recursive: true });
+
+      // Try uv first (faster)
+      let uvPath = null;
+      try {
+        uvPath = execSync('which uv', { encoding: 'utf-8' }).trim();
+      } catch {
+        // Check common locations
+        const uvLocations = [
+          path.join(os.homedir(), '.local', 'bin', 'uv'),
+          '/usr/local/bin/uv',
+          '/usr/bin/uv',
+        ];
+        for (const loc of uvLocations) {
+          if (existsSync(loc)) {
+            uvPath = loc;
+            break;
+          }
+        }
+      }
+
+      if (uvPath) {
+        // Use uv to create venv
+        const proc = spawn(uvPath, ['venv', resolvedPath], {
+          stdio: ['pipe', 'pipe', 'pipe'],
+        });
+
+        let stderr = '';
+        proc.stderr.on('data', (data) => { stderr += data; });
+
+        await new Promise((resolve, reject) => {
+          proc.on('close', (code) => {
+            if (code === 0) resolve();
+            else reject(new Error(`uv venv failed: ${stderr}`));
+          });
+          proc.on('error', reject);
+        });
+      } else {
+        // Fallback to python3 -m venv
+        const proc = spawn('python3', ['-m', 'venv', resolvedPath], {
+          stdio: ['pipe', 'pipe', 'pipe'],
+        });
+
+        let stderr = '';
+        proc.stderr.on('data', (data) => { stderr += data; });
+
+        await new Promise((resolve, reject) => {
+          proc.on('close', (code) => {
+            if (code === 0) resolve();
+            else reject(new Error(`python3 -m venv failed (code ${code}): ${stderr}`));
+          });
+          proc.on('error', reject);
+        });
+      }
+
+      // Verify creation
+      if (existsSync(path.join(resolvedPath, 'bin', 'activate'))) {
+        res.json({
+          success: true,
+          path: resolvedPath,
+          method: uvPath ? 'uv' : 'python3',
+        });
+      } else {
+        res.status(500).json({
+          success: false,
+          error: 'Virtual environment creation completed but activation script not found',
+        });
+      }
+    } catch (err) {
+      console.error('[system:create-venv]', err);
+      res.status(500).json({ success: false, error: err.message });
+    }
+  });
+
   /**
    * POST /api/system/install-mrmd-python
    * Install mrmd-python in a venv

package/src/server.js

@@ -1,5 +1,7 @@
 /**
  * Express server that mirrors Electron's electronAPI
+ *
+ * Uses services from mrmd-electron for full feature parity.
  */
 
 import express from 'express';
@@ -23,8 +25,33 @@ 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 { createSettingsRoutes } from './api/settings.js';
+import { createRRoutes } from './api/r.js';
 import { setupWebSocket } from './websocket.js';
 
+// Import services from mrmd-electron (pure Node.js, no Electron deps)
+import {
+  ProjectService,
+  SessionService,
+  BashSessionService,
+  RSessionService,
+  JuliaSessionService,
+  PtySessionService,
+  FileService,
+  AssetService,
+  SettingsService,
+} from './services.js';
+
+// Import sync manager for dynamic project handling
+import {
+  acquireSyncServer,
+  releaseSyncServer,
+  getSyncServer,
+  listSyncServers,
+  stopAllSyncServers,
+  onSyncDeath,
+} from './sync-manager.js';
+
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
 /**
@@ -59,28 +86,65 @@ export async function createServer(config) {
     aiPort = 51790,
   } = config;
 
+  // projectDir is optional now - dynamic project detection is supported
   if (!projectDir) {
-    throw new Error('projectDir is required');
+    console.log('[server] No projectDir specified - dynamic project detection enabled');
   }
 
   const app = express();
   const server = createHttpServer(app);
   const eventBus = new EventBus();
 
+  // Instantiate services from mrmd-electron
+  const projectService = new ProjectService();
+  const sessionService = new SessionService();
+  const bashSessionService = new BashSessionService();
+  const rSessionService = new RSessionService();
+  const juliaSessionService = new JuliaSessionService();
+  const ptySessionService = new PtySessionService();
+  const fileService = new FileService();
+  const assetService = new AssetService();
+  const settingsService = new SettingsService();
+
   // Service context passed to all route handlers
   const context = {
-    projectDir: path.resolve(projectDir),
+    // Legacy: fixed project dir (for backwards compat, may be null)
+    projectDir: projectDir ? path.resolve(projectDir) : null,
     syncPort,
     pythonPort,
     aiPort,
     eventBus,
-    // These will be populated by services
+
+    // Services from mrmd-electron
+    projectService,
+    sessionService,
+    bashSessionService,
+    rSessionService,
+    juliaSessionService,
+    ptySessionService,
+    fileService,
+    assetService,
+    settingsService,
+
+    // Sync server management (dynamic per-project)
+    acquireSyncServer,
+    releaseSyncServer,
+    getSyncServer,
+    listSyncServers,
+
+    // Legacy: process tracking (kept for backwards compat)
     syncProcess: null,
     pythonProcess: null,
     monitorProcesses: new Map(),
     watchers: new Map(),
+    pythonReady: false,
   };
 
+  // Register for sync death notifications and broadcast via WebSocket
+  onSyncDeath((message) => {
+    eventBus.emit('sync-server-died', message);
+  });
+
   // Middleware
   app.use(cors({
     origin: true,
@@ -118,6 +182,8 @@ export async function createServer(config) {
   app.use('/api/julia', createJuliaRoutes(context));
   app.use('/api/pty', createPtyRoutes(context));
   app.use('/api/notebook', createNotebookRoutes(context));
+  app.use('/api/settings', createSettingsRoutes(context));
+  app.use('/api/r', createRRoutes(context));
 
   // Serve http-shim.js
   app.get('/http-shim.js', (req, res) => {
@@ -131,9 +197,13 @@ export async function createServer(config) {
     // Serve mrmd-electron assets (fonts, icons)
     app.use('/assets', express.static(path.join(electronPath, 'assets')));
 
-    // Serve mrmd-editor dist
+    // Serve mrmd-editor dist (referenced as ../mrmd-editor/dist/ in index.html)
     const editorDistPath = path.join(electronPath, '../mrmd-editor/dist');
-    app.use('/dist', express.static(editorDistPath));
+    app.use('/mrmd-editor/dist', express.static(editorDistPath));
+    app.use('/dist', express.static(editorDistPath)); // Also at /dist for compatibility
+
+    // Serve node_modules from mrmd-electron (for xterm, etc.)
+    app.use('/node_modules', express.static(path.join(electronPath, 'node_modules')));
 
     // Serve transformed index.html at root
     app.get('/', async (req, res) => {
@@ -144,6 +214,7 @@ export async function createServer(config) {
         // Transform for browser mode:
         // 1. Inject http-shim.js as first script in head
         // 2. Update CSP to allow HTTP connections to this server
+        // 3. Fix relative paths for HTTP serving
         html = transformIndexHtml(html, host, port);
 
         res.type('html').send(html);
@@ -211,7 +282,33 @@ export async function createServer(config) {
         await watcher.close();
       }
 
-      // Kill child processes
+      // Stop all sync servers
+      stopAllSyncServers();
+
+      // Stop all sessions via services (if they have shutdown methods)
+      try {
+        if (typeof sessionService.shutdown === 'function') {
+          await sessionService.shutdown();
+        }
+      } catch (e) {
+        console.warn('[server] Error stopping sessions:', e.message);
+      }
+      try {
+        if (typeof bashSessionService.shutdown === 'function') {
+          await bashSessionService.shutdown();
+        }
+      } catch (e) {
+        console.warn('[server] Error stopping bash sessions:', e.message);
+      }
+      try {
+        if (typeof ptySessionService.shutdown === 'function') {
+          await ptySessionService.shutdown();
+        }
+      } catch (e) {
+        console.warn('[server] Error stopping pty sessions:', e.message);
+      }
+
+      // Legacy: kill child processes
       if (context.syncProcess) {
         context.syncProcess.kill();
       }
@@ -261,6 +358,7 @@ function findElectronDir(fromDir) {
  * Transform index.html for browser mode
  * - Inject http-shim.js as first script
  * - Update CSP to allow HTTP connections
+ * - Fix relative paths for HTTP serving
  */
 function transformIndexHtml(html, host, port) {
   // 1. Inject http-shim.js right after <head>
@@ -283,6 +381,19 @@ function transformIndexHtml(html, host, port) {
   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; */');
 
+  // 4. Fix relative paths for HTTP serving
+  // ../mrmd-editor/dist/ -> /mrmd-editor/dist/
+  html = html.replace(/src=["']\.\.\/mrmd-editor\//g, 'src="/mrmd-editor/');
+  html = html.replace(/href=["']\.\.\/mrmd-editor\//g, 'href="/mrmd-editor/');
+
+  // ./node_modules/ -> /node_modules/
+  html = html.replace(/src=["']\.\/node_modules\//g, 'src="/node_modules/');
+  html = html.replace(/href=["']\.\/node_modules\//g, 'href="/node_modules/');
+
+  // ./assets/ -> /assets/
+  html = html.replace(/src=["']\.\/assets\//g, 'src="/assets/');
+  html = html.replace(/href=["']\.\/assets\//g, 'href="/assets/');
+
   return html;
 }
 

package/src/services.js

@@ -0,0 +1,42 @@
+/**
+ * Re-export services from mrmd-electron
+ *
+ * These services are pure Node.js (no Electron dependencies)
+ * and can be used directly by mrmd-server.
+ */
+
+export {
+  default as ProjectService,
+} from 'mrmd-electron/src/services/project-service.js';
+
+export {
+  default as SessionService,
+} from 'mrmd-electron/src/services/session-service.js';
+
+export {
+  default as BashSessionService,
+} from 'mrmd-electron/src/services/bash-session-service.js';
+
+export {
+  default as RSessionService,
+} from 'mrmd-electron/src/services/r-session-service.js';
+
+export {
+  default as JuliaSessionService,
+} from 'mrmd-electron/src/services/julia-session-service.js';
+
+export {
+  default as PtySessionService,
+} from 'mrmd-electron/src/services/pty-session-service.js';
+
+export {
+  default as FileService,
+} from 'mrmd-electron/src/services/file-service.js';
+
+export {
+  default as AssetService,
+} from 'mrmd-electron/src/services/asset-service.js';
+
+export {
+  default as SettingsService,
+} from 'mrmd-electron/src/services/settings-service.js';

package/src/sync-manager.js

@@ -0,0 +1,223 @@
+/**
+ * Sync Server Manager for mrmd-server
+ *
+ * Ported from mrmd-electron/main.js to provide dynamic per-project sync servers.
+ * Allows mrmd-server to handle files from any project, not just a fixed projectDir.
+ */
+
+import { spawn } from 'child_process';
+import crypto from 'crypto';
+import path from 'path';
+import fs from 'fs';
+import os from 'os';
+import { fileURLToPath } from 'url';
+
+// Import utilities from mrmd-electron
+import { findFreePort, waitForPort, isProcessAlive } from 'mrmd-electron/src/utils/index.js';
+import { SYNC_SERVER_MEMORY_MB, DIR_HASH_LENGTH } from 'mrmd-electron/src/config.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Track active sync servers by directory hash
+const syncServers = new Map();
+
+// Event listeners for sync death notifications
+const syncDeathListeners = new Set();
+
+/**
+ * Hash a directory path to a short, filesystem-safe string
+ */
+function computeDirHash(dir) {
+  return crypto.createHash('sha256').update(path.resolve(dir)).digest('hex').slice(0, DIR_HASH_LENGTH);
+}
+
+/**
+ * Resolve the path to an mrmd package's CLI script
+ * In dev mode: Returns path to source CLI in sibling directory
+ */
+function resolvePackageBin(packageName, binPath) {
+  // Try sibling directory (for monorepo development)
+  const siblingPath = path.join(path.dirname(path.dirname(__dirname)), packageName, binPath);
+  if (fs.existsSync(siblingPath)) {
+    return siblingPath;
+  }
+
+  // Try node_modules
+  try {
+    const packageJson = path.dirname(require.resolve(`${packageName}/package.json`));
+    return path.join(packageJson, binPath);
+  } catch (e) {
+    // Fallback for ESM - look relative to mrmd-server
+    const nmPath = path.join(__dirname, '..', 'node_modules', packageName, binPath);
+    if (fs.existsSync(nmPath)) {
+      return nmPath;
+    }
+    throw new Error(`Cannot resolve ${packageName}: ${e.message}`);
+  }
+}
+
+/**
+ * Notify all registered listeners that a sync server died
+ */
+function notifySyncDied(projectDir, exitCode, signal) {
+  const message = {
+    projectDir,
+    exitCode,
+    signal,
+    timestamp: new Date().toISOString(),
+    reason: exitCode === null ? 'crashed (likely OOM)' : `exited with code ${exitCode}`,
+  };
+
+  console.error(`[sync] CRITICAL: Sync server died for ${projectDir}:`, message.reason);
+
+  for (const listener of syncDeathListeners) {
+    try {
+      listener(message);
+    } catch (e) {
+      console.error('[sync] Error in death listener:', e);
+    }
+  }
+}
+
+/**
+ * Register a listener to be notified when any sync server dies
+ * @param {Function} listener - Called with {projectDir, exitCode, signal, timestamp, reason}
+ * @returns {Function} Unsubscribe function
+ */
+export function onSyncDeath(listener) {
+  syncDeathListeners.add(listener);
+  return () => syncDeathListeners.delete(listener);
+}
+
+/**
+ * Get or start a sync server for a project directory
+ * Uses reference counting so multiple documents can share a sync server
+ *
+ * @param {string} projectDir - The project directory to sync
+ * @returns {Promise<{port: number, dir: string, refCount: number}>}
+ */
+export async function acquireSyncServer(projectDir) {
+  const dirHash = computeDirHash(projectDir);
+
+  // Reuse existing server if available
+  if (syncServers.has(dirHash)) {
+    const server = syncServers.get(dirHash);
+    server.refCount++;
+    console.log(`[sync] Reusing server for ${projectDir} on port ${server.port} (refCount: ${server.refCount})`);
+    return server;
+  }
+
+  // Check for existing server from a PID file (in case of restart)
+  const syncStatePath = path.join(os.tmpdir(), `mrmd-sync-${dirHash}`, 'server.pid');
+  try {
+    if (fs.existsSync(syncStatePath)) {
+      const pidData = JSON.parse(fs.readFileSync(syncStatePath, 'utf8'));
+      if (isProcessAlive(pidData.pid)) {
+        console.log(`[sync] Found existing server on port ${pidData.port}`);
+        const server = { proc: null, port: pidData.port, dir: projectDir, refCount: 1, owned: false };
+        syncServers.set(dirHash, server);
+        return server;
+      } else {
+        fs.unlinkSync(syncStatePath);
+      }
+    }
+  } catch (e) {
+    // Ignore errors reading PID file
+  }
+
+  // Start a new sync server
+  const port = await findFreePort();
+  console.log(`[sync] Starting server for ${projectDir} on port ${port}...`);
+
+  const syncCliPath = resolvePackageBin('mrmd-sync', 'bin/cli.js');
+  const nodeArgs = [
+    `--max-old-space-size=${SYNC_SERVER_MEMORY_MB}`,
+    syncCliPath,
+    '--port', port.toString(),
+    '--i-know-what-i-am-doing',
+    projectDir,
+  ];
+
+  const proc = spawn('node', nodeArgs, { stdio: ['pipe', 'pipe', 'pipe'] });
+  proc.expectedExit = false;
+
+  proc.stdout.on('data', (d) => console.log(`[sync:${port}]`, d.toString().trim()));
+  proc.stderr.on('data', (d) => console.error(`[sync:${port}]`, d.toString().trim()));
+
+  // Handle unexpected exits (data loss prevention)
+  proc.on('exit', (code, signal) => {
+    console.log(`[sync:${port}] Exited with code ${code}, signal ${signal}`);
+    syncServers.delete(dirHash);
+
+    if (!proc.expectedExit) {
+      notifySyncDied(projectDir, code, signal);
+    }
+  });
+
+  await waitForPort(port);
+
+  const server = { proc, port, dir: projectDir, refCount: 1, owned: true };
+  syncServers.set(dirHash, server);
+  return server;
+}
+
+/**
+ * Release a sync server reference
+ * If refCount reaches 0, the server is stopped
+ *
+ * @param {string} projectDir - The project directory
+ */
+export function releaseSyncServer(projectDir) {
+  const dirHash = computeDirHash(projectDir);
+  const server = syncServers.get(dirHash);
+  if (!server) return;
+
+  server.refCount--;
+  console.log(`[sync] Released server for ${projectDir} (refCount: ${server.refCount})`);
+
+  if (server.refCount <= 0 && server.owned && server.proc) {
+    console.log(`[sync] Stopping server for ${projectDir}`);
+    server.proc.expectedExit = true;
+    server.proc.kill('SIGTERM');
+    syncServers.delete(dirHash);
+  }
+}
+
+/**
+ * Get the sync server for a project if one is running
+ *
+ * @param {string} projectDir - The project directory
+ * @returns {Object|null} The server info or null
+ */
+export function getSyncServer(projectDir) {
+  const dirHash = computeDirHash(projectDir);
+  return syncServers.get(dirHash) || null;
+}
+
+/**
+ * List all active sync servers
+ * @returns {Array<{dir: string, port: number, refCount: number, owned: boolean}>}
+ */
+export function listSyncServers() {
+  return Array.from(syncServers.values()).map(s => ({
+    dir: s.dir,
+    port: s.port,
+    refCount: s.refCount,
+    owned: s.owned,
+  }));
+}
+
+/**
+ * Stop all sync servers (for shutdown)
+ */
+export function stopAllSyncServers() {
+  for (const [hash, server] of syncServers) {
+    if (server.owned && server.proc) {
+      console.log(`[sync] Stopping server for ${server.dir}`);
+      server.proc.expectedExit = true;
+      server.proc.kill('SIGTERM');
+    }
+  }
+  syncServers.clear();
+}