mrmd-server 0.1.0

package/src/api/session.js

@@ -0,0 +1,358 @@
+/**
+ * Session API routes
+ *
+ * Mirrors electronAPI.session.*
+ */
+
+import { Router } from 'express';
+import { spawn } from 'child_process';
+import path from 'path';
+import fs from 'fs/promises';
+import net from 'net';
+
+// Session registry: sessionName -> { port, process, venv, cwd }
+const sessions = new Map();
+
+/**
+ * Create session routes
+ * @param {import('../server.js').ServerContext} ctx
+ */
+export function createSessionRoutes(ctx) {
+  const router = Router();
+
+  /**
+   * GET /api/session
+   * List all running sessions
+   * Mirrors: electronAPI.session.list()
+   */
+  router.get('/', async (req, res) => {
+    try {
+      const list = [];
+      for (const [name, session] of sessions) {
+        list.push({
+          name,
+          port: session.port,
+          venv: session.venv,
+          cwd: session.cwd,
+          running: session.process && !session.process.killed,
+        });
+      }
+      res.json(list);
+    } catch (err) {
+      console.error('[session:list]', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  /**
+   * POST /api/session
+   * Start a new session
+   * Mirrors: electronAPI.session.start(config)
+   */
+  router.post('/', async (req, res) => {
+    try {
+      const { config } = req.body;
+      const { name, venv, cwd } = config || {};
+
+      if (!name) {
+        return res.status(400).json({ error: 'config.name required' });
+      }
+
+      // Check if session already exists
+      if (sessions.has(name)) {
+        const existing = sessions.get(name);
+        if (existing.process && !existing.process.killed) {
+          return res.json({
+            name,
+            port: existing.port,
+            venv: existing.venv,
+            cwd: existing.cwd,
+            reused: true,
+          });
+        }
+      }
+
+      // Find free port
+      const port = await findFreePort(8001, 8100);
+
+      // Determine Python path
+      let pythonPath = 'python3';
+      let resolvedVenv = null;
+
+      if (venv) {
+        resolvedVenv = path.resolve(ctx.projectDir, venv);
+        const venvPython = path.join(resolvedVenv, 'bin', 'python');
+        try {
+          await fs.access(venvPython);
+          pythonPath = venvPython;
+        } catch {
+          console.warn(`[session] Venv python not found: ${venvPython}`);
+        }
+      }
+
+      // Start mrmd-python
+      const workDir = cwd ? path.resolve(ctx.projectDir, cwd) : ctx.projectDir;
+
+      // Try to find mrmd-python package
+      const mrmdPythonPaths = [
+        path.join(ctx.projectDir, '../mrmd-python'),
+        path.join(process.cwd(), '../mrmd-python'),
+        path.join(process.cwd(), 'mrmd-python'),
+      ];
+
+      let mrmdPythonPath = null;
+      for (const p of mrmdPythonPaths) {
+        try {
+          await fs.access(path.join(p, 'src', 'mrmd_python'));
+          mrmdPythonPath = p;
+          break;
+        } catch {}
+      }
+
+      let proc;
+      if (mrmdPythonPath) {
+        // Run with uv
+        proc = spawn('uv', [
+          'run', '--project', mrmdPythonPath,
+          'python', '-m', 'mrmd_python.cli',
+          '--port', port.toString(),
+        ], {
+          cwd: workDir,
+          stdio: ['pipe', 'pipe', 'pipe'],
+          env: { ...process.env, PYTHONPATH: path.join(mrmdPythonPath, 'src') },
+        });
+      } else {
+        // Fallback: assume mrmd-python is installed
+        proc = spawn(pythonPath, [
+          '-m', 'mrmd_python.cli',
+          '--port', port.toString(),
+        ], {
+          cwd: workDir,
+          stdio: ['pipe', 'pipe', 'pipe'],
+        });
+      }
+
+      // Wait for server to start
+      await waitForPort(port, 15000);
+
+      sessions.set(name, {
+        port,
+        process: proc,
+        venv: resolvedVenv,
+        cwd: workDir,
+      });
+
+      proc.on('exit', (code) => {
+        console.log(`[session] ${name} exited with code ${code}`);
+        sessions.delete(name);
+      });
+
+      res.json({
+        name,
+        port,
+        venv: resolvedVenv,
+        cwd: workDir,
+        url: `http://localhost:${port}/mrp/v1`,
+      });
+    } catch (err) {
+      console.error('[session:start]', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  /**
+   * DELETE /api/session/:name
+   * Stop a session
+   * Mirrors: electronAPI.session.stop(sessionName)
+   */
+  router.delete('/:name', async (req, res) => {
+    try {
+      const { name } = req.params;
+      const session = sessions.get(name);
+
+      if (!session) {
+        return res.json({ success: true, message: 'Session not found' });
+      }
+
+      if (session.process && !session.process.killed) {
+        session.process.kill();
+      }
+
+      sessions.delete(name);
+      res.json({ success: true });
+    } catch (err) {
+      console.error('[session:stop]', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  /**
+   * POST /api/session/:name/restart
+   * Restart a session
+   * Mirrors: electronAPI.session.restart(sessionName)
+   */
+  router.post('/:name/restart', async (req, res) => {
+    try {
+      const { name } = req.params;
+      const session = sessions.get(name);
+
+      if (!session) {
+        return res.status(404).json({ error: 'Session not found' });
+      }
+
+      // Kill existing
+      if (session.process && !session.process.killed) {
+        session.process.kill();
+      }
+
+      // Re-create with same config
+      req.body.config = { name, venv: session.venv, cwd: session.cwd };
+      sessions.delete(name);
+
+      // Forward to start handler
+      // (In a real implementation, extract the logic to a shared function)
+      return router.handle(req, res, () => {});
+    } catch (err) {
+      console.error('[session:restart]', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  /**
+   * POST /api/session/for-document
+   * Get or create session for a document
+   * Mirrors: electronAPI.session.forDocument(documentPath)
+   */
+  router.post('/for-document', async (req, res) => {
+    try {
+      const { documentPath } = req.body;
+      if (!documentPath) {
+        return res.status(400).json({ error: 'documentPath required' });
+      }
+
+      // Use document name as session name
+      const docName = path.basename(documentPath, '.md');
+
+      // Check if session exists
+      if (sessions.has(docName)) {
+        const session = sessions.get(docName);
+        return res.json({
+          name: docName,
+          port: session.port,
+          venv: session.venv,
+          cwd: session.cwd,
+          url: `http://localhost:${session.port}/mrp/v1`,
+        });
+      }
+
+      // Try to read venv from document frontmatter or project config
+      const fullPath = path.resolve(ctx.projectDir, documentPath);
+      let venv = null;
+
+      try {
+        const content = await fs.readFile(fullPath, 'utf-8');
+        const match = content.match(/^---\n[\s\S]*?venv:\s*(.+?)[\n\r]/m);
+        if (match) {
+          venv = match[1].trim();
+        }
+      } catch {}
+
+      // Create session
+      req.body.config = {
+        name: docName,
+        venv,
+        cwd: path.dirname(fullPath),
+      };
+
+      // Re-use the POST / handler logic
+      // (simplified - in production extract to shared function)
+      const { config } = req.body;
+      const port = await findFreePort(8001, 8100);
+      const workDir = config.cwd || ctx.projectDir;
+
+      // Start with default Python for now
+      const proc = spawn('uv', [
+        'run', 'python', '-m', 'mrmd_python.cli',
+        '--port', port.toString(),
+      ], {
+        cwd: workDir,
+        stdio: ['pipe', 'pipe', 'pipe'],
+      });
+
+      await waitForPort(port, 15000);
+
+      sessions.set(docName, {
+        port,
+        process: proc,
+        venv,
+        cwd: workDir,
+      });
+
+      res.json({
+        name: docName,
+        port,
+        venv,
+        cwd: workDir,
+        url: `http://localhost:${port}/mrp/v1`,
+      });
+    } catch (err) {
+      console.error('[session:forDocument]', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  return router;
+}
+
+/**
+ * Find a free port in range
+ */
+async function findFreePort(start, end) {
+  for (let port = start; port <= end; port++) {
+    if (await isPortFree(port)) {
+      return port;
+    }
+  }
+  throw new Error(`No free port found in range ${start}-${end}`);
+}
+
+/**
+ * Check if port is free
+ */
+function isPortFree(port) {
+  return new Promise((resolve) => {
+    const server = net.createServer();
+    server.once('error', () => resolve(false));
+    server.once('listening', () => {
+      server.close();
+      resolve(true);
+    });
+    server.listen(port, '127.0.0.1');
+  });
+}
+
+/**
+ * Wait for port to be open
+ */
+function waitForPort(port, timeout = 10000) {
+  return new Promise((resolve, reject) => {
+    const start = Date.now();
+
+    function check() {
+      const socket = net.connect(port, '127.0.0.1');
+      socket.once('connect', () => {
+        socket.end();
+        resolve();
+      });
+      socket.once('error', () => {
+        if (Date.now() - start > timeout) {
+          reject(new Error(`Timeout waiting for port ${port}`));
+        } else {
+          setTimeout(check, 200);
+        }
+      });
+    }
+
+    check();
+  });
+}

package/src/api/system.js

@@ -0,0 +1,256 @@
+/**
+ * System API routes
+ *
+ * Mirrors various electronAPI system functions
+ */
+
+import { Router } from 'express';
+import os from 'os';
+import path from 'path';
+import fs from 'fs/promises';
+import { spawn } from 'child_process';
+
+/**
+ * Create system routes
+ * @param {import('../server.js').ServerContext} ctx
+ */
+export function createSystemRoutes(ctx) {
+  const router = Router();
+
+  /**
+   * GET /api/system/home
+   * Get home directory
+   * Mirrors: electronAPI.getHomeDir()
+   */
+  router.get('/home', (req, res) => {
+    res.json({ homeDir: os.homedir() });
+  });
+
+  /**
+   * GET /api/system/recent
+   * Get recent files and venvs
+   * Mirrors: electronAPI.getRecent()
+   */
+  router.get('/recent', async (req, res) => {
+    try {
+      // Try to read from config file
+      const configDir = path.join(os.homedir(), '.config', 'mrmd');
+      const recentPath = path.join(configDir, 'recent.json');
+
+      try {
+        const content = await fs.readFile(recentPath, 'utf-8');
+        res.json(JSON.parse(content));
+      } catch {
+        res.json({ files: [], venvs: [] });
+      }
+    } catch (err) {
+      console.error('[system:recent]', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  /**
+   * POST /api/system/recent
+   * Update recent files/venvs
+   */
+  router.post('/recent', async (req, res) => {
+    try {
+      const { files, venvs } = req.body;
+
+      const configDir = path.join(os.homedir(), '.config', 'mrmd');
+      await fs.mkdir(configDir, { recursive: true });
+
+      const recentPath = path.join(configDir, 'recent.json');
+
+      // Read existing
+      let existing = { files: [], venvs: [] };
+      try {
+        const content = await fs.readFile(recentPath, 'utf-8');
+        existing = JSON.parse(content);
+      } catch {}
+
+      // Merge
+      if (files) {
+        existing.files = [...new Set([...files, ...existing.files])].slice(0, 50);
+      }
+      if (venvs) {
+        existing.venvs = [...new Set([...venvs, ...existing.venvs])].slice(0, 20);
+      }
+
+      await fs.writeFile(recentPath, JSON.stringify(existing, null, 2));
+      res.json(existing);
+    } catch (err) {
+      console.error('[system:recent:update]', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  /**
+   * GET /api/system/ai
+   * Get AI server info
+   * Mirrors: electronAPI.getAi()
+   */
+  router.get('/ai', (req, res) => {
+    res.json({
+      port: ctx.aiPort,
+      url: `http://localhost:${ctx.aiPort}`,
+    });
+  });
+
+  /**
+   * POST /api/system/discover-venvs
+   * Discover virtual environments
+   * Mirrors: electronAPI.discoverVenvs(projectDir)
+   */
+  router.post('/discover-venvs', async (req, res) => {
+    try {
+      const { projectDir } = req.body;
+      const searchDir = projectDir || ctx.projectDir;
+
+      // Start async discovery
+      discoverVenvs(searchDir, ctx.eventBus);
+
+      res.json({ started: true, searchDir });
+    } catch (err) {
+      console.error('[system:discover-venvs]', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  /**
+   * POST /api/system/install-mrmd-python
+   * Install mrmd-python in a venv
+   * Mirrors: electronAPI.installMrmdPython(venvPath)
+   */
+  router.post('/install-mrmd-python', async (req, res) => {
+    try {
+      const { venvPath } = req.body;
+      if (!venvPath) {
+        return res.status(400).json({ error: 'venvPath required' });
+      }
+
+      const resolvedPath = path.resolve(ctx.projectDir, venvPath);
+      const pipPath = path.join(resolvedPath, 'bin', 'pip');
+
+      // Install dependencies
+      const deps = ['ipython', 'starlette', 'uvicorn', 'sse-starlette'];
+
+      const proc = spawn('uv', ['pip', 'install', '--python', path.join(resolvedPath, 'bin', 'python'), ...deps], {
+        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: ${stderr}`));
+        });
+      });
+
+      res.json({ success: true, output: stdout });
+    } catch (err) {
+      console.error('[system:install-mrmd-python]', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  /**
+   * Shell operations (stubs for browser)
+   */
+  router.post('/shell/show-in-folder', (req, res) => {
+    // Can't do this in browser - return the path so UI can display it
+    res.json({
+      success: false,
+      message: 'Not available in browser mode',
+      path: req.body.path,
+    });
+  });
+
+  router.post('/shell/open-external', (req, res) => {
+    // Return URL so browser can window.open() it
+    res.json({
+      success: true,
+      url: req.body.url,
+      action: 'window.open',
+    });
+  });
+
+  router.post('/shell/open-path', (req, res) => {
+    // Can't open local files from browser
+    res.json({
+      success: false,
+      message: 'Not available in browser mode',
+      path: req.body.path,
+    });
+  });
+
+  return router;
+}
+
+/**
+ * Async venv discovery
+ */
+async function discoverVenvs(searchDir, eventBus, maxDepth = 4, currentDepth = 0) {
+  if (currentDepth > maxDepth) return;
+
+  try {
+    const entries = await fs.readdir(searchDir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (entry.name.startsWith('.') && entry.name !== '.venv') continue;
+      if (entry.name === 'node_modules') continue;
+      if (entry.name === '__pycache__') continue;
+
+      const fullPath = path.join(searchDir, entry.name);
+
+      // Check if this is a venv
+      const activatePath = path.join(fullPath, 'bin', 'activate');
+      try {
+        await fs.access(activatePath);
+
+        // Found a venv!
+        const pythonPath = path.join(fullPath, 'bin', 'python');
+        let version = 'unknown';
+
+        try {
+          const proc = spawn(pythonPath, ['--version'], {
+            stdio: ['pipe', 'pipe', 'pipe'],
+          });
+
+          let output = '';
+          proc.stdout.on('data', (data) => { output += data; });
+          proc.stderr.on('data', (data) => { output += data; });
+
+          await new Promise((resolve) => proc.on('close', resolve));
+          version = output.trim().replace('Python ', '');
+        } catch {}
+
+        eventBus.venvFound({
+          path: fullPath,
+          name: entry.name,
+          python: pythonPath,
+          version,
+        });
+
+        // Don't recurse into venvs
+        continue;
+      } catch {}
+
+      // Recurse into directory
+      await discoverVenvs(fullPath, eventBus, maxDepth, currentDepth + 1);
+    }
+  } catch (err) {
+    console.error('[discover-venvs]', err.message);
+  }
+
+  // If this is the root call, emit done
+  if (currentDepth === 0) {
+    eventBus.venvScanDone();
+  }
+}

package/src/auth.js

@@ -0,0 +1,60 @@
+/**
+ * Token-based authentication
+ */
+
+import crypto from 'crypto';
+
+/**
+ * Generate a random token
+ * @returns {string}
+ */
+export function generateToken() {
+  return crypto.randomBytes(24).toString('base64url');
+}
+
+/**
+ * Create authentication middleware
+ * @param {string} validToken - The valid token
+ * @param {boolean} noAuth - If true, skip auth
+ */
+export function createAuthMiddleware(validToken, noAuth = false) {
+  return (req, res, next) => {
+    if (noAuth) {
+      return next();
+    }
+
+    // Check for token in query string, header, or cookie
+    const token =
+      req.query.token ||
+      req.headers.authorization?.replace('Bearer ', '') ||
+      req.headers['x-token'] ||
+      req.cookies?.token;
+
+    if (!token) {
+      return res.status(401).json({
+        error: 'Authentication required',
+        message: 'Provide token via ?token=, Authorization header, or X-Token header',
+      });
+    }
+
+    if (token !== validToken) {
+      return res.status(403).json({
+        error: 'Invalid token',
+      });
+    }
+
+    next();
+  };
+}
+
+/**
+ * Validate token for WebSocket connections
+ * @param {string} providedToken
+ * @param {string} validToken
+ * @param {boolean} noAuth
+ * @returns {boolean}
+ */
+export function validateWsToken(providedToken, validToken, noAuth) {
+  if (noAuth) return true;
+  return providedToken === validToken;
+}