mrmd-server 0.1.0

package/src/api/julia.js

@@ -0,0 +1,345 @@
+/**
+ * Julia Session API routes
+ *
+ * Mirrors electronAPI.julia.*
+ */
+
+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, cwd }
+const sessions = new Map();
+
+/**
+ * Create Julia routes
+ * @param {import('../server.js').ServerContext} ctx
+ */
+export function createJuliaRoutes(ctx) {
+  const router = Router();
+
+  /**
+   * GET /api/julia
+   * List all running Julia sessions
+   * Mirrors: electronAPI.julia.list()
+   */
+  router.get('/', async (req, res) => {
+    try {
+      const list = [];
+      for (const [name, session] of sessions) {
+        list.push({
+          name,
+          port: session.port,
+          cwd: session.cwd,
+          running: session.process && !session.process.killed,
+        });
+      }
+      res.json(list);
+    } catch (err) {
+      console.error('[julia:list]', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  /**
+   * GET /api/julia/available
+   * Check if Julia is available on the system
+   * Mirrors: electronAPI.julia.isAvailable()
+   */
+  router.get('/available', async (req, res) => {
+    try {
+      const available = await isJuliaAvailable();
+      res.json({ available });
+    } catch (err) {
+      console.error('[julia:available]', err);
+      res.json({ available: false });
+    }
+  });
+
+  /**
+   * POST /api/julia
+   * Start a new Julia session
+   * Mirrors: electronAPI.julia.start(config)
+   */
+  router.post('/', async (req, res) => {
+    try {
+      const { config } = req.body;
+      const { name, cwd } = config || {};
+
+      if (!name) {
+        return res.status(400).json({ error: 'config.name required' });
+      }
+
+      // Check if Julia is available
+      if (!await isJuliaAvailable()) {
+        return res.status(503).json({ error: 'Julia is not available on this system' });
+      }
+
+      // 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,
+            reused: true,
+          });
+        }
+      }
+
+      // Find free port
+      const port = await findFreePort(9001, 9100);
+      const workDir = cwd ? path.resolve(ctx.projectDir, cwd) : ctx.projectDir;
+
+      // Start Julia MRP server
+      // Note: This assumes mrmd-julia is installed and provides an MRP-compatible server
+      const proc = spawn('julia', [
+        '-e',
+        `using MrmdJulia; MrmdJulia.serve(${port})`,
+      ], {
+        cwd: workDir,
+        stdio: ['pipe', 'pipe', 'pipe'],
+      });
+
+      // Wait for server to start (with timeout)
+      try {
+        await waitForPort(port, 15000);
+      } catch (err) {
+        proc.kill();
+        return res.status(500).json({ error: `Julia server failed to start: ${err.message}` });
+      }
+
+      sessions.set(name, {
+        port,
+        process: proc,
+        cwd: workDir,
+      });
+
+      proc.on('exit', (code) => {
+        console.log(`[julia] ${name} exited with code ${code}`);
+        sessions.delete(name);
+      });
+
+      res.json({
+        name,
+        port,
+        cwd: workDir,
+        url: `http://localhost:${port}/mrp/v1`,
+      });
+    } catch (err) {
+      console.error('[julia:start]', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  /**
+   * DELETE /api/julia/:name
+   * Stop a Julia session
+   * Mirrors: electronAPI.julia.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('[julia:stop]', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  /**
+   * POST /api/julia/:name/restart
+   * Restart a Julia session
+   * Mirrors: electronAPI.julia.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
+      const cwd = session.cwd;
+      sessions.delete(name);
+
+      // Forward to start handler
+      req.body.config = { name, cwd };
+      // Recursively call POST /
+      // In production, extract logic to shared function
+      return res.redirect(307, '/api/julia');
+    } catch (err) {
+      console.error('[julia:restart]', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  /**
+   * POST /api/julia/for-document
+   * Get or create Julia session for a document
+   * Mirrors: electronAPI.julia.forDocument(documentPath)
+   */
+  router.post('/for-document', async (req, res) => {
+    try {
+      const { documentPath } = req.body;
+      if (!documentPath) {
+        return res.status(400).json({ error: 'documentPath required' });
+      }
+
+      // Check if Julia is available
+      if (!await isJuliaAvailable()) {
+        return res.json(null);
+      }
+
+      const docName = `julia-${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,
+          cwd: session.cwd,
+          url: `http://localhost:${session.port}/mrp/v1`,
+        });
+      }
+
+      // Create session
+      const fullPath = path.resolve(ctx.projectDir, documentPath);
+      const port = await findFreePort(9001, 9100);
+      const workDir = path.dirname(fullPath);
+
+      const proc = spawn('julia', [
+        '-e',
+        `using MrmdJulia; MrmdJulia.serve(${port})`,
+      ], {
+        cwd: workDir,
+        stdio: ['pipe', 'pipe', 'pipe'],
+      });
+
+      try {
+        await waitForPort(port, 15000);
+      } catch (err) {
+        proc.kill();
+        return res.json(null);
+      }
+
+      sessions.set(docName, {
+        port,
+        process: proc,
+        cwd: workDir,
+      });
+
+      res.json({
+        name: docName,
+        port,
+        cwd: workDir,
+        url: `http://localhost:${port}/mrp/v1`,
+      });
+    } catch (err) {
+      console.error('[julia:forDocument]', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  return router;
+}
+
+/**
+ * Check if Julia is available
+ */
+async function isJuliaAvailable() {
+  return new Promise((resolve) => {
+    const proc = spawn('julia', ['--version'], {
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+
+    proc.on('close', (code) => {
+      resolve(code === 0);
+    });
+
+    proc.on('error', () => {
+      resolve(false);
+    });
+
+    // Timeout after 5 seconds
+    setTimeout(() => {
+      proc.kill();
+      resolve(false);
+    }, 5000);
+  });
+}
+
+/**
+ * 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/project.js

@@ -0,0 +1,296 @@
+/**
+ * Project API routes
+ *
+ * Mirrors electronAPI.project.*
+ */
+
+import { Router } from 'express';
+import path from 'path';
+import fs from 'fs/promises';
+import { watch } from 'chokidar';
+
+/**
+ * Create project routes
+ * @param {import('../server.js').ServerContext} ctx
+ */
+export function createProjectRoutes(ctx) {
+  const router = Router();
+
+  /**
+   * GET /api/project?path=...
+   * Get project info for a file path
+   * Mirrors: electronAPI.project.get(filePath)
+   */
+  router.get('/', async (req, res) => {
+    try {
+      const filePath = req.query.path;
+      if (!filePath) {
+        return res.status(400).json({ error: 'path query parameter required' });
+      }
+
+      const projectInfo = await getProjectInfo(filePath, ctx.projectDir);
+      res.json(projectInfo);
+    } catch (err) {
+      console.error('[project:get]', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  /**
+   * POST /api/project
+   * Create a new mrmd project
+   * Mirrors: electronAPI.project.create(targetPath)
+   */
+  router.post('/', async (req, res) => {
+    try {
+      const { targetPath } = req.body;
+      if (!targetPath) {
+        return res.status(400).json({ error: 'targetPath required' });
+      }
+
+      const resolvedPath = path.resolve(ctx.projectDir, targetPath);
+
+      // Create directory if it doesn't exist
+      await fs.mkdir(resolvedPath, { recursive: true });
+
+      // Create mrmd.md config file
+      const mrmdPath = path.join(resolvedPath, 'mrmd.md');
+      const mrmdContent = `# ${path.basename(resolvedPath)}
+
+A new mrmd project.
+
+---
+venv: .venv
+---
+`;
+      await fs.writeFile(mrmdPath, mrmdContent);
+
+      // Get and return project info
+      const projectInfo = await getProjectInfo(mrmdPath, ctx.projectDir);
+      res.json(projectInfo);
+    } catch (err) {
+      console.error('[project:create]', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  /**
+   * GET /api/project/nav?root=...
+   * Get navigation tree for a project
+   * Mirrors: electronAPI.project.nav(projectRoot)
+   */
+  router.get('/nav', async (req, res) => {
+    try {
+      const projectRoot = req.query.root || ctx.projectDir;
+      const navTree = await buildNavTree(projectRoot);
+      res.json(navTree);
+    } catch (err) {
+      console.error('[project:nav]', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  /**
+   * POST /api/project/invalidate
+   * Invalidate cached project info
+   * Mirrors: electronAPI.project.invalidate(projectRoot)
+   */
+  router.post('/invalidate', async (req, res) => {
+    try {
+      const { projectRoot } = req.body;
+      // In this implementation we don't cache, so this is a no-op
+      // but we emit an event so the UI can refresh
+      ctx.eventBus.projectChanged(projectRoot || ctx.projectDir);
+      res.json({ success: true });
+    } catch (err) {
+      console.error('[project:invalidate]', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  /**
+   * POST /api/project/watch
+   * Watch project for file changes
+   * Mirrors: electronAPI.project.watch(projectRoot)
+   */
+  router.post('/watch', async (req, res) => {
+    try {
+      const { projectRoot } = req.body;
+      const watchPath = projectRoot || ctx.projectDir;
+
+      // Close existing watcher if any
+      if (ctx.watchers.has(watchPath)) {
+        await ctx.watchers.get(watchPath).close();
+      }
+
+      // Create new watcher
+      const watcher = watch(watchPath, {
+        ignored: /(^|[\/\\])\.|node_modules|\.git|__pycache__|\.mrmd-sync/,
+        persistent: true,
+        ignoreInitial: true,
+      });
+
+      watcher.on('all', (event, filePath) => {
+        if (filePath.endsWith('.md')) {
+          ctx.eventBus.projectChanged(watchPath);
+        }
+      });
+
+      ctx.watchers.set(watchPath, watcher);
+      res.json({ success: true, watching: watchPath });
+    } catch (err) {
+      console.error('[project:watch]', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  /**
+   * POST /api/project/unwatch
+   * Stop watching project
+   * Mirrors: electronAPI.project.unwatch()
+   */
+  router.post('/unwatch', async (req, res) => {
+    try {
+      // Close all watchers
+      for (const [watchPath, watcher] of ctx.watchers) {
+        await watcher.close();
+        ctx.watchers.delete(watchPath);
+      }
+      res.json({ success: true });
+    } catch (err) {
+      console.error('[project:unwatch]', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  return router;
+}
+
+/**
+ * Get project info for a file path
+ */
+async function getProjectInfo(filePath, defaultRoot) {
+  const resolvedPath = path.resolve(defaultRoot, filePath);
+
+  // Find project root by walking up to find mrmd.md
+  let projectRoot = path.dirname(resolvedPath);
+  let mrmdConfig = null;
+
+  for (let i = 0; i < 10; i++) {
+    const mrmdPath = path.join(projectRoot, 'mrmd.md');
+    try {
+      const content = await fs.readFile(mrmdPath, 'utf-8');
+      mrmdConfig = parseMrmdConfig(content);
+      break;
+    } catch {
+      const parent = path.dirname(projectRoot);
+      if (parent === projectRoot) break;
+      projectRoot = parent;
+    }
+  }
+
+  // If no mrmd.md found, use the provided directory
+  if (!mrmdConfig) {
+    projectRoot = defaultRoot;
+    mrmdConfig = { venv: '.venv' };
+  }
+
+  // Build nav tree
+  const navTree = await buildNavTree(projectRoot);
+
+  return {
+    root: projectRoot,
+    config: mrmdConfig,
+    navTree,
+    currentFile: resolvedPath,
+  };
+}
+
+/**
+ * Parse mrmd.md config (frontmatter)
+ */
+function parseMrmdConfig(content) {
+  const config = { venv: '.venv' };
+
+  // Simple YAML frontmatter parsing
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (match) {
+    const yaml = match[1];
+    const venvMatch = yaml.match(/venv:\s*(.+)/);
+    if (venvMatch) {
+      config.venv = venvMatch[1].trim();
+    }
+  }
+
+  return config;
+}
+
+/**
+ * Build navigation tree for a project
+ */
+async function buildNavTree(projectRoot, relativePath = '') {
+  const fullPath = path.join(projectRoot, relativePath);
+  const entries = await fs.readdir(fullPath, { withFileTypes: true });
+  const nodes = [];
+
+  // Sort entries: directories first, then files, alphabetically
+  entries.sort((a, b) => {
+    if (a.isDirectory() && !b.isDirectory()) return -1;
+    if (!a.isDirectory() && b.isDirectory()) return 1;
+    // Handle FSML ordering (numeric prefixes)
+    const aNum = parseInt(a.name.match(/^(\d+)/)?.[1] || '999');
+    const bNum = parseInt(b.name.match(/^(\d+)/)?.[1] || '999');
+    if (aNum !== bNum) return aNum - bNum;
+    return a.name.localeCompare(b.name);
+  });
+
+  for (const entry of entries) {
+    // Skip hidden files and special directories
+    if (entry.name.startsWith('.')) continue;
+    if (entry.name === 'node_modules') continue;
+    if (entry.name === '__pycache__') continue;
+    if (entry.name === '_assets') continue;
+
+    const entryRelPath = path.join(relativePath, entry.name);
+
+    if (entry.isDirectory()) {
+      const children = await buildNavTree(projectRoot, entryRelPath);
+      // Only include directories that have .md files (directly or nested)
+      if (children.length > 0 || await hasIndexFile(path.join(projectRoot, entryRelPath))) {
+        nodes.push({
+          type: 'folder',
+          name: cleanName(entry.name),
+          path: entryRelPath,
+          children,
+        });
+      }
+    } else if (entry.name.endsWith('.md') && entry.name !== 'mrmd.md') {
+      nodes.push({
+        type: 'file',
+        name: cleanName(entry.name.replace(/\.md$/, '')),
+        path: entryRelPath,
+      });
+    }
+  }
+
+  return nodes;
+}
+
+/**
+ * Check if directory has an index file
+ */
+async function hasIndexFile(dirPath) {
+  try {
+    const entries = await fs.readdir(dirPath);
+    return entries.some(e => e.endsWith('.md'));
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Clean FSML numeric prefix from name
+ */
+function cleanName(name) {
+  return name.replace(/^\d+[-_.\s]*/, '');
+}