mrmd-server 0.1.0 → 0.1.2

package/src/api/pty.js

@@ -1,17 +1,30 @@
 /**
  * PTY Session API routes (for ```term blocks)
  *
- * Mirrors electronAPI.pty.*
+ * Mirrors electronAPI.pty.* using PtySessionService 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, cwd, venv, wsUrl }
-const sessions = new Map();
+/**
+ * Detect project from a file path
+ */
+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 PTY routes
@@ -19,6 +32,7 @@ const sessions = new Map();
  */
 export function createPtyRoutes(ctx) {
   const router = Router();
+  const { ptySessionService } = ctx;
 
   /**
    * GET /api/pty
@@ -27,17 +41,7 @@ export function createPtyRoutes(ctx) {
    */
   router.get('/', async (req, res) => {
     try {
-      const list = [];
-      for (const [name, session] of sessions) {
-        list.push({
-          name,
-          port: session.port,
-          cwd: session.cwd,
-          venv: session.venv,
-          wsUrl: session.wsUrl,
-          running: session.process && !session.process.killed,
-        });
-      }
+      const list = ptySessionService.list();
       res.json(list);
     } catch (err) {
       console.error('[pty:list]', err);
@@ -53,113 +57,21 @@ export function createPtyRoutes(ctx) {
   router.post('/', async (req, res) => {
     try {
       const { config } = req.body;
-      const { name, cwd, venv } = 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,
-            cwd: existing.cwd,
-            venv: existing.venv,
-            wsUrl: existing.wsUrl,
-            reused: true,
-            alive: true,
-          });
-        }
-      }
-
-      // Find free port
-      const port = await findFreePort(7001, 7100);
-      const workDir = cwd ? path.resolve(ctx.projectDir, cwd) : ctx.projectDir;
-
-      // Find mrmd-pty package
-      const mrmdPtyPaths = [
-        path.join(ctx.projectDir, '../mrmd-pty'),
-        path.join(process.cwd(), '../mrmd-pty'),
-        path.join(process.cwd(), 'mrmd-pty'),
-        path.join(__dirname, '../../../mrmd-pty'),
-      ];
-
-      let mrmdPtyPath = null;
-      for (const p of mrmdPtyPaths) {
-        try {
-          await fs.access(path.join(p, 'package.json'));
-          mrmdPtyPath = p;
-          break;
-        } catch {}
-      }
-
-      let proc;
-      const env = { ...process.env };
-
-      // If venv specified, activate it
-      if (venv) {
-        const venvPath = path.resolve(ctx.projectDir, venv);
-        env.VIRTUAL_ENV = venvPath;
-        env.PATH = `${path.join(venvPath, 'bin')}:${env.PATH}`;
-      }
-
-      if (mrmdPtyPath) {
-        // Run mrmd-pty server
-        proc = spawn('node', [
-          path.join(mrmdPtyPath, 'src', 'server.js'),
-          '--port', port.toString(),
-          '--cwd', workDir,
-        ], {
-          cwd: workDir,
-          stdio: ['pipe', 'pipe', 'pipe'],
-          env,
-        });
-      } else {
-        // Fallback: Try to use npx
-        proc = spawn('npx', [
-          'mrmd-pty',
-          '--port', port.toString(),
-          '--cwd', workDir,
-        ], {
-          cwd: workDir,
-          stdio: ['pipe', 'pipe', 'pipe'],
-          env,
-        });
-      }
-
-      // Wait for server to start
-      try {
-        await waitForPort(port, 10000);
-      } catch (err) {
-        proc.kill();
-        return res.status(500).json({ error: `PTY server failed to start: ${err.message}` });
-      }
-
-      const wsUrl = `ws://localhost:${port}`;
-
-      sessions.set(name, {
-        port,
-        process: proc,
-        cwd: workDir,
-        venv,
-        wsUrl,
-      });
-
-      proc.on('exit', (code) => {
-        console.log(`[pty] ${name} exited with code ${code}`);
-        sessions.delete(name);
-      });
+      const result = await ptySessionService.start(config);
 
       res.json({
-        name,
-        port,
-        cwd: workDir,
-        venv,
-        wsUrl,
-        alive: true,
+        name: result.name,
+        port: result.port,
+        cwd: result.cwd,
+        venv: result.venv,
+        pid: result.pid,
+        wsUrl: `ws://localhost:${result.port}`,
+        alive: result.alive,
       });
     } catch (err) {
       console.error('[pty:start]', err);
@@ -175,21 +87,11 @@ export function createPtyRoutes(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 ptySessionService.stop(name);
       res.json({ success: true });
     } catch (err) {
       console.error('[pty:stop]', err);
-      res.status(500).json({ error: err.message });
+      res.json({ success: true, message: err.message });
     }
   });
 
@@ -201,25 +103,17 @@ export function createPtyRoutes(ctx) {
   router.post('/:name/restart', async (req, res) => {
     try {
       const { name } = req.params;
-      const session = sessions.get(name);
+      const result = await ptySessionService.restart(name);
 
-      if (!session) {
-        return res.status(404).json({ error: 'Session not found' });
-      }
-
-      const { cwd, venv } = session;
-
-      // Kill existing
-      if (session.process && !session.process.killed) {
-        session.process.kill();
-      }
-
-      sessions.delete(name);
-
-      // Create new session
-      req.body.config = { name, cwd, venv };
-      // Redirect to POST /
-      return res.redirect(307, '/api/pty');
+      res.json({
+        name: result.name,
+        port: result.port,
+        cwd: result.cwd,
+        venv: result.venv,
+        pid: result.pid,
+        wsUrl: `ws://localhost:${result.port}`,
+        alive: result.alive,
+      });
     } catch (err) {
       console.error('[pty:restart]', err);
       res.status(500).json({ error: err.message });
@@ -231,171 +125,57 @@ export function createPtyRoutes(ctx) {
    * Get or create PTY session for a document
    * Returns session info including wsUrl for WebSocket connection
    * Mirrors: electronAPI.pty.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' });
       }
 
-      const docName = `pty-${path.basename(documentPath, '.md')}`;
-
-      // Check if session exists
-      if (sessions.has(docName)) {
-        const session = sessions.get(docName);
-        const alive = session.process && !session.process.killed;
-        return res.json({
-          name: docName,
-          port: session.port,
-          cwd: session.cwd,
-          venv: session.venv,
-          wsUrl: session.wsUrl,
-          alive,
-        });
-      }
-
-      // Try to read venv from document frontmatter
-      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-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 || {};
         }
-      } catch {}
-
-      // Create session
-      const port = await findFreePort(7001, 7100);
-      const workDir = path.dirname(fullPath);
-      const env = { ...process.env };
-
-      if (venv) {
-        const venvPath = path.resolve(ctx.projectDir, venv);
-        env.VIRTUAL_ENV = venvPath;
-        env.PATH = `${path.join(venvPath, 'bin')}:${env.PATH}`;
       }
 
-      // Try to start mrmd-pty
-      const mrmdPtyPaths = [
-        path.join(ctx.projectDir, '../mrmd-pty'),
-        path.join(process.cwd(), '../mrmd-pty'),
-      ];
-
-      let mrmdPtyPath = null;
-      for (const p of mrmdPtyPaths) {
+      // Auto-parse frontmatter if not provided
+      if (!frontmatter) {
         try {
-          await fs.access(path.join(p, 'package.json'));
-          mrmdPtyPath = p;
-          break;
-        } catch {}
+          const content = fs.readFileSync(documentPath, 'utf8');
+          frontmatter = Project.parseFrontmatter(content);
+        } catch (e) {
+          frontmatter = null;
+        }
       }
 
-      let proc;
-      if (mrmdPtyPath) {
-        proc = spawn('node', [
-          path.join(mrmdPtyPath, 'src', 'server.js'),
-          '--port', port.toString(),
-          '--cwd', workDir,
-        ], {
-          cwd: workDir,
-          stdio: ['pipe', 'pipe', 'pipe'],
-          env,
-        });
-      } else {
-        // mrmd-pty not found, return null
-        return res.json(null);
-      }
+      const result = await ptySessionService.getForDocument(
+        documentPath,
+        projectConfig,
+        frontmatter,
+        projectRoot
+      );
 
-      try {
-        await waitForPort(port, 10000);
-      } catch (err) {
-        proc.kill();
-        return res.json(null);
+      // Add wsUrl if we have a port
+      if (result?.port) {
+        result.wsUrl = `ws://localhost:${result.port}`;
       }
 
-      const wsUrl = `ws://localhost:${port}`;
-
-      sessions.set(docName, {
-        port,
-        process: proc,
-        cwd: workDir,
-        venv,
-        wsUrl,
-      });
-
-      proc.on('exit', () => {
-        sessions.delete(docName);
-      });
-
-      res.json({
-        name: docName,
-        port,
-        cwd: workDir,
-        venv,
-        wsUrl,
-        alive: true,
-      });
+      res.json(result);
     } catch (err) {
       console.error('[pty:forDocument]', err);
-      res.status(500).json({ error: err.message });
+      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');
-  });
-}
-
-/**
- * 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();
-  });
-}