mrmd-server 0.1.0 → 0.1.2

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';
@@ -9,7 +11,10 @@ import { WebSocketServer } from 'ws';
 import path from 'path';
 import fs from 'fs/promises';
 import { existsSync } from 'fs';
-import { fileURLToPath } from 'url';
+import { fileURLToPath, pathToFileURL } from 'url';
+import { createRequire } from 'module';
+
+const require = createRequire(import.meta.url);
 
 import { createAuthMiddleware, generateToken } from './auth.js';
 import { EventBus } from './events.js';
@@ -23,8 +28,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 +89,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 +185,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 +200,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 +217,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 +285,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();
       }
@@ -238,15 +338,26 @@ export async function createServer(config) {
  */
 function findElectronDir(fromDir) {
   const candidates = [
+    // Development: sibling directories
     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
+    // npm/npx: node_modules relative to mrmd-server package
+    path.join(fromDir, '../node_modules/mrmd-electron'),
     path.join(fromDir, '../../node_modules/mrmd-electron'),
+    // npm/npx: node_modules in cwd
     path.join(process.cwd(), 'node_modules/mrmd-electron'),
   ];
 
+  // Also try require.resolve to find the package
+  try {
+    const electronPkg = path.dirname(require.resolve('mrmd-electron/package.json'));
+    candidates.unshift(electronPkg);
+  } catch (e) {
+    // mrmd-electron not found via require, continue with path search
+  }
+
   for (const candidate of candidates) {
     const indexPath = path.join(candidate, 'index.html');
     if (existsSync(indexPath)) {
@@ -261,6 +372,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 +395,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';