mrmd-server 0.1.0 → 0.1.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Maxime Rivest
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/bin/cli.js

@@ -128,26 +128,10 @@ async function main() {
 
   await server.start();
 
-  // Start mrmd-sync if available
-  try {
-    const syncPath = path.join(packageDir, '..', 'mrmd-sync', 'bin', 'cli.js');
-    await fs.access(syncPath);
-
-    console.log('  Starting mrmd-sync...');
-    const syncProc = spawn('node', [syncPath, '--port', '4444', options.projectDir], {
-      stdio: ['pipe', 'pipe', 'pipe'],
-    });
-
-    syncProc.stdout.on('data', (data) => {
-      if (data.toString().includes('Server started')) {
-        console.log(`  Sync:       ws://localhost:4444`);
-      }
-    });
-
-    server.context.syncProcess = syncProc;
-  } catch {
-    console.log('  Sync:       (mrmd-sync not found, start manually)');
-  }
+  // Sync servers are now started dynamically per-project when files are opened
+  // via the sync-manager.js acquireSyncServer() function
+  console.log('  Sync:       (dynamic per-project)');
+  console.log('');
 
   // Keep running
   console.log('');

package/package.json

@@ -1,12 +1,18 @@
 {
   "name": "mrmd-server",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "HTTP server for mrmd - run mrmd in any browser, access from anywhere",
   "type": "module",
   "main": "src/index.js",
   "bin": {
     "mrmd-server": "./bin/cli.js"
   },
+  "files": [
+    "src",
+    "bin",
+    "static",
+    "README.md"
+  ],
   "scripts": {
     "start": "node bin/cli.js",
     "dev": "node bin/cli.js --dev"
@@ -17,9 +23,18 @@
     "notebook",
     "server",
     "remote",
-    "collaboration"
+    "collaboration",
+    "literate-programming",
+    "code-execution"
   ],
+  "author": "Anthropic",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/anthropics/mrmd.git",
+    "directory": "packages/mrmd-server"
+  },
+  "homepage": "https://github.com/anthropics/mrmd",
   "engines": {
     "node": ">=18.0.0"
   },
@@ -30,6 +45,8 @@
     "multer": "^1.4.5-lts.1",
     "chokidar": "^3.6.0",
     "fzf": "^0.5.2",
-    "mrmd-project": "*"
+    "mrmd-project": "^0.1.1",
+    "mrmd-electron": "^0.3.1",
+    "mrmd-sync": "^0.3.2"
   }
 }

package/src/api/bash.js

