mrmd-server 0.2.0 → 0.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mrmd-server",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "HTTP server for mrmd - run mrmd in any browser, access from anywhere",
   "type": "module",
   "main": "src/index.js",

package/src/cloud-session-service.js

@@ -1,35 +1,63 @@
 /**
- * CloudSessionService — drop-in replacement for SessionService
+ * CloudSessionService — hybrid runtime manager for cloud mode
  *
- * Instead of spawning mrmd-python as a child process, this connects
- * to a pre-existing runtime container's MRP endpoint. Used when
- * mrmd-server runs inside an editor container (CLOUD_MODE=1).
+ * Python:       Routes to a pre-existing runtime container (RUNTIME_PORT)
+ * Bash/R/Julia/PTY: Spawns local child processes via RuntimeService
  *
- * The runtime container is started by the orchestrator/compute-manager
- * and its port is passed via RUNTIME_PORT env var.
+ * Used when mrmd-server runs inside an editor container (CLOUD_MODE=1).
+ * The Python runtime container is started by the orchestrator/compute-manager.
  */
 
+import { RuntimeService } from './services.js';
+
+/** Languages handled by the external runtime container */
+const CLOUD_LANGUAGES = new Set(['python', 'py', 'python3']);
+
 class CloudSessionService {
   constructor(runtimePort, runtimeHost) {
     this.runtimePort = runtimePort;
     this.runtimeHost = runtimeHost || '127.0.0.1';
     this.homeDir = process.env.CLOUD_HOME || process.env.HOME || '/home/ubuntu';
-    this.sessions = new Map();
+    this.pythonSessions = new Map();
     this.defaultRuntime = null;
+
+    // Local RuntimeService for bash, R, Julia, PTY
+    this.localService = new RuntimeService();
+  }
+
+  /**
+   * Is this language handled by the cloud runtime container?
+   */
+  _isCloudLanguage(language) {
+    return CLOUD_LANGUAGES.has((language || '').toLowerCase());
   }
 
   /**
-   * List all sessions.
-   * In cloud mode there's typically one session per runtime container.
+   * List all sessions (cloud Python + local runtimes).
    */
-  list() {
-    return Array.from(this.sessions.values());
+  list(language) {
+    const cloud = Array.from(this.pythonSessions.values());
+    const local = this.localService.list(language);
+
+    if (language) {
+      if (this._isCloudLanguage(language)) return cloud;
+      return local;
+    }
+    return [...cloud, ...local];
   }
 
   /**
-   * Start a session — in cloud mode, just registers the pre-existing runtime.
+   * Start a session.
+   * Python → register cloud runtime.  Others → delegate to local RuntimeService.
    */
   async start(config) {
+    const language = config.language || 'python';
+
+    if (!this._isCloudLanguage(language)) {
+      return this.localService.start(config);
+    }
+
+    // Cloud Python: register pre-existing runtime container
     const name = config.name || 'default';
     const port = this.runtimePort;
 
@@ -45,7 +73,9 @@ class CloudSessionService {
 
     const info = {
       name,
+      language: 'python',
       port,
+      url: `http://${this.runtimeHost}:${port}/mrp/v1`,
       pid: null,
       venv: null,
       cwd: config.cwd || this.homeDir,
@@ -54,127 +84,169 @@ class CloudSessionService {
       cloud: true,
     };
 
-    this.sessions.set(name, info);
+    this.pythonSessions.set(name, info);
     if (!this.defaultRuntime) this.defaultRuntime = name;
 
     return info;
   }
 
   /**
-   * Stop a session — in cloud mode, we don't kill the runtime container
-   * (that's the orchestrator's job). Just deregister locally.
+   * Stop a session.
    */
   async stop(sessionName) {
-    this.sessions.delete(sessionName);
-    return true;
+    if (this.pythonSessions.has(sessionName)) {
+      this.pythonSessions.delete(sessionName);
+      return true;
+    }
+    return this.localService.stop(sessionName);
   }
 
   /**
-   * Restart — re-verify the runtime is alive.
+   * Restart a session.
    */
   async restart(sessionName) {
-    const session = this.sessions.get(sessionName);
-    const config = session ? { name: sessionName, cwd: session.cwd } : { name: sessionName };
-    this.sessions.delete(sessionName);
-    return this.start(config);
+    if (this.pythonSessions.has(sessionName)) {
+      const session = this.pythonSessions.get(sessionName);
+      const config = { name: sessionName, language: 'python', cwd: session?.cwd };
+      this.pythonSessions.delete(sessionName);
+      return this.start(config);
+    }
+    return this.localService.restart(sessionName);
   }
 
   /**
-   * Attach to a session.
+   * Attach to an existing session.
    */
   attach(sessionName) {
-    const session = this.sessions.get(sessionName);
-    return session || null;
+    const cloudSession = this.pythonSessions.get(sessionName);
+    if (cloudSession) return cloudSession;
+    return this.localService.attach(sessionName);
   }
 
   /**
-   * Get or create session for a document.
-   * In cloud mode, always returns the runtime container's port.
-   * Auto-starts (registers) the session if needed.
+   * Get or create ALL runtimes needed for a document.
+   * Python → cloud container.  Bash/R/Julia/PTY → local RuntimeService.
    */
   async getForDocument(documentPath, projectConfig, frontmatter, projectRoot) {
-    // Derive a session name from the project
-    const projectName = projectRoot ? projectRoot.split('/').pop() : 'default';
-    const name = `${projectName}:default`;
+    const results = {};
 
-    const existing = this.sessions.get(name);
-    if (existing?.alive) {
-      return existing;
+    // Python: cloud runtime
+    const projectName = projectRoot ? projectRoot.split('/').pop() : 'default';
+    const pythonName = `${projectName}:python:default`;
+
+    const existingPython = this.pythonSessions.get(pythonName);
+    if (existingPython?.alive) {
+      results.python = { ...existingPython, autoStart: true, available: true };
+    } else {
+      try {
+        const info = await this.start({ name: pythonName, language: 'python', cwd: projectRoot || this.homeDir });
+        results.python = {
+          ...info,
+          autoStart: true,
+          available: true,
+        };
+      } catch (err) {
+        results.python = {
+          name: pythonName,
+          language: 'python',
+          port: null,
+          alive: false,
+          autoStart: true,
+          available: false,
+          error: err.message,
+        };
+      }
     }
 
-    // Auto-register the runtime container as a session
-    try {
-      const info = await this.start({ name, cwd: projectRoot || this.homeDir });
-      return {
-        name,
-        port: info.port,
-        alive: true,
-        autoStart: true,
-        venv: null,
-        cwd: info.cwd,
-        pid: null,
-        startedAt: info.startedAt,
-      };
-    } catch (err) {
-      return {
-        name,
-        port: null,
-        alive: false,
-        autoStart: true,
-        venv: null,
-        cwd: projectRoot || this.homeDir,
-        pid: null,
-        error: err.message,
-      };
-    }
-  }
+    // Other languages: delegate to local RuntimeService
+    const localResults = await this.localService.getForDocument(
+      documentPath, projectConfig, frontmatter, projectRoot,
+    );
 
-  /**
-   * Update the runtime port and/or host (called by orchestrator after CRIU migration).
-   * Updates all existing sessions to point to the new location.
-   */
-  updateRuntimePort(newPort, newHost) {
-    const oldPort = this.runtimePort;
-    const oldHost = this.runtimeHost;
-    this.runtimePort = newPort;
-    if (newHost) this.runtimeHost = newHost;
-    for (const [name, session] of this.sessions) {
-      session.port = newPort;
+    // Merge: local results for non-Python, cloud result for Python
+    for (const [lang, info] of Object.entries(localResults)) {
+      if (lang !== 'python') {
+        results[lang] = info;
+      }
     }
-    console.log(`[cloud-session] Runtime updated: ${oldHost}:${oldPort} → ${this.runtimeHost}:${newPort}`);
-    return { oldPort, newPort, oldHost, newHost: this.runtimeHost, sessionsUpdated: this.sessions.size };
+
+    return results;
   }
 
   /**
-   * Get or create runtime for a specific language.
-   * In cloud mode, all languages route to the same runtime container.
+   * Get or create a runtime for a specific language.
    */
   async getForDocumentLanguage(language, documentPath, projectConfig, frontmatter, projectRoot) {
-    // Cloud mode: single runtime handles everything
-    return this.getForDocument(documentPath, projectConfig, frontmatter, projectRoot);
+    if (this._isCloudLanguage(language)) {
+      const projectName = projectRoot ? projectRoot.split('/').pop() : 'default';
+      const name = `${projectName}:python:default`;
+
+      const existing = this.pythonSessions.get(name);
+      if (existing?.alive) {
+        return { ...existing, autoStart: true, available: true };
+      }
+
+      try {
+        const info = await this.start({ name, language: 'python', cwd: projectRoot || this.homeDir });
+        return { ...info, autoStart: true, available: true };
+      } catch (err) {
+        return {
+          name,
+          language: 'python',
+          port: null,
+          alive: false,
+          autoStart: true,
+          available: false,
+          error: err.message,
+        };
+      }
+    }
+
+    // Non-Python: delegate to local RuntimeService
+    return this.localService.getForDocumentLanguage(
+      language, documentPath, projectConfig, frontmatter, projectRoot,
+    );
   }
 
   /**
    * Check if a language is available.
-   * In cloud mode, the runtime container handles whatever it supports.
    */
   isAvailable(language) {
-    return { available: true };
+    if (this._isCloudLanguage(language)) return { available: true };
+    return this.localService.isAvailable(language);
   }
 
   /**
-   * List supported languages.
-   * In cloud mode, Python is the primary; others depend on container image.
+   * List ALL supported languages (cloud + local).
    */
   supportedLanguages() {
-    return ['python'];
+    return ['python', ...this.localService.supportedLanguages().filter(l => l !== 'python')];
+  }
+
+  /**
+   * Update the cloud runtime port/host (called after CRIU migration).
+   */
+  updateRuntimePort(newPort, newHost) {
+    const oldPort = this.runtimePort;
+    const oldHost = this.runtimeHost;
+    this.runtimePort = newPort;
+    if (newHost) this.runtimeHost = newHost;
+    for (const [, session] of this.pythonSessions) {
+      session.port = newPort;
+      session.url = `http://${this.runtimeHost}:${newPort}/mrp/v1`;
+    }
+    console.log(`[cloud-session] Runtime updated: ${oldHost}:${oldPort} → ${this.runtimeHost}:${newPort}`);
+    return { oldPort, newPort, oldHost, newHost: this.runtimeHost, sessionsUpdated: this.pythonSessions.size };
   }
 
   /**
-   * Shutdown — no-op in cloud mode.
+   * Shutdown all sessions.
    */
   shutdown() {
-    this.sessions.clear();
+    this.pythonSessions.clear();
+    if (typeof this.localService.shutdown === 'function') {
+      this.localService.shutdown();
+    }
   }
 }
 

package/src/sync-manager.js

@@ -3,6 +3,11 @@
  *
  * Ported from mrmd-electron/main.js to provide dynamic per-project sync servers.
  * Allows mrmd-server to handle files from any project, not just a fixed projectDir.
+ *
+ * Supports three sync modes (via SYNC_MODE env var):
+ *   - legacy: spawn local mrmd-sync per project (default)
+ *   - mirror: same as legacy (mirroring handled by orchestrator WS proxy)
+ *   - relay_primary: use relay-client to sync project dir with cloud relay
  */
 
 import { spawn } from 'child_process';
@@ -19,6 +24,10 @@ import { SYNC_SERVER_MEMORY_MB, DIR_HASH_LENGTH } from 'mrmd-electron/src/config
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
+const SYNC_MODE = process.env.SYNC_MODE || 'legacy';
+const SYNC_RELAY_URL = process.env.SYNC_RELAY_URL || 'ws://localhost:3006';
+const CLOUD_USER_ID = process.env.CLOUD_USER_ID || '';
+
 // Track active sync servers by directory hash
 const syncServers = new Map();
 
@@ -94,6 +103,9 @@ export function onSyncDeath(listener) {
  * Get or start a sync server for a project directory
  * Uses reference counting so multiple documents can share a sync server
  *
+ * In relay_primary mode, creates a relay client instead of a local sync server.
+ * The relay client syncs the project dir with the cloud relay bidirectionally.
+ *
  * @param {string} projectDir - The project directory to sync
  * @returns {Promise<{port: number, dir: string, refCount: number}>}
  */
@@ -104,10 +116,56 @@ export async function acquireSyncServer(projectDir) {
   if (syncServers.has(dirHash)) {
     const server = syncServers.get(dirHash);
     server.refCount++;
-    console.log(`[sync] Reusing server for ${projectDir} on port ${server.port} (refCount: ${server.refCount})`);
+    console.log(`[sync] Reusing server for ${projectDir} (refCount: ${server.refCount})`);
     return server;
   }
 
+  // ── Relay-primary mode: use relay client instead of local sync server ──
+  if (SYNC_MODE === 'relay_primary' && CLOUD_USER_ID) {
+    // Derive project name from the directory name
+    const projectName = path.basename(projectDir);
+
+    console.log(`[sync] Starting relay client for ${projectDir} (project: ${projectName})`);
+
+    try {
+      // Dynamic import so this doesn't fail in environments without relay-client
+      const { createRelayClient } = await import('mrmd-sync/src/relay-client.js');
+
+      const relayClient = createRelayClient({
+        relayUrl: SYNC_RELAY_URL,
+        projectDir,
+        userId: CLOUD_USER_ID,
+        project: projectName,
+        writeDebounceMs: 1000,
+        log: (msg) => console.log(msg),
+      });
+
+      await relayClient.start();
+
+      // Return a server-like object that the rest of the code can use.
+      // port=0 signals that sync is handled by the relay (not a local WS server).
+      // The orchestrator's WS proxy routes sync traffic directly to the relay.
+      const server = {
+        proc: null,
+        port: 0,
+        dir: projectDir,
+        refCount: 1,
+        owned: true,
+        isRelay: true,
+        relayClient,
+      };
+      syncServers.set(dirHash, server);
+      console.log(`[sync] Relay client started for ${projectDir}`);
+      return server;
+    } catch (err) {
+      console.error(`[sync] Failed to start relay client for ${projectDir}: ${err.message}`);
+      console.warn(`[sync] Falling back to local sync server`);
+      // Fall through to local server below
+    }
+  }
+
+  // ── Legacy / mirror mode: spawn local mrmd-sync process ──
+
   // Check for existing server from a PID file (in case of restart)
   const syncStatePath = path.join(os.tmpdir(), `mrmd-sync-${dirHash}`, 'server.pid');
   try {

package/static/http-shim.js

@@ -110,6 +110,39 @@
   const POST = (path, body) => apiCall('POST', path, body);
   const DELETE = (path) => apiCall('DELETE', path);
 
+  const DOC_EXTENSIONS = ['.md', '.qmd'];
+
+  function basenameFromPath(filePath = '') {
+    const normalized = String(filePath).replace(/\\/g, '/').replace(/\/+/g, '/');
+    const parts = normalized.split('/').filter(Boolean);
+    return parts.length ? parts[parts.length - 1] : '';
+  }
+
+  function dirnameFromPath(filePath = '') {
+    const normalized = String(filePath).replace(/\\/g, '/').replace(/\/+/g, '/');
+    const lastSlash = normalized.lastIndexOf('/');
+    if (lastSlash <= 0) return normalized.startsWith('/') ? '/' : '.';
+    return normalized.slice(0, lastSlash) || '/';
+  }
+
+  function stripDocExtension(fileName = '') {
+    const lower = fileName.toLowerCase();
+    for (const ext of DOC_EXTENSIONS) {
+      if (lower.endsWith(ext)) {
+        return fileName.slice(0, -ext.length);
+      }
+    }
+    return fileName;
+  }
+
+  function makeRuntimeIdFromVenv(venvPath = '', forceNew = false) {
+    const venvName = basenameFromPath(venvPath).replace(/^\.+/, '') || 'venv';
+    const projectName = basenameFromPath(dirnameFromPath(venvPath)).replace(/^\.+/, '') || 'project';
+    let name = `${projectName}:${venvName}`.replace(/[^a-zA-Z0-9-:]/g, '-');
+    if (forceNew) name += '-' + Date.now().toString(36).slice(-4);
+    return name;
+  }
+
   // ==========================================================================
   // WebSocket for Events
   // ==========================================================================
@@ -322,8 +355,20 @@
       GET(`/api/file/preview?path=${encodeURIComponent(filePath)}&lines=${lines || 40}`)
         .then(r => r.content),
 
-    getFileInfo: (filePath) =>
-      GET(`/api/file/info?path=${encodeURIComponent(filePath)}`),
+    getFileInfo: async (filePath) => {
+      try {
+        const info = await GET(`/api/file/info?path=${encodeURIComponent(filePath)}`);
+        return {
+          success: true,
+          ...info,
+        };
+      } catch (err) {
+        return {
+          success: false,
+          error: err.message,
+        };
+      }
+    },
 
     // ========================================================================
     // Venv creation (still useful for setup flows)
@@ -332,6 +377,109 @@
     createVenv: (venvPath) =>
       POST('/api/system/create-venv', { venvPath }),
 
+    installMrmdPython: (venvPath) =>
+      POST('/api/system/install-mrmd-python', { venvPath }),
+
+    startPython: async (venvPath, forceNew = false) => {
+      try {
+        const runtimeId = makeRuntimeIdFromVenv(venvPath, forceNew);
+        const cwd = dirnameFromPath(venvPath);
+        const result = await POST('/api/runtime', {
+          config: {
+            name: runtimeId,
+            language: 'python',
+            cwd,
+            venv: venvPath,
+          },
+        });
+
+        return {
+          success: true,
+          port: result.port,
+          runtimeId,
+          venv: result.venv || venvPath,
+          url: result.url,
+        };
+      } catch (err) {
+        return {
+          success: false,
+          error: err.message,
+        };
+      }
+    },
+
+    attachRuntime: async (runtimeId) => {
+      try {
+        const result = await POST(`/api/runtime/${encodeURIComponent(runtimeId)}/attach`, {});
+        return {
+          success: true,
+          port: result.port,
+          url: result.url,
+          venv: result.venv,
+        };
+      } catch (err) {
+        return {
+          success: false,
+          error: err.message,
+        };
+      }
+    },
+
+    openFile: async (filePath) => {
+      try {
+        // Ensure project is detected and sync server is available.
+        const project = await GET(`/api/project?path=${encodeURIComponent(filePath)}`);
+        const projectDir = project?.root || dirnameFromPath(filePath);
+
+        let syncPort = project?.syncPort;
+        if (!syncPort) {
+          const sync = await POST('/api/project/sync/acquire', { projectDir });
+          syncPort = sync.port;
+        }
+
+        // Mirror Electron behavior: track recent file usage.
+        try {
+          await POST('/api/system/recent', { file: filePath });
+        } catch (err) {
+          console.warn('[http-shim] Failed to update recent file:', err.message);
+        }
+
+        const fileName = basenameFromPath(filePath);
+        const docName = stripDocExtension(fileName);
+
+        return {
+          success: true,
+          syncPort,
+          docName,
+          pythonPort: null,
+          projectDir,
+        };
+      } catch (err) {
+        return {
+          success: false,
+          error: err.message,
+        };
+      }
+    },
+
+    listRuntimes: async () => {
+      try {
+        const runtimes = await GET('/api/runtime');
+        return { runtimes };
+      } catch (err) {
+        return { runtimes: [], error: err.message };
+      }
+    },
+
+    killRuntime: async (runtimeId) => {
+      try {
+        await DELETE(`/api/runtime/${encodeURIComponent(runtimeId)}`);
+        return { success: true };
+      } catch (err) {
+        return { success: false, error: err.message };
+      }
+    },
+
     // ========================================================================
     // PROJECT SERVICE
     // ========================================================================