mrmd-server 0.2.6 → 0.2.7

package/src/vendor/utils/python.js

@@ -0,0 +1,309 @@
+/**
+ * Python environment utilities for mrmd-electron
+ *
+ * Shared functions for Python/venv management used by main process and services.
+ */
+
+import { spawn, execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { fileURLToPath } from 'url';
+import { PYTHON_DEPS, getPythonInstallArgs } from '../config.js';
+import { findUv, ensureUv } from './uv-installer.js';
+import {
+  getVenvPython,
+  getVenvExecutable,
+  getVenvBinDir,
+  getPythonCommand,
+} from './platform.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+function resolveLocalMrmdPythonSource() {
+  const explicit = process.env.MRMD_PYTHON_DEV;
+  if (explicit && fs.existsSync(path.join(explicit, 'pyproject.toml'))) {
+    return { path: explicit, editable: true, source: 'env' };
+  }
+
+  try {
+    const sibling = path.resolve(__dirname, '../../../mrmd-python');
+    if (fs.existsSync(path.join(sibling, 'pyproject.toml'))) {
+      return { path: sibling, editable: true, source: 'sibling' };
+    }
+  } catch {
+    // ignore
+  }
+
+  try {
+    if (process.resourcesPath) {
+      const bundled = path.join(process.resourcesPath, 'mrmd-python');
+      if (fs.existsSync(path.join(bundled, 'pyproject.toml'))) {
+        return { path: bundled, editable: false, source: 'bundled' };
+      }
+    }
+  } catch {
+    // ignore
+  }
+
+  return null;
+}
+
+// Re-export for backwards compatibility
+export { findUv, ensureUv };
+
+/**
+ * Find uv binary (sync version for use in constructors)
+ * @deprecated Use findUv from uv-installer.js instead
+ * @returns {string|null} Path to uv or null if not found
+ */
+export function findUvSync() {
+  return findUv();
+}
+
+/**
+ * Install all required Python packages in a virtual environment
+ *
+ * Uses uv (auto-installed if missing). Installs packages according to
+ * the version compatibility matrix in config.js.
+ *
+ * @param {string} venvPath - Path to the virtual environment
+ * @param {object} options - Options
+ * @param {string} options.localDev - Local development path (from MRMD_PYTHON_DEV env)
+ * @param {boolean} options.fullInstall - Install all packages including optional (default: true)
+ * @param {function} options.onProgress - Progress callback (stage, detail)
+ * @returns {Promise<{ success: boolean, packages: string[] }>}
+ */
+export async function installMrmdPython(venvPath, options = {}) {
+  const {
+    localDev = process.env.MRMD_PYTHON_DEV,
+    fullInstall = true,
+    onProgress
+  } = options;
+
+  const localSource = localDev
+    ? { path: localDev, editable: true, source: 'explicit' }
+    : resolveLocalMrmdPythonSource();
+
+  const report = (stage, detail) => {
+    console.log(`[python] ${stage}: ${detail}`);
+    if (onProgress) onProgress(stage, detail);
+  };
+
+  const pythonPath = getVenvPython(venvPath);
+
+  // Validate venv exists
+  if (!fs.existsSync(pythonPath)) {
+    throw new Error(`Python not found at ${pythonPath}. Is this a valid venv?`);
+  }
+
+  // Ensure uv is installed (auto-install if missing)
+  report('checking', 'uv installation');
+  const uvPath = await ensureUv({
+    onProgress: (stage, detail) => report(`uv-${stage}`, detail)
+  });
+
+  // Build package list from version matrix
+  const packages = [];
+
+  if (localSource?.path) {
+    // Prefer bundled/local mrmd-python source so packaged apps don't depend on
+    // PyPI for MRMD's own runtime package. Keep third-party deps from PyPI.
+    const installArgs = getPythonInstallArgs().filter((spec) => !spec.startsWith('mrmd-python'));
+    packages.push(...installArgs);
+    if (localSource.editable) {
+      packages.push('-e', localSource.path);
+    } else {
+      packages.push(localSource.path);
+    }
+    report('mode', `${localSource.source} mrmd-python + PyPI deps (${localSource.path})`);
+  } else {
+    // Production: install from PyPI with version constraints
+    const installArgs = getPythonInstallArgs();
+    packages.push(...installArgs);
+    report('mode', `PyPI (${installArgs.length} packages)`);
+  }
+
+  // Run uv pip install
+  const args = ['pip', 'install', '--python', pythonPath, ...packages];
+
+  report('installing', packages.filter(p => !p.startsWith('-')).join(', '));
+
+  return new Promise((resolve, reject) => {
+    console.log(`[python] Running: ${uvPath} ${args.join(' ')}`);
+
+    const proc = spawn(uvPath, args, {
+      cwd: path.dirname(venvPath),
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: { ...process.env, VIRTUAL_ENV: venvPath },
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    proc.stdout.on('data', (d) => {
+      stdout += d.toString();
+      const line = d.toString().trim();
+      if (line) console.log('[uv]', line);
+    });
+
+    proc.stderr.on('data', (d) => {
+      stderr += d.toString();
+      const line = d.toString().trim();
+      if (line) console.error('[uv]', line);
+    });
+
+    proc.on('error', (e) => {
+      reject(new Error(`Failed to run uv: ${e.message}`));
+    });
+
+    proc.on('close', (code) => {
+      if (code === 0) {
+        report('complete', 'all packages installed');
+        resolve({
+          success: true,
+          packages: Object.keys(PYTHON_DEPS)
+        });
+      } else {
+        reject(new Error(`uv pip install failed (code ${code}): ${(stderr || stdout).slice(-500)}`));
+      }
+    });
+  });
+}
+
+/**
+ * Install mrmd-python only (legacy function for backwards compatibility)
+ * @deprecated Use installMrmdPython with fullInstall option
+ */
+export async function installMrmdPythonOnly(venvPath, options = {}) {
+  return installMrmdPython(venvPath, { ...options, fullInstall: false });
+}
+
+/**
+ * Create a Python virtual environment
+ *
+ * Tries uv first (faster), falls back to python -m venv.
+ *
+ * @param {string} venvPath - Path for the new venv
+ * @returns {Promise<void>}
+ */
+export function createVenv(venvPath) {
+  return new Promise((resolve, reject) => {
+    const uvPath = findUvSync();
+
+    if (uvPath) {
+      // Try uv first (faster)
+      const proc = spawn(uvPath, ['venv', venvPath], {
+        stdio: ['pipe', 'pipe', 'pipe'],
+      });
+
+      let stderr = '';
+      proc.stderr.on('data', (d) => { stderr += d.toString(); });
+
+      proc.on('close', (code) => {
+        if (code === 0) {
+          resolve();
+        } else {
+          reject(new Error(`uv venv failed: ${stderr}`));
+        }
+      });
+
+      proc.on('error', () => {
+        // uv failed, fall back to python -m venv
+        createVenvWithPython(venvPath).then(resolve).catch(reject);
+      });
+    } else {
+      // No uv, use python -m venv
+      createVenvWithPython(venvPath).then(resolve).catch(reject);
+    }
+  });
+}
+
+/**
+ * Create venv using python -m venv
+ */
+function createVenvWithPython(venvPath) {
+  return new Promise((resolve, reject) => {
+    const pythonCmd = getPythonCommand();
+    const proc = spawn(pythonCmd, ['-m', 'venv', venvPath], {
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+
+    let stderr = '';
+    proc.stderr.on('data', (d) => { stderr += d.toString(); });
+
+    proc.on('error', (e) => {
+      reject(new Error(`Failed to create venv: ${e.message}`));
+    });
+
+    proc.on('close', (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`python -m venv failed (code ${code}): ${stderr}`));
+      }
+    });
+  });
+}
+
+/**
+ * Get information about a Python environment
+ *
+ * @param {string} envPath - Path to the environment
+ * @param {string} envType - Type of environment ('system', 'venv', 'conda', 'pyenv')
+ * @returns {object} Environment info
+ */
+export function getEnvInfo(envPath, envType) {
+  let pythonVersion = null;
+  let hasMrmdPython = false;
+  let hasPython = false;
+  let projectName = '';
+  let name = '';
+
+  try {
+    hasPython = fs.existsSync(getVenvPython(envPath));
+
+    // Get Python version from pyvenv.cfg
+    const pyvenvCfg = path.join(envPath, 'pyvenv.cfg');
+    if (fs.existsSync(pyvenvCfg)) {
+      const content = fs.readFileSync(pyvenvCfg, 'utf8');
+      const match = content.match(/version\s*=\s*(\d+\.\d+)/);
+      if (match) pythonVersion = match[1];
+    }
+
+    // Check if mrmd-python is installed
+    hasMrmdPython = fs.existsSync(getVenvExecutable(envPath, 'mrmd-python'));
+
+    // Set name based on environment type
+    switch (envType) {
+      case 'system':
+        name = 'System Python';
+        projectName = 'system';
+        break;
+      case 'conda':
+        name = path.basename(envPath);
+        projectName = 'conda';
+        break;
+      case 'pyenv':
+        name = path.basename(envPath);
+        projectName = 'pyenv';
+        break;
+      default: // venv
+        name = path.basename(envPath);
+        projectName = path.basename(path.dirname(envPath));
+    }
+  } catch (e) {
+    console.warn(`[python] Error getting env info for ${envPath}:`, e.message);
+  }
+
+  return {
+    path: envPath,
+    pythonVersion,
+    hasMrmdPython,
+    hasPython,
+    projectName,
+    name,
+    envType,
+  };
+}

package/src/vendor/utils/uv-installer.js

@@ -0,0 +1,299 @@
+/**
+ * UV Auto-Installer for mrmd-electron
+ *
+ * Automatically downloads and installs uv if not present.
+ * uv is required for fast Python package management.
+ */
+
+import { spawn, execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import https from 'https';
+import { createWriteStream, createReadStream } from 'fs';
+import { pipeline } from 'stream/promises';
+import { createGunzip } from 'zlib';
+
+import {
+  UV_PATHS,
+  UV_DOWNLOAD_URLS,
+  UV_INSTALL_DIR,
+  UV_INSTALL_PATH,
+} from '../config.js';
+
+/**
+ * Find existing uv installation
+ * @returns {string|null} Path to uv binary or null
+ */
+export function findUv() {
+  // Check configured paths
+  for (const loc of UV_PATHS) {
+    if (fs.existsSync(loc)) {
+      return loc;
+    }
+  }
+
+  // Check our install location
+  if (fs.existsSync(UV_INSTALL_PATH)) {
+    return UV_INSTALL_PATH;
+  }
+
+  // Try PATH via 'which' (Unix) or 'where' (Windows)
+  try {
+    const cmd = process.platform === 'win32' ? 'where' : 'which';
+    const result = execSync(`${cmd} uv`, {
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'ignore']
+    }).trim().split('\n')[0];
+
+    if (result && fs.existsSync(result)) {
+      return result;
+    }
+  } catch {
+    // uv not in PATH
+  }
+
+  return null;
+}
+
+/**
+ * Get the download URL for current platform
+ * @returns {string|null} Download URL or null if unsupported
+ */
+function getDownloadUrl() {
+  const platform = process.platform;
+  const arch = process.arch;
+
+  const key = `${platform}-${arch}`;
+  return UV_DOWNLOAD_URLS[key] || null;
+}
+
+/**
+ * Download a file to a local path
+ * @param {string} url - URL to download
+ * @param {string} dest - Destination path
+ * @param {function} onProgress - Progress callback (received, total)
+ * @returns {Promise<void>}
+ */
+function downloadFile(url, dest, onProgress) {
+  return new Promise((resolve, reject) => {
+    const file = createWriteStream(dest);
+
+    const request = (url) => {
+      https.get(url, (response) => {
+        // Handle redirects
+        if (response.statusCode === 301 || response.statusCode === 302) {
+          request(response.headers.location);
+          return;
+        }
+
+        if (response.statusCode !== 200) {
+          reject(new Error(`Download failed: HTTP ${response.statusCode}`));
+          return;
+        }
+
+        const total = parseInt(response.headers['content-length'], 10);
+        let received = 0;
+
+        response.on('data', (chunk) => {
+          received += chunk.length;
+          if (onProgress) onProgress(received, total);
+        });
+
+        response.pipe(file);
+
+        file.on('finish', () => {
+          file.close();
+          resolve();
+        });
+      }).on('error', (err) => {
+        fs.unlink(dest, () => {});
+        reject(err);
+      });
+    };
+
+    request(url);
+  });
+}
+
+/**
+ * Extract tar.gz archive
+ * @param {string} archive - Path to archive
+ * @param {string} dest - Destination directory
+ * @returns {Promise<void>}
+ */
+async function extractTarGz(archive, dest) {
+  // Use tar command (available on Unix and modern Windows)
+  return new Promise((resolve, reject) => {
+    const proc = spawn('tar', ['-xzf', archive, '-C', dest], {
+      stdio: ['pipe', 'pipe', 'pipe']
+    });
+
+    let stderr = '';
+    proc.stderr.on('data', (d) => { stderr += d.toString(); });
+
+    proc.on('close', (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`tar extract failed: ${stderr}`));
+    });
+
+    proc.on('error', reject);
+  });
+}
+
+/**
+ * Extract zip archive (Windows)
+ * @param {string} archive - Path to archive
+ * @param {string} dest - Destination directory
+ * @returns {Promise<void>}
+ */
+async function extractZip(archive, dest) {
+  // Use PowerShell on Windows
+  return new Promise((resolve, reject) => {
+    const proc = spawn('powershell', [
+      '-Command',
+      `Expand-Archive -Path '${archive}' -DestinationPath '${dest}' -Force`
+    ], {
+      stdio: ['pipe', 'pipe', 'pipe']
+    });
+
+    let stderr = '';
+    proc.stderr.on('data', (d) => { stderr += d.toString(); });
+
+    proc.on('close', (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`zip extract failed: ${stderr}`));
+    });
+
+    proc.on('error', reject);
+  });
+}
+
+/**
+ * Install uv automatically
+ * @param {object} options - Options
+ * @param {function} options.onProgress - Progress callback (stage, detail)
+ * @returns {Promise<string>} Path to installed uv binary
+ */
+export async function installUv(options = {}) {
+  const { onProgress } = options;
+
+  const report = (stage, detail) => {
+    console.log(`[uv-install] ${stage}: ${detail}`);
+    if (onProgress) onProgress(stage, detail);
+  };
+
+  // Check if already installed
+  const existing = findUv();
+  if (existing) {
+    report('found', existing);
+    return existing;
+  }
+
+  // Get download URL
+  const url = getDownloadUrl();
+  if (!url) {
+    throw new Error(`Unsupported platform: ${process.platform}-${process.arch}`);
+  }
+
+  report('downloading', url);
+
+  // Create temp directory
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'uv-install-'));
+  const isZip = url.endsWith('.zip');
+  const archivePath = path.join(tmpDir, isZip ? 'uv.zip' : 'uv.tar.gz');
+
+  try {
+    // Download
+    await downloadFile(url, archivePath, (received, total) => {
+      const pct = total ? Math.round((received / total) * 100) : 0;
+      report('downloading', `${pct}%`);
+    });
+
+    report('extracting', archivePath);
+
+    // Extract
+    if (isZip) {
+      await extractZip(archivePath, tmpDir);
+    } else {
+      await extractTarGz(archivePath, tmpDir);
+    }
+
+    // Find the uv binary in extracted files
+    const uvBinary = process.platform === 'win32' ? 'uv.exe' : 'uv';
+    let extractedUv = null;
+
+    // Search for uv in tmpDir (might be in a subdirectory)
+    const searchDir = (dir) => {
+      for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          const found = searchDir(fullPath);
+          if (found) return found;
+        } else if (entry.name === uvBinary) {
+          return fullPath;
+        }
+      }
+      return null;
+    };
+
+    extractedUv = searchDir(tmpDir);
+
+    if (!extractedUv) {
+      throw new Error('uv binary not found in archive');
+    }
+
+    report('installing', UV_INSTALL_PATH);
+
+    // Ensure install directory exists
+    fs.mkdirSync(UV_INSTALL_DIR, { recursive: true });
+
+    // Move uv to install location
+    fs.copyFileSync(extractedUv, UV_INSTALL_PATH);
+
+    // Make executable (Unix)
+    if (process.platform !== 'win32') {
+      fs.chmodSync(UV_INSTALL_PATH, 0o755);
+    }
+
+    report('complete', UV_INSTALL_PATH);
+
+    return UV_INSTALL_PATH;
+
+  } finally {
+    // Cleanup temp directory
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  }
+}
+
+/**
+ * Ensure uv is installed, installing if necessary
+ * @param {object} options - Options passed to installUv
+ * @returns {Promise<string>} Path to uv binary
+ */
+export async function ensureUv(options = {}) {
+  const existing = findUv();
+  if (existing) {
+    return existing;
+  }
+
+  return installUv(options);
+}
+
+/**
+ * Get uv version
+ * @param {string} uvPath - Path to uv binary
+ * @returns {string|null} Version string or null
+ */
+export function getUvVersion(uvPath) {
+  try {
+    const result = execSync(`"${uvPath}" --version`, {
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'ignore']
+    }).trim();
+    // Output is like "uv 0.5.14"
+    return result.split(' ')[1] || result;
+  } catch {
+    return null;
+  }
+}