mrmd-server 0.1.14 → 0.1.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mrmd-server",
-  "version": "0.1.14",
+  "version": "0.1.16",
   "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/file.js

@@ -22,10 +22,13 @@ export function createFileRoutes(ctx) {
    */
   router.get('/scan', async (req, res) => {
     try {
-      const root = req.query.root || ctx.projectDir;
+      // Default to home directory (like Electron's file picker)
+      const os = await import('os');
+      const root = req.query.root || ctx.projectDir || os.default.homedir();
       const options = {
-        extensions: req.query.extensions?.split(',') || ['.md'],
-        maxDepth: parseInt(req.query.maxDepth) || 6,
+        // Default to both .md and .ipynb (like Electron)
+        extensions: req.query.extensions?.split(',') || ['.md', '.ipynb'],
+        maxDepth: parseInt(req.query.maxDepth) || 10,
         includeHidden: req.query.includeHidden === 'true',
       };
 

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));
 
 /**
@@ -321,9 +324,13 @@ export async function createServer(config) {
 
       upstream.on('open', () => {
         syncWss.handleUpgrade(request, socket, head, (clientWs) => {
-          // Bidirectional proxy
-          clientWs.on('message', (data) => upstream.send(data));
-          upstream.on('message', (data) => clientWs.send(data));
+          // Bidirectional proxy - preserve message type (binary/text)
+          clientWs.on('message', (data, isBinary) => {
+            upstream.send(data, { binary: isBinary });
+          });
+          upstream.on('message', (data, isBinary) => {
+            clientWs.send(data, { binary: isBinary });
+          });
           clientWs.on('close', () => upstream.close());
           upstream.on('close', () => clientWs.close());
           clientWs.on('error', () => upstream.close());
@@ -389,6 +396,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') {