mrmd-server 0.2.4 → 0.2.6

package/package.json

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

package/src/api/file.js

@@ -325,6 +325,143 @@ export function createFileRoutes(ctx) {
     }
   });
 
+  /**
+   * GET /api/browse?path=...&type=all|dir|file&show_hidden=true
+   * Browse the filesystem for the file picker.
+   * Returns { path, parent, entries: [{name, path, type, size?, modified?}] }
+   */
+  router.get('/browse', async (req, res) => {
+    try {
+      const os = await import('os');
+      const fs = await import('fs/promises');
+
+      let browsePath = req.query.path || '~';
+      if (browsePath === '~') {
+        browsePath = ctx.projectDir || os.default.homedir();
+      }
+
+      const resolvedPath = path.resolve(browsePath);
+      const typeFilter = req.query.type || 'all'; // 'all', 'dir', 'file'
+      const showHidden = req.query.show_hidden === 'true';
+
+      let dirEntries;
+      try {
+        dirEntries = await fs.readdir(resolvedPath, { withFileTypes: true });
+      } catch (err) {
+        if (err.code === 'ENOENT') {
+          return res.status(404).json({ error: 'Directory not found', path: resolvedPath });
+        }
+        if (err.code === 'EACCES') {
+          return res.status(403).json({ error: 'Permission denied', path: resolvedPath });
+        }
+        throw err;
+      }
+
+      const entries = [];
+      for (const entry of dirEntries) {
+        // Skip hidden files unless requested
+        if (!showHidden && entry.name.startsWith('.')) continue;
+        // Skip common uninteresting directories
+        if (entry.name === 'node_modules' || entry.name === '__pycache__' || entry.name === '.git') continue;
+
+        const isDir = entry.isDirectory();
+        const isFile = entry.isFile();
+        if (!isDir && !isFile) continue;
+        if (typeFilter === 'dir' && !isDir) continue;
+        if (typeFilter === 'file' && !isFile) continue;
+
+        const entryPath = path.join(resolvedPath, entry.name);
+        const item = {
+          name: entry.name,
+          path: entryPath,
+          type: isDir ? 'directory' : 'file',
+        };
+
+        // Add file metadata (best-effort, don't fail if stat errors)
+        if (isFile) {
+          try {
+            const stat = await fs.stat(entryPath);
+            item.size = stat.size;
+            item.modified = stat.mtime.toISOString();
+          } catch { /* ignore stat errors */ }
+        }
+
+        entries.push(item);
+      }
+
+      // Sort: directories first, then alphabetical
+      entries.sort((a, b) => {
+        if (a.type === 'directory' && b.type !== 'directory') return -1;
+        if (a.type !== 'directory' && b.type === 'directory') return 1;
+        return a.name.localeCompare(b.name);
+      });
+
+      const parent = path.dirname(resolvedPath);
+      res.json({
+        path: resolvedPath,
+        parent: parent !== resolvedPath ? parent : null,
+        entries,
+      });
+    } catch (err) {
+      console.error('[file:browse]', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  /**
+   * POST /api/file/write-bytes
+   * Write raw bytes to a file (for drag-drop uploads from browser).
+   * Body: { filePath, bytes: number[] }
+   */
+  router.post('/write-bytes', async (req, res) => {
+    try {
+      const { filePath, bytes } = req.body;
+      if (!filePath || !bytes) {
+        return res.status(400).json({ error: 'filePath and bytes required' });
+      }
+      const fullPath = resolvePath(ctx.projectDir, filePath);
+      await fsPromises.mkdir(path.dirname(fullPath), { recursive: true });
+      await fsPromises.writeFile(fullPath, Buffer.from(bytes));
+
+      ctx.eventBus.projectChanged(ctx.projectDir);
+      res.json({ success: true, path: fullPath });
+    } catch (err) {
+      console.error('[file:write-bytes]', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  /**
+   * POST /api/file/copy
+   * Copy a file or directory.
+   * Body: { fromPath, toPath }
+   */
+  router.post('/copy', async (req, res) => {
+    try {
+      const { fromPath, toPath } = req.body;
+      if (!fromPath || !toPath) {
+        return res.status(400).json({ error: 'fromPath and toPath required' });
+      }
+
+      const fullFrom = resolvePath(ctx.projectDir, fromPath);
+      const fullTo = resolvePath(ctx.projectDir, toPath);
+      const stat = await fsPromises.stat(fullFrom);
+
+      if (stat.isDirectory()) {
+        await fsPromises.cp(fullFrom, fullTo, { recursive: true });
+      } else {
+        await fsPromises.mkdir(path.dirname(fullTo), { recursive: true });
+        await fsPromises.copyFile(fullFrom, fullTo);
+      }
+
+      ctx.eventBus.projectChanged(ctx.projectDir);
+      res.json({ success: true, path: fullTo });
+    } catch (err) {
+      console.error('[file:copy]', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
   return router;
 }
 

package/src/api/index.js

@@ -9,3 +9,4 @@ export { createSystemRoutes } from './system.js';
 export { createRuntimeRoutes } from './runtime.js';
 export { createNotebookRoutes } from './notebook.js';
 export { createSettingsRoutes } from './settings.js';
+export { createVoiceRoutes } from './voice.js';

package/src/api/languagetool.js

@@ -0,0 +1,119 @@
+/**
+ * LanguageTool API routes
+ *
+ * Mirrors electronAPI.languagetool.*
+ */
+
+import { Router } from 'express';
+
+export function createLanguageToolRoutes(ctx) {
+  const router = Router();
+  const { languageToolService, languageToolPreferencesService } = ctx;
+
+  router.get('/status', async (req, res) => {
+    try {
+      res.json(await languageToolService.status());
+    } catch (err) {
+      console.error('[languagetool:status]', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  router.get('/languages', async (req, res) => {
+    try {
+      res.json(await languageToolService.languages());
+    } catch (err) {
+      console.error('[languagetool:languages]', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  router.post('/check', async (req, res) => {
+    try {
+      res.json(await languageToolService.check(req.body || {}));
+    } catch (err) {
+      console.error('[languagetool:check]', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  router.get('/prefs', async (req, res) => {
+    try {
+      const { documentPath, projectRoot } = req.query;
+      res.json(await languageToolPreferencesService.getForDocument({ documentPath, projectRoot }));
+    } catch (err) {
+      console.error('[languagetool:getPrefs]', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  router.post('/prefs', async (req, res) => {
+    try {
+      const { documentPath, patch = {}, projectRoot = null } = req.body || {};
+      res.json(await languageToolPreferencesService.setForDocument({ documentPath, patch, projectRoot }));
+    } catch (err) {
+      console.error('[languagetool:setPrefs]', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  router.post('/prefs/clear', async (req, res) => {
+    try {
+      const { documentPath, projectRoot = null } = req.body || {};
+      res.json(await languageToolPreferencesService.clearDocumentOverrides({ documentPath, projectRoot }));
+    } catch (err) {
+      console.error('[languagetool:clearPrefs]', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  router.get('/dictionary', (req, res) => {
+    try {
+      res.json(languageToolPreferencesService.getDictionary());
+    } catch (err) {
+      console.error('[languagetool:getDictionary]', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  router.post('/dictionary/add', (req, res) => {
+    try {
+      const { word } = req.body || {};
+      res.json(languageToolPreferencesService.addToDictionary(word));
+    } catch (err) {
+      console.error('[languagetool:addToDictionary]', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  router.post('/dictionary/remove', (req, res) => {
+    try {
+      const { word } = req.body || {};
+      res.json(languageToolPreferencesService.removeFromDictionary(word));
+    } catch (err) {
+      console.error('[languagetool:removeFromDictionary]', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  router.get('/defaults', (req, res) => {
+    try {
+      res.json(languageToolPreferencesService.getDefaults());
+    } catch (err) {
+      console.error('[languagetool:getDefaults]', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  router.post('/defaults', (req, res) => {
+    try {
+      const { patch = {} } = req.body || {};
+      res.json(languageToolPreferencesService.setDefaults(patch));
+    } catch (err) {
+      console.error('[languagetool:setDefaults]', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  return router;
+}

package/src/api/project.js

@@ -8,9 +8,8 @@
 import { Router } from 'express';
 import path from 'path';
 import fs from 'fs/promises';
-import { existsSync, readFileSync } from 'fs';
+import { existsSync } from 'fs';
 import { watch } from 'chokidar';
-import { Project } from 'mrmd-project';
 
 const DOC_EXTENSIONS = ['.md', '.qmd'];
 
@@ -30,25 +29,61 @@ function stripDocExtension(fileName) {
 }
 
 /**
- * Detect project from a file path
- * Returns { root, config } or null if not in a project
+ * Resolve project root from a file path without requiring mrmd.md.
  */
-function detectProject(filePath) {
-  // Use mrmd-project's findRoot to locate project root
-  const root = Project.findRoot(filePath, (dir) => existsSync(path.join(dir, 'mrmd.md')));
+function findGitRoot(startDir) {
+  let current = path.resolve(startDir || '/');
+  while (true) {
+    if (existsSync(path.join(current, '.git'))) return current;
+    const parent = path.dirname(current);
+    if (!parent || parent === current) break;
+    current = parent;
+  }
+  return null;
+}
 
-  if (!root) return null;
+async function hasDocsInDir(dir) {
+  try {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    return entries.some((entry) => entry.isFile() && isDocFile(entry.name));
+  } catch {
+    return false;
+  }
+}
 
-  // Read and parse mrmd.md config
+async function detectProject(filePath) {
+  const abs = path.resolve(filePath);
+  let startDir = abs;
   try {
-    const mrmdPath = path.join(root, 'mrmd.md');
-    const content = readFileSync(mrmdPath, 'utf8');
-    const config = Project.parseConfig(content);
-    return { root, config };
-  } catch (e) {
-    // mrmd.md exists but couldn't be read/parsed
-    return { root, config: {} };
+    const stat = await fs.stat(abs);
+    if (stat.isFile()) startDir = path.dirname(abs);
+  } catch {
+    if (path.extname(abs)) startDir = path.dirname(abs);
+  }
+
+  const gitRoot = findGitRoot(startDir);
+  if (gitRoot) {
+    return { root: gitRoot, config: { name: path.basename(gitRoot) || 'Project' } };
   }
+
+  let candidate = startDir;
+  let current = startDir;
+  const homeDir = path.resolve(process.env.HOME || '/');
+  for (let i = 0; i < 4; i++) {
+    const parent = path.dirname(current);
+    if (!parent || parent === current || parent === '/' || parent === homeDir) break;
+    if (await hasDocsInDir(parent)) {
+      candidate = parent;
+      current = parent;
+      continue;
+    }
+    break;
+  }
+
+  return {
+    root: candidate,
+    config: { name: path.basename(candidate) || 'Project' },
+  };
 }
 
 /**
@@ -75,7 +110,7 @@ export function createProjectRoutes(ctx) {
 
       // Detect project from file path
       const resolvedPath = path.isAbsolute(filePath) ? filePath : path.resolve(ctx.projectDir || process.cwd(), filePath);
-      const detected = detectProject(resolvedPath);
+      const detected = await detectProject(resolvedPath);
 
       if (detected) {
         // Get or start sync server for this project
@@ -164,7 +199,7 @@ export function createProjectRoutes(ctx) {
    * Mirrors: electronAPI.project.create(targetPath)
    *
    * Uses ProjectService.createProject() which:
-   * 1. Creates scaffold files (mrmd.md, index files)
+   * 1. Creates scaffold files (index + assets)
    * 2. Creates venv
    * 3. Installs mrmd-python
    */
@@ -202,6 +237,34 @@ export function createProjectRoutes(ctx) {
     }
   });
 
+  /**
+   * GET /api/project/raw-tree?root=...&showSystem=true&maxDepth=...
+   * Get raw file tree (all files, actual filenames) for file browser view.
+   * Mirrors: electronAPI.project.rawTree(root, showSystem, maxDepth)
+   */
+  router.get('/raw-tree', async (req, res) => {
+    try {
+      const root = req.query.root || ctx.projectDir;
+      const showSystem = req.query.showSystem === 'true';
+      const maxDepth = Number.isFinite(Number(req.query.maxDepth)) ? Number(req.query.maxDepth) : undefined;
+
+      if (!root) {
+        return res.status(400).json({ error: 'root query parameter required' });
+      }
+
+      // Use shared ProjectService implementation so Electron + server stay aligned.
+      const tree = await projectService.getRawTree(root, {
+        showSystem,
+        ...(Number.isInteger(maxDepth) && maxDepth >= 0 ? { maxDepth } : {}),
+      });
+
+      res.json(tree);
+    } catch (err) {
+      console.error('[project:raw-tree]', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
   /**
    * POST /api/project/invalidate
    * Invalidate cached project info
@@ -210,9 +273,11 @@ export function createProjectRoutes(ctx) {
   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);
+      const root = projectRoot || ctx.projectDir;
+      if (root) {
+        projectService.invalidate(root);
+      }
+      ctx.eventBus.projectChanged(root);
       res.json({ success: true });
     } catch (err) {
       console.error('[project:invalidate]', err);
@@ -243,7 +308,9 @@ export function createProjectRoutes(ctx) {
       });
 
       watcher.on('all', (event, filePath) => {
-        if (isDocFile(filePath)) {
+        const isDirectoryEvent = !path.extname(filePath || '');
+        if (isDocFile(filePath) || isDirectoryEvent) {
+          projectService.invalidate(watchPath);
           ctx.eventBus.projectChanged(watchPath);
         }
       });
@@ -283,29 +350,9 @@ export function createProjectRoutes(ctx) {
  */
 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' };
-  }
+  const detected = await detectProject(resolvedPath);
+  const projectRoot = detected?.root || path.dirname(resolvedPath);
+  const config = detected?.config || { name: path.basename(projectRoot) || 'Project' };
 
   // Build nav tree
   const navTree = await buildNavTree(projectRoot);
@@ -315,7 +362,7 @@ async function getProjectInfo(filePath, defaultRoot) {
 
   return {
     root: projectRoot,
-    config: mrmdConfig,
+    config,
     navTree,
     files,
     currentFile: resolvedPath,
@@ -337,67 +384,6 @@ function flattenNavTree(nodes, projectRoot) {
   return files;
 }
 
-/**
- * Parse mrmd.md config (from yaml config code blocks)
- */
-function parseMrmdConfig(content) {
-  const config = { venv: '.venv' };
-
-  // Find all ```yaml config blocks and merge them
-  const configBlockRegex = /```yaml\s+config\n([\s\S]*?)```/g;
-  let match;
-
-  while ((match = configBlockRegex.exec(content)) !== null) {
-    const yaml = match[1];
-
-    // Parse name
-    const nameMatch = yaml.match(/^name:\s*["']?([^"'\n]+)["']?/m);
-    if (nameMatch) {
-      config.name = nameMatch[1].trim();
-    }
-
-    // Parse venv (direct or under session.python)
-    const venvMatch = yaml.match(/^\s*venv:\s*["']?([^"'\n]+)["']?/m);
-    if (venvMatch) {
-      config.venv = venvMatch[1].trim();
-    }
-
-    // Parse session config
-    const sessionMatch = yaml.match(/^session:\n([\s\S]*?)(?=^[^\s]|\Z)/m);
-    if (sessionMatch) {
-      config.session = {};
-      const sessionYaml = sessionMatch[1];
-
-      // Parse python session
-      const pythonMatch = sessionYaml.match(/^\s+python:\n([\s\S]*?)(?=^\s+\w+:|\Z)/m);
-      if (pythonMatch) {
-        config.session.python = {};
-        const pyYaml = pythonMatch[1];
-        const pyVenv = pyYaml.match(/venv:\s*["']?([^"'\n]+)["']?/);
-        if (pyVenv) config.session.python.venv = pyVenv[1].trim();
-        const pyCwd = pyYaml.match(/cwd:\s*["']?([^"'\n]+)["']?/);
-        if (pyCwd) config.session.python.cwd = pyCwd[1].trim();
-        const pyName = pyYaml.match(/name:\s*["']?([^"'\n]+)["']?/);
-        if (pyName) config.session.python.name = pyName[1].trim();
-        const pyAutoStart = pyYaml.match(/auto_start:\s*(true|false)/);
-        if (pyAutoStart) config.session.python.auto_start = pyAutoStart[1] === 'true';
-      }
-    }
-  }
-
-  // Also check YAML frontmatter for backwards compatibility
-  const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
-  if (fmMatch) {
-    const yaml = fmMatch[1];
-    const venvMatch = yaml.match(/venv:\s*(.+)/);
-    if (venvMatch && !config.venv) {
-      config.venv = venvMatch[1].trim();
-    }
-  }
-
-  return config;
-}
-
 /**
  * Build navigation tree for a project
  */
@@ -437,7 +423,7 @@ async function buildNavTree(projectRoot, relativePath = '') {
           children,
         });
       }
-    } else if (isDocFile(entry.name) && entry.name !== 'mrmd.md') {
+    } else if (isDocFile(entry.name)) {
       nodes.push({
         isFolder: false,
         title: cleanName(stripDocExtension(entry.name)),
@@ -467,3 +453,4 @@ async function hasIndexFile(dirPath) {
 function cleanName(name) {
   return name.replace(/^\d+[-_.\s]*/, '');
 }
+