lemonade-interactive-loader 1.0.0

package/src/services/github.js

@@ -0,0 +1,72 @@
+const https = require('https');
+const http = require('http');
+const { GITHUB_RELEASES_URL, GITHUB_API_HEADERS } = require('../config/constants');
+
+/**
+ * Fetch all releases from llama.cpp GitHub repository
+ * @param {number} limit - Maximum number of releases to fetch
+ * @returns {Promise<Array>} Array of release data
+ */
+async function fetchAllReleases(limit = 20) {
+  return new Promise((resolve, reject) => {
+    const options = {
+      hostname: 'api.github.com',
+      path: `/repos/ggml-org/llama.cpp/releases?per_page=${limit}`,
+      method: 'GET',
+      headers: GITHUB_API_HEADERS
+    };
+
+    const protocol = https;
+    const req = protocol.request(options, (res) => {
+      let data = '';
+
+      if (res.statusCode !== 200) {
+        reject(new Error(`Request failed with status code ${res.statusCode}`));
+        res.resume();
+        return;
+      }
+
+      res.on('data', (chunk) => {
+        data += chunk;
+      });
+
+      res.on('end', () => {
+        try {
+          resolve(JSON.parse(data));
+        } catch (e) {
+          reject(new Error(`Failed to parse response: ${e.message}`));
+        }
+      });
+    });
+
+    req.on('error', (e) => {
+      reject(new Error(`Request error: ${e.message}`));
+    });
+
+    req.setTimeout(30000, () => {
+      req.destroy();
+      reject(new Error('Request timed out'));
+    });
+
+    req.end();
+  });
+}
+
+/**
+ * Fetch the latest release from llama.cpp GitHub repository
+ * @returns {Promise<Object>} The latest release data
+ */
+async function fetchLatestRelease() {
+  const releases = await fetchAllReleases(1);
+  
+  if (releases.length === 0) {
+    throw new Error('No releases found');
+  }
+  
+  return releases[0];
+}
+
+module.exports = {
+  fetchAllReleases,
+  fetchLatestRelease
+};

package/src/services/server.js

