mrmd-server 0.1.13 → 0.1.15

package/package.json

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

package/src/ai-service.js

@@ -0,0 +1,184 @@
+/**
+ * AI Service - manages the mrmd-ai server
+ *
+ * The AI server is shared across all sessions (stateless).
+ * It's started once on first request and kept running.
+ */
+
+import { spawn, execSync } from 'child_process';
+import net from 'net';
+import path from 'path';
+import { existsSync } from 'fs';
+import os from 'os';
+
+// AI server singleton
+let aiServer = null;
+let startPromise = null;
+
+/**
+ * Find a free port
+ */
+async function findFreePort() {
+  return new Promise((resolve, reject) => {
+    const srv = net.createServer();
+    srv.listen(0, () => {
+      const { port } = srv.address();
+      srv.close(() => resolve(port));
+    });
+    srv.on('error', reject);
+  });
+}
+
+/**
+ * Wait for a port to be available (server started)
+ */
+async function waitForPort(port, { timeout = 30000 } = {}) {
+  const start = Date.now();
+  while (Date.now() - start < timeout) {
+    try {
+      await new Promise((resolve, reject) => {
+        const socket = net.connect(port, '127.0.0.1');
+        socket.on('connect', () => {
+          socket.destroy();
+          resolve();
+        });
+        socket.on('error', reject);
+      });
+      return true;
+    } catch {
+      await new Promise(r => setTimeout(r, 200));
+    }
+  }
+  throw new Error(`Timeout waiting for port ${port}`);
+}
+
+/**
+ * Find uv executable
+ */
+function findUv() {
+  try {
+    return execSync('which uv', { encoding: 'utf-8' }).trim();
+  } catch {
+    // Check common locations
+    const locations = [
+      path.join(os.homedir(), '.local', 'bin', 'uv'),
+      '/usr/local/bin/uv',
+      '/usr/bin/uv',
+      path.join(os.homedir(), '.cargo', 'bin', 'uv'),
+    ];
+    for (const loc of locations) {
+      if (existsSync(loc)) {
+        return loc;
+      }
+    }
+  }
+  return null;
+}
+
+/**
+ * Ensure AI server is running
+ * Returns { port, url, success } or { error, success: false }
+ */
+export async function ensureAiServer() {
+  // Already running
+  if (aiServer) {
+    return {
+      success: true,
+      port: aiServer.port,
+      url: `http://localhost:${aiServer.port}`,
+    };
+  }
+
+  // Already starting (avoid race condition)
+  if (startPromise) {
+    return startPromise;
+  }
+
+  startPromise = (async () => {
+    const uvPath = findUv();
+    if (!uvPath) {
+      return {
+        success: false,
+        error: "'uv' is not installed. Install it with: curl -LsSf https://astral.sh/uv/install.sh | sh",
+      };
+    }
+
+    const port = await findFreePort();
+    console.log(`[ai] Starting mrmd-ai on port ${port}...`);
+
+    const proc = spawn(uvPath, [
+      'tool', 'run',
+      '--from', 'mrmd-ai>=0.1.0,<0.2',
+      'mrmd-ai-server',
+      '--port', port.toString(),
+    ], {
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+
+    proc.stdout.on('data', (d) => console.log('[ai]', d.toString().trim()));
+    proc.stderr.on('data', (d) => console.error('[ai]', d.toString().trim()));
+    proc.on('exit', (code) => {
+      console.log(`[ai] AI server exited with code ${code}`);
+      aiServer = null;
+      startPromise = null;
+    });
+
+    try {
+      // AI server imports heavy libs (dspy, litellm) - needs 30s timeout
+      await waitForPort(port, { timeout: 30000 });
+
+      aiServer = { proc, port };
+      console.log(`[ai] AI server ready on port ${port}`);
+
+      return {
+        success: true,
+        port,
+        url: `http://localhost:${port}`,
+      };
+    } catch (e) {
+      proc.kill('SIGTERM');
+      startPromise = null;
+      return {
+        success: false,
+        error: `AI server failed to start: ${e.message}`,
+      };
+    }
+  })();
+
+  const result = await startPromise;
+  if (!result.success) {
+    startPromise = null;
+  }
+  return result;
+}
+
+/**
+ * Get current AI server status
+ */
+export function getAiServer() {
+  if (aiServer) {
+    return {
+      success: true,
+      port: aiServer.port,
+      url: `http://localhost:${aiServer.port}`,
+      running: true,
+    };
+  }
+  return {
+    success: false,
+    running: false,
+    error: 'AI server not started',
+  };
+}
+
+/**
+ * Stop AI server
+ */
+export function stopAiServer() {
+  if (aiServer?.proc) {
+    console.log('[ai] Stopping AI server...');
+    aiServer.proc.kill('SIGTERM');
+    aiServer = null;
+    startPromise = null;
+  }
+}

package/src/api/system.js

@@ -10,6 +10,7 @@ import path from 'path';
 import fs from 'fs/promises';
 import { existsSync } from 'fs';
 import { spawn, execSync } from 'child_process';
+import { ensureAiServer, getAiServer } from '../ai-service.js';
 
 /**
  * Create system routes
@@ -187,14 +188,26 @@ export function createSystemRoutes(ctx) {
 
   /**
    * GET /api/system/ai
-   * Get AI server info
+   * Get AI server info - ensures AI server is running
    * Mirrors: electronAPI.getAi()
    */
-  router.get('/ai', (req, res) => {
-    res.json({
-      port: ctx.aiPort,
-      url: `http://localhost:${ctx.aiPort}`,
-    });
+  router.get('/ai', async (req, res) => {
+    try {
+      // Ensure AI server is running (starts it if not)
+      const result = await ensureAiServer();
+      res.json(result);
+    } catch (err) {
+      console.error('[system:ai]', err);
+      res.status(500).json({ success: false, error: err.message });
+    }
+  });
+
+  /**
+   * GET /api/system/ai/status
+   * Get AI server status without starting it
+   */
+  router.get('/ai/status', (req, res) => {
+    res.json(getAiServer());
   });
 
   /**

package/src/server.js

@@ -55,6 +55,9 @@ import {
   onSyncDeath,
 } from './sync-manager.js';
 
+// Import AI service for mrmd-ai server management
+import { stopAiServer } from './ai-service.js';
+
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
 /**
@@ -309,11 +312,12 @@ export async function createServer(config) {
       return;
     }
 
-    // Handle /sync/:port/:doc - proxy to local sync server
+    // Handle /sync/:port/:path - proxy to local server (sync, pty, etc.)
     const syncMatch = url.pathname.match(/^\/sync\/(\d+)\/(.+)$/);
     if (syncMatch) {
-      const [, syncPort, docName] = syncMatch;
-      const targetUrl = `ws://127.0.0.1:${syncPort}/${docName}`;
+      const [, syncPort, pathPart] = syncMatch;
+      // Preserve query string for PTY sessions
+      const targetUrl = `ws://127.0.0.1:${syncPort}/${pathPart}${url.search}`;
 
       // Create connection to local sync server
       const upstream = new WsClient(targetUrl);
@@ -388,6 +392,9 @@ export async function createServer(config) {
       // Stop all sync servers
       stopAllSyncServers();
 
+      // Stop AI server
+      stopAiServer();
+
       // Stop all sessions via services (if they have shutdown methods)
       try {
         if (typeof sessionService.shutdown === 'function') {