mrmd-server 0.1.0 → 0.1.1

package/src/api/session.js

@@ -1,17 +1,31 @@
 /**
  * Session API routes
  *
- * Mirrors electronAPI.session.*
+ * Mirrors electronAPI.session.* using SessionService from mrmd-electron
  */
 
 import { Router } from 'express';
-import { spawn } from 'child_process';
+import { Project } from 'mrmd-project';
+import fs from 'fs';
 import path from 'path';
-import fs from 'fs/promises';
-import net from 'net';
 
-// Session registry: sessionName -> { port, process, venv, cwd }
-const sessions = new Map();
+/**
+ * Detect project from a file path
+ * Returns { root, config } or null if not in a project
+ */
+function detectProject(filePath) {
+  const root = Project.findRoot(filePath, (dir) => fs.existsSync(path.join(dir, 'mrmd.md')));
+  if (!root) return null;
+
+  try {
+    const mrmdPath = path.join(root, 'mrmd.md');
+    const content = fs.readFileSync(mrmdPath, 'utf8');
+    const config = Project.parseConfig(content);
+    return { root, config };
+  } catch (e) {
+    return { root, config: {} };
+  }
+}
 
 /**
  * Create session routes
@@ -19,6 +33,7 @@ const sessions = new Map();
  */
 export function createSessionRoutes(ctx) {
   const router = Router();
+  const { sessionService } = ctx;
 
   /**
    * GET /api/session
@@ -27,16 +42,7 @@ export function createSessionRoutes(ctx) {
    */
   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,
-        });
-      }
+      const list = sessionService.list();
       res.json(list);
     } catch (err) {
       console.error('[session:list]', err);
@@ -52,107 +58,21 @@ export function createSessionRoutes(ctx) {
   router.post('/', async (req, res) => {
     try {
       const { config } = req.body;
-      const { name, venv, cwd } = config || {};
 
-      if (!name) {
+      if (!config?.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);
-      });
+      const result = await sessionService.start(config);
 
+      // Return in expected format
       res.json({
-        name,
-        port,
-        venv: resolvedVenv,
-        cwd: workDir,
-        url: `http://localhost:${port}/mrp/v1`,
+        name: result.name,
+        port: result.port,
+        venv: result.venv,
+        cwd: result.cwd,
+        pid: result.pid,
+        url: `http://localhost:${result.port}/mrp/v1`,
       });
     } catch (err) {
       console.error('[session:start]', err);
@@ -168,21 +88,12 @@ export function createSessionRoutes(ctx) {
   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);
+      await sessionService.stop(name);
       res.json({ success: true });
     } catch (err) {
       console.error('[session:stop]', err);
-      res.status(500).json({ error: err.message });
+      // Even if session not found, return success (idempotent)
+      res.json({ success: true, message: err.message });
     }
   });
 
@@ -194,24 +105,16 @@ export function createSessionRoutes(ctx) {
   router.post('/:name/restart', async (req, res) => {
     try {
       const { name } = req.params;
-      const session = sessions.get(name);
+      const result = await sessionService.restart(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, () => {});
+      res.json({
+        name: result.name,
+        port: result.port,
+        venv: result.venv,
+        cwd: result.cwd,
+        pid: result.pid,
+        url: `http://localhost:${result.port}/mrp/v1`,
+      });
     } catch (err) {
       console.error('[session:restart]', err);
       res.status(500).json({ error: err.message });
@@ -222,137 +125,79 @@ export function createSessionRoutes(ctx) {
    * POST /api/session/for-document
    * Get or create session for a document
    * Mirrors: electronAPI.session.forDocument(documentPath)
+   *
+   * Automatically detects project if projectConfig/projectRoot not provided
    */
   router.post('/for-document', async (req, res) => {
     try {
-      const { documentPath } = req.body;
+      let { documentPath, projectConfig, frontmatter, projectRoot } = 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`,
-        });
+      // Auto-detect project if not provided
+      if (!projectConfig || !projectRoot) {
+        const detected = detectProject(documentPath);
+        if (detected) {
+          projectRoot = projectRoot || detected.root;
+          projectConfig = projectConfig || detected.config;
+        } else {
+          projectRoot = projectRoot || (ctx.projectDir || process.cwd());
+          projectConfig = projectConfig || {};
+        }
       }
 
-      // 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();
+      // Auto-parse frontmatter if not provided
+      if (!frontmatter) {
+        try {
+          const content = fs.readFileSync(documentPath, 'utf8');
+          frontmatter = Project.parseFrontmatter(content);
+        } catch (e) {
+          frontmatter = null;
         }
-      } 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);
+      const result = await sessionService.getForDocument(
+        documentPath,
+        projectConfig,
+        frontmatter,
+        projectRoot
+      );
 
-      sessions.set(docName, {
-        port,
-        process: proc,
-        venv,
-        cwd: workDir,
-      });
+      // Add url if we have a port
+      if (result?.port) {
+        result.url = `http://localhost:${result.port}/mrp/v1`;
+      }
 
-      res.json({
-        name: docName,
-        port,
-        venv,
-        cwd: workDir,
-        url: `http://localhost:${port}/mrp/v1`,
-      });
+      res.json(result);
     } catch (err) {
       console.error('[session:forDocument]', err);
-      res.status(500).json({ error: err.message });
+      // Return null on error (non-blocking - editor works without Python)
+      res.json(null);
     }
   });
 
-  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');
-  });
-}
+  /**
+   * POST /api/session/attach
+   * Attach to an existing session
+   * Mirrors: electronAPI.session.attach(sessionName)
+   */
+  router.post('/attach', async (req, res) => {
+    try {
+      const { sessionName } = req.body;
 
-/**
- * Wait for port to be open
- */
-function waitForPort(port, timeout = 10000) {
-  return new Promise((resolve, reject) => {
-    const start = Date.now();
+      if (!sessionName) {
+        return res.status(400).json({ error: 'sessionName required' });
+      }
 
-    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);
-        }
-      });
+      const result = sessionService.attach(sessionName);
+      res.json(result);
+    } catch (err) {
+      console.error('[session:attach]', err);
+      res.status(500).json({ error: err.message });
     }
-
-    check();
   });
+
+  return router;
 }