@@ -1,16 +1,30 @@
 /**
  * Bash Session API routes
  *
- * Mirrors electronAPI.bash.*
+ * Mirrors electronAPI.bash.* using BashSessionService 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 net from 'net';
 
-// Bash session registry
-const bashSessions = 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 bash routes
@@ -18,6 +32,7 @@ const bashSessions = new Map();
  */
 export function createBashRoutes(ctx) {
   const router = Router();
+  const { bashSessionService } = ctx;
 
   /**
    * GET /api/bash
@@ -26,15 +41,7 @@ export function createBashRoutes(ctx) {
    */
   router.get('/', async (req, res) => {
     try {
-      const list = [];
-      for (const [name, session] of bashSessions) {
-        list.push({
-          name,
-          port: session.port,
-          cwd: session.cwd,
-          running: session.process && !session.process.killed,
-        });
-      }
+      const list = bashSessionService.list();
       res.json(list);
     } catch (err) {
       console.error('[bash:list]', err);
@@ -50,86 +57,19 @@ export function createBashRoutes(ctx) {
   router.post('/', async (req, res) => {
     try {
       const { config } = req.body;
-      const { name, cwd } = config || {};
 
-      if (!name) {
+      if (!config?.name) {
         return res.status(400).json({ error: 'config.name required' });
       }
 
-      // Check if session already exists
-      if (bashSessions.has(name)) {
-        const existing = bashSessions.get(name);
-        if (existing.process && !existing.process.killed) {
-          return res.json({
-            name,
-            port: existing.port,
-            cwd: existing.cwd,
-            reused: true,
-          });
-        }
-      }
-
-      // Find free port
-      const port = await findFreePort(8101, 8200);
-
-      const workDir = cwd ? path.resolve(ctx.projectDir, cwd) : ctx.projectDir;
-
-      // Try to find mrmd-bash package
-      const mrmdBashPaths = [
-        path.join(ctx.projectDir, '../mrmd-bash'),
-        path.join(process.cwd(), '../mrmd-bash'),
-        path.join(process.cwd(), 'mrmd-bash'),
-      ];
-
-      let mrmdBashPath = null;
-      for (const p of mrmdBashPaths) {
-        try {
-          const fs = await import('fs/promises');
-          await fs.access(path.join(p, 'pyproject.toml'));
-          mrmdBashPath = p;
-          break;
-        } catch {}
-      }
-
-      let proc;
-      if (mrmdBashPath) {
-        proc = spawn('uv', [
-          'run', '--project', mrmdBashPath,
-          'mrmd-bash',
-          '--port', port.toString(),
-        ], {
-          cwd: workDir,
-          stdio: ['pipe', 'pipe', 'pipe'],
-        });
-      } else {
-        // Fallback: assume mrmd-bash is installed
-        proc = spawn('mrmd-bash', [
-          '--port', port.toString(),
-        ], {
-          cwd: workDir,
-          stdio: ['pipe', 'pipe', 'pipe'],
-        });
-      }
-
-      // Wait for server to start
-      await waitForPort(port, 15000);
-
-      bashSessions.set(name, {
-        port,
-        process: proc,
-        cwd: workDir,
-      });
-
-      proc.on('exit', (code) => {
-        console.log(`[bash] ${name} exited with code ${code}`);
-        bashSessions.delete(name);
-      });
+      const result = await bashSessionService.start(config);
 
       res.json({
-        name,
-        port,
-        cwd: workDir,
-        url: `http://localhost:${port}/mrp/v1`,
+        name: result.name,
+        port: result.port,
+        cwd: result.cwd,
+        pid: result.pid,
+        url: `http://localhost:${result.port}/mrp/v1`,
       });
     } catch (err) {
       console.error('[bash:start]', err);
@@ -145,21 +85,11 @@ export function createBashRoutes(ctx) {
   router.delete('/:name', async (req, res) => {
     try {
       const { name } = req.params;
-      const session = bashSessions.get(name);
-
-      if (!session) {
-        return res.json({ success: true, message: 'Session not found' });
-      }
-
-      if (session.process && !session.process.killed) {
-        session.process.kill();
-      }
-
-      bashSessions.delete(name);
+      await bashSessionService.stop(name);
       res.json({ success: true });
     } catch (err) {
       console.error('[bash:stop]', err);
-      res.status(500).json({ error: err.message });
+      res.json({ success: true, message: err.message });
     }
   });
 
@@ -171,29 +101,15 @@ export function createBashRoutes(ctx) {
   router.post('/:name/restart', async (req, res) => {
     try {
       const { name } = req.params;
-      const session = bashSessions.get(name);
-
-      if (!session) {
-        return res.status(404).json({ error: 'Session not found' });
-      }
-
-      // Kill existing
-      if (session.process && !session.process.killed) {
-        session.process.kill();
-      }
+      const result = await bashSessionService.restart(name);
 
-      bashSessions.delete(name);
-
-      // Re-create
-      req.body.config = { name, cwd: session.cwd };
-
-      // Use the POST handler
-      const handler = router.stack.find(r => r.route?.path === '/' && r.route.methods.post);
-      if (handler) {
-        return handler.route.stack[0].handle(req, res);
-      }
-
-      res.status(500).json({ error: 'Could not restart' });
+      res.json({
+        name: result.name,
+        port: result.port,
+        cwd: result.cwd,
+        pid: result.pid,
+        url: `http://localhost:${result.port}/mrp/v1`,
+      });
     } catch (err) {
       console.error('[bash:restart]', err);
       res.status(500).json({ error: err.message });
@@ -204,90 +120,57 @@ export function createBashRoutes(ctx) {
    * POST /api/bash/for-document
    * Get or create bash session for a document
    * Mirrors: electronAPI.bash.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 = `bash-${path.basename(documentPath, '.md')}`;
+      // 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 || {};
+        }
+      }
 
-      // Check if session exists
-      if (bashSessions.has(docName)) {
-        const session = bashSessions.get(docName);
-        return res.json({
-          name: docName,
-          port: session.port,
-          cwd: session.cwd,
-          url: `http://localhost:${session.port}/mrp/v1`,
-        });
+      // Auto-parse frontmatter if not provided
+      if (!frontmatter) {
+        try {
+          const content = fs.readFileSync(documentPath, 'utf8');
+          frontmatter = Project.parseFrontmatter(content);
+        } catch (e) {
+          frontmatter = null;
+        }
       }
 
-      // Create session in document's directory
-      const fullPath = path.resolve(ctx.projectDir, documentPath);
-      req.body.config = {
-        name: docName,
-        cwd: path.dirname(fullPath),
-      };
+      const result = await bashSessionService.getForDocument(
+        documentPath,
+        projectConfig,
+        frontmatter,
+        projectRoot
+      );
 
-      // Use the POST handler
-      const handler = router.stack.find(r => r.route?.path === '/' && r.route.methods.post);
-      if (handler) {
-        return handler.route.stack[0].handle(req, res);
+      // Add url if we have a port
+      if (result?.port) {
+        result.url = `http://localhost:${result.port}/mrp/v1`;
       }
 
-      res.status(500).json({ error: 'Could not create session' });
+      res.json(result);
     } catch (err) {
       console.error('[bash:forDocument]', err);
-      res.status(500).json({ error: err.message });
+      res.json(null);
     }
   });
 
   return router;
 }
-
-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}`);
-}
-
-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');
-  });
-}
-
-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/file.js

@@ -48,7 +48,7 @@ export function createFileRoutes(ctx) {
         return res.status(400).json({ error: 'filePath required' });
       }
 
-      const fullPath = resolveSafePath(ctx.projectDir, filePath);
+      const fullPath = resolvePath(ctx.projectDir, filePath);
 
       // Create directory if needed
       await fs.mkdir(path.dirname(fullPath), { recursive: true });
@@ -84,7 +84,7 @@ export function createFileRoutes(ctx) {
       }
 
       const root = projectRoot || ctx.projectDir;
-      const fullPath = resolveSafePath(root, relativePath);
+      const fullPath = resolvePath(root, relativePath);
 
       // Create directory if needed
       await fs.mkdir(path.dirname(fullPath), { recursive: true });
@@ -138,8 +138,8 @@ export function createFileRoutes(ctx) {
       }
 
       const root = projectRoot || ctx.projectDir;
-      const fullFromPath = resolveSafePath(root, fromPath);
-      const fullToPath = resolveSafePath(root, toPath);
+      const fullFromPath = resolvePath(root, fromPath);
+      const fullToPath = resolvePath(root, toPath);
 
       // Create destination directory if needed
       await fs.mkdir(path.dirname(fullToPath), { recursive: true });
@@ -187,15 +187,15 @@ export function createFileRoutes(ctx) {
       // 3. Renaming files with new prefixes
 
       // For now, just do a simple move
-      const fullSourcePath = resolveSafePath(root, sourcePath);
+      const fullSourcePath = resolvePath(root, sourcePath);
       let fullTargetPath;
 
       if (position === 'inside') {
         // Move into target directory
-        fullTargetPath = resolveSafePath(root, path.join(targetPath, path.basename(sourcePath)));
+        fullTargetPath = resolvePath(root, path.join(targetPath, path.basename(sourcePath)));
       } else {
         // Move to same directory as target
-        fullTargetPath = resolveSafePath(root, path.join(path.dirname(targetPath), path.basename(sourcePath)));
+        fullTargetPath = resolvePath(root, path.join(path.dirname(targetPath), path.basename(sourcePath)));
       }
 
       await fs.mkdir(path.dirname(fullTargetPath), { recursive: true });
@@ -228,7 +228,7 @@ export function createFileRoutes(ctx) {
         return res.status(400).json({ error: 'path query parameter required' });
       }
 
-      const fullPath = resolveSafePath(ctx.projectDir, filePath);
+      const fullPath = resolvePath(ctx.projectDir, filePath);
 
       const stat = await fs.stat(fullPath);
       if (stat.isDirectory()) {
@@ -257,7 +257,7 @@ export function createFileRoutes(ctx) {
         return res.status(400).json({ error: 'path query parameter required' });
       }
 
-      const fullPath = resolveSafePath(ctx.projectDir, filePath);
+      const fullPath = resolvePath(ctx.projectDir, filePath);
       const content = await fs.readFile(fullPath, 'utf-8');
 
       res.json({ success: true, content });
@@ -282,7 +282,7 @@ export function createFileRoutes(ctx) {
         return res.status(400).json({ error: 'filePath required' });
       }
 
-      const fullPath = resolveSafePath(ctx.projectDir, filePath);
+      const fullPath = resolvePath(ctx.projectDir, filePath);
 
       // Create directory if needed
       await fs.mkdir(path.dirname(fullPath), { recursive: true });
@@ -310,7 +310,7 @@ export function createFileRoutes(ctx) {
         return res.status(400).json({ error: 'path query parameter required' });
       }
 
-      const fullPath = resolveSafePath(ctx.projectDir, filePath);
+      const fullPath = resolvePath(ctx.projectDir, filePath);
       const content = await fs.readFile(fullPath, 'utf-8');
       const previewLines = content.split('\n').slice(0, lines).join('\n');
 
@@ -336,7 +336,7 @@ export function createFileRoutes(ctx) {
         return res.status(400).json({ error: 'path query parameter required' });
       }
 
-      const fullPath = resolveSafePath(ctx.projectDir, filePath);
+      const fullPath = resolvePath(ctx.projectDir, filePath);
       const stat = await fs.stat(fullPath);
 
       res.json({
@@ -359,17 +359,23 @@ export function createFileRoutes(ctx) {
 }
 
 /**
- * Resolve path safely within project directory
+ * Resolve path - allows full filesystem access
+ *
+ * Security model: The server runs on the user's machine with their permissions.
+ * Access control is handled via auth token, not path restrictions.
+ *
+ * @param {string} basePath - Base path for relative paths (ignored for absolute)
+ * @param {string} inputPath - Path to resolve (absolute or relative)
+ * @returns {string} Resolved absolute path
  */
-function resolveSafePath(projectDir, relativePath) {
-  const resolved = path.resolve(projectDir, relativePath);
-
-  // Security: ensure resolved path is within project directory
-  if (!resolved.startsWith(path.resolve(projectDir))) {
-    throw new Error('Path traversal not allowed');
+function resolvePath(basePath, inputPath) {
+  // If it's already absolute, use it directly
+  if (path.isAbsolute(inputPath)) {
+    return inputPath;
   }
 
-  return resolved;
+  // Otherwise resolve relative to basePath
+  return path.resolve(basePath, inputPath);
 }
 
 /**

package/src/api/index.js

@@ -9,3 +9,8 @@ export { createFileRoutes } from './file.js';
 export { createAssetRoutes } from './asset.js';
 export { createSystemRoutes } from './system.js';
 export { createRuntimeRoutes } from './runtime.js';
+export { createJuliaRoutes } from './julia.js';
+export { createPtyRoutes } from './pty.js';
+export { createNotebookRoutes } from './notebook.js';
+export { createSettingsRoutes } from './settings.js';
+export { createRRoutes } from './r.js';