@@ -0,0 +1,174 @@
+const fs = require('fs');
+const { execSync } = require('child_process');
+const { LEMONADE_SERVER_DEFAULT_PATH } = require('../config/constants');
+const { findLlamaServer } = require('../utils/system');
+const { getLlamaServerPath } = require('./asset-manager');
+
+/**
+ * Build server command arguments
+ * @param {Object} config - Server configuration
+ * @returns {Array} Array of command arguments
+ */
+function buildServerArgs(config) {
+  const { host, port, logLevel, modelDir, llamacppArgs } = config;
+  const args = [
+    'serve',
+    '--log-level', logLevel || 'info',
+    '--host', host,
+    '--port', port.toString()
+  ];
+  
+  if (modelDir && modelDir !== 'None') {
+    args.push('--extra-models-dir', modelDir);
+  }
+  
+  if (llamacppArgs) {
+    args.push('--llamacpp-args', `"${llamacppArgs}"`);
+  }
+  
+  return args;
+}
+
+/**
+ * Format command for cross-platform display
+ * @param {string} serverPath - Path to server binary
+ * @param {Array} args - Command arguments
+ * @param {Object} envVars - Environment variables
+ * @returns {string} Formatted command string
+ */
+function formatCommand(serverPath, args, envVars = {}) {
+  const isWindows = process.platform === 'win32';
+  
+  if (isWindows) {
+    let cmd = '';
+    for (const [key, value] of Object.entries(envVars)) {
+      if (value) {
+        cmd += `set ${key}="${value}" && `;
+      }
+    }
+    
+    const quotedPath = serverPath.includes(' ') ? `"${serverPath}"` : serverPath;
+    const quotedArgs = args.map(arg => arg.includes(' ') ? `"${arg}"` : arg);
+    
+    return cmd + quotedPath + ' ' + quotedArgs.join(' ');
+  } else {
+    let cmd = '';
+    for (const [key, value] of Object.entries(envVars)) {
+      if (value) {
+        cmd += `${key}="${value}" `;
+      }
+    }
+    
+    const quotedArgs = args.map(arg => arg.includes(' ') ? `"${arg}"` : arg);
+    return cmd + serverPath + ' ' + quotedArgs.join(' ');
+  }
+}
+
+/**
+ * Launch lemonade-server with the specified configuration
+ * @param {Object} config - Server configuration
+ */
+async function launchLemonadeServer(config) {
+  const { 
+    host, 
+    port, 
+    logLevel, 
+    modelDir, 
+    llamacppArgs,
+    runMode,
+    customLlamacppPath,
+    customBackendType,
+    customServerPath,
+    backend
+  } = config;
+  
+  console.log('\n=== Launching Lemonade Server ===\n');
+  console.log(`Host: ${host}`);
+  console.log(`Port: ${port}`);
+  console.log(`Log Level: ${logLevel}`);
+  console.log(`Backend: ${backend || 'auto'}`);
+  console.log(`Model Directory: ${modelDir || 'default'}`);
+  console.log(`Run Mode: ${runMode || 'headless'}`);
+  if (llamacppArgs) {
+    console.log(`llama.cpp Args: ${llamacppArgs}`);
+  }
+  if (customLlamacppPath) {
+    console.log(`Custom llama.cpp: ${customLlamacppPath}`);
+  }
+  console.log('');
+  
+  const serverPath = LEMONADE_SERVER_DEFAULT_PATH;
+  const args = buildServerArgs(config);
+  
+  let backendTypeToUse = customBackendType;
+  if (!backendTypeToUse && backend && backend !== 'auto') {
+    backendTypeToUse = backend;
+  }
+  
+  let serverBinary = customServerPath;
+  if (!serverBinary && customLlamacppPath) {
+    serverBinary = findLlamaServer(customLlamacppPath);
+  }
+  
+  const envVars = {};
+  if (backendTypeToUse && backendTypeToUse !== 'auto' && serverBinary) {
+    const backendEnvVar = `LEMONADE_LLAMACPP_${backendTypeToUse.toUpperCase()}_BIN`;
+    // Point to the actual binary, not the directory
+    const binaryPath = findLlamaServer(customLlamacppPath || serverBinary);
+    envVars[backendEnvVar] = binaryPath;
+  }
+  
+  if (!fs.existsSync(serverPath)) {
+    console.error(`\n❌ Error: lemonade-server not found at ${serverPath}`);
+    console.log('\n📋 Expected Location:');
+    console.log(`   ${serverPath}`);
+    console.log('\n📥 How to Install Lemonade Server:');
+    console.log('   Visit: https://lemonade-server.ai');
+    
+    const command = formatCommand(serverPath, args, envVars);
+    console.log('\n🔧 Once installed, this is the command that will be run:');
+    console.log(`   ${command}`);
+    
+    if (Object.keys(envVars).length > 0) {
+      console.log('\n💡 Environment Variable Set:');
+      for (const [key, value] of Object.entries(envVars)) {
+        console.log(`   ${key}=${value}`);
+      }
+    }
+    
+    console.log('\n💡 After installing lemonade-server, run this tool again to start the server.');
+    console.log('');
+    return;
+  }
+  
+  for (const [key, value] of Object.entries(envVars)) {
+    process.env[key] = value;
+    console.log(`Set ${key}=${value}`);
+  }
+  
+  if (Object.keys(envVars).length === 0) {
+    console.log('Using default backend configuration');
+  }
+  
+  console.log(`\nCommand: ${serverPath} ${args.join(' ')}`);
+  console.log('\nStarting server...\n');
+  
+  try {
+    const command = formatCommand(serverPath, args, {});
+    execSync(command, {
+      stdio: 'inherit',
+      env: process.env
+    });
+  } catch (error) {
+    console.error(`Server exited with error code: ${error.status}`);
+    if (error.status !== null) {
+      process.exit(error.status);
+    }
+  }
+}
+
+module.exports = {
+  buildServerArgs,
+  formatCommand,
+  launchLemonadeServer
+};

package/src/utils/system.js

@@ -0,0 +1,150 @@
+const os = require('os');
+const path = require('path');
+const fs = require('fs');
+
+/**
+ * Detect user's system for suggested asset
+ * @returns {Object} System information
+ */
+function detectSystem() {
+  const platform = process.platform;
+  const arch = process.arch;
+  
+  let osType = 'unknown';
+  let archType = arch;
+  
+  if (platform === 'win32') {
+    osType = 'windows';
+    if (arch === 'x64') archType = 'x64';
+    else if (arch === 'arm64') archType = 'arm64';
+    else if (arch === 'ia32') archType = 'x86';
+  } else if (platform === 'darwin') {
+    osType = 'macos';
+    if (arch === 'arm64') archType = 'arm64';
+    else if (arch === 'x64') archType = 'x64';
+  } else if (platform === 'linux') {
+    osType = 'linux';
+    if (arch === 'x64') archType = 'x64';
+    else if (arch === 'arm64') archType = 'arm64';
+    else if (arch === 'arm') archType = 'armv7l';
+  }
+  
+  return { platform, arch: archType, osType };
+}
+
+/**
+ * Format bytes to human readable string
+ * @param {number} bytes - Bytes to format
+ * @returns {string} Formatted byte string
+ */
+function formatBytes(bytes) {
+  if (bytes === 0) return '0 B';
+  const k = 1024;
+  const sizes = ['B', 'KB', 'MB', 'GB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+}
+
+/**
+ * Infer backend type from asset name
+ * @param {string} assetName - Asset filename
+ * @returns {string} Backend type
+ */
+function inferBackendType(assetName) {
+  const name = assetName.toLowerCase();
+  
+  if (name.includes('rocm') || name.includes('hip')) return 'rocm';
+  if (name.includes('vulkan')) return 'vulkan';
+  if (name.includes('cuda')) return 'cuda';
+  if (name.includes('sycl')) return 'sycl';
+  if (name.includes('opencl')) return 'opencl';
+  if (name.includes('cpu')) return 'cpu';
+  
+  return 'cpu';
+}
+
+/**
+ * Categorize asset based on its name
+ * @param {string} assetName - Asset filename
+ * @returns {string} Category
+ */
+function categorizeAsset(assetName) {
+  const name = assetName.toLowerCase();
+  
+  if (name.includes('cuda')) return 'CUDA';
+  if (name.includes('rocm') || name.includes('hip')) return 'ROCm';
+  if (name.includes('vulkan')) return 'Vulkan';
+  if (name.includes('sycl')) return 'SYCL';
+  if (name.includes('opencl')) return 'OpenCL';
+  if (name.includes('cpu')) return 'CPU';
+  if (name.includes('macos') || name.includes('xcframework')) return 'macOS';
+  if (name.includes('ubuntu') || name.includes('linux')) return 'Linux';
+  if (name.includes('win') || name.includes('windows')) return 'Windows';
+  
+  return 'Other';
+}
+
+/**
+ * Determine asset type (zip or tar.gz)
+ * @param {string} assetName - Asset filename
+ * @returns {string} 'zip', 'tar', or 'unknown'
+ */
+function getAssetType(assetName) {
+  if (assetName.endsWith('.zip')) return 'zip';
+  if (assetName.endsWith('.tar.gz')) return 'tar';
+  return 'unknown';
+}
+
+/**
+ * Filter assets for llama-server binaries only
+ * @param {Array} assets - Array of asset objects
+ * @returns {Array} Filtered assets
+ */
+function filterServerAssets(assets) {
+  return assets.filter(asset => {
+    const name = asset.name.toLowerCase();
+    return name.includes('bin') && (name.endsWith('.zip') || name.endsWith('.tar.gz'));
+  });
+}
+
+/**
+ * Find the llama-server binary in extracted directory
+ * @param {string} extractDir - Directory to search
+ * @returns {string|null} Path to llama-server or null
+ */
+function findLlamaServer(extractDir) {
+  const candidates = process.platform === 'win32' 
+    ? ['llama-server.exe'] 
+    : ['llama-server'];
+  
+  function searchDir(dir) {
+    if (!fs.existsSync(dir)) return null;
+    
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      
+      if (entry.isDirectory()) {
+        const result = searchDir(fullPath);
+        if (result) return result;
+      } else if (entry.isFile() && candidates.includes(entry.name)) {
+        return fullPath;
+      }
+    }
+    
+    return null;
+  }
+  
+  return searchDir(extractDir);
+}
+
+module.exports = {
+  detectSystem,
+  formatBytes,
+  inferBackendType,
+  categorizeAsset,
+  getAssetType,
+  filterServerAssets,
+  findLlamaServer
+};