lemonade-interactive-loader 1.0.0

package/src/cli/setup-wizard.js

@@ -0,0 +1,243 @@
+const inquirer = require('inquirer');
+const { DEFAULTS, BACKEND_TYPES, LOG_LEVELS, RUN_MODES, HOSTS } = require('../config/constants');
+const { loadConfig, saveConfig } = require('../config');
+const { selectLlamaCppRelease, selectAsset, selectInstalledAssetPrompt, displayConfigSummary } = require('./prompts');
+const { downloadAndExtractLlamaCpp } = require('../services/asset-manager');
+const { inferBackendType } = require('../utils/system');
+
+/**
+ * Run the interactive setup wizard
+ * @param {boolean} isEdit - If true, use saved values as defaults
+ * @returns {Promise<Object>} Configuration object
+ */
+async function runSetupWizard(isEdit = false) {
+  console.log(isEdit ? '🍋 Edit Configuration From Saved' : '🍋 Setup Configuration From Defaults');
+  
+  const existingConfig = isEdit ? loadConfig() : {};
+  
+  // Q1: Local network exposure
+  const { exposeToNetwork } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'exposeToNetwork',
+      message: 'Do you want to expose the server to the local network?',
+      default: existingConfig.exposeToNetwork || DEFAULTS.EXPOSE_TO_NETWORK
+    }
+  ]);
+  
+  const host = exposeToNetwork ? HOSTS.ALL_INTERFACES : HOSTS.LOCALHOST;
+  
+  // Q2: Port selection
+  const { port } = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'port',
+      message: 'What port would you like the server to run on?',
+      default: existingConfig.port || DEFAULTS.PORT.toString(),
+      validate: (input) => !isNaN(input) && parseInt(input) > 0 && parseInt(input) < 65536 || 'Invalid port number (must be 1-65535)'
+    }
+  ]);
+  
+  // Q3: Logging level
+  const { logLevel } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'logLevel',
+      message: 'What logging level do you want?',
+      choices: [
+        { name: 'info (default)', value: LOG_LEVELS.INFO },
+        { name: 'debug (verbose)', value: LOG_LEVELS.DEBUG },
+        { name: 'warning (warnings only)', value: LOG_LEVELS.WARNING },
+        { name: 'error (errors only)', value: LOG_LEVELS.ERROR }
+      ],
+      default: existingConfig.logLevel || DEFAULTS.LOG_LEVEL
+    }
+  ]);
+  
+  // Q4: Custom model directory
+  const existingModelDir = existingConfig.modelDir;
+  const hasExistingModelDir = existingModelDir && existingModelDir !== 'None';
+  
+  const { useCustomModelDir } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'useCustomModelDir',
+      message: 'Is there another model directory to use? (example: LM Studio)',
+      default: false
+    }
+  ]);
+  
+  let finalModelDir;
+  
+  if (useCustomModelDir) {
+    const modelDirAnswer = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'modelDir',
+        message: 'Enter the model directory path:',
+        default: existingModelDir || './models'
+      }
+    ]);
+    finalModelDir = modelDirAnswer.modelDir;
+  } else {
+    finalModelDir = DEFAULTS.MODEL_DIR;
+  }
+  
+  // Q5: System tray vs headless
+  const { runMode } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'runMode',
+      message: 'Do you want a system tray or headless?',
+      choices: [
+        { name: 'system-tray (with system tray icon)', value: RUN_MODES.SYSTEM_TRAY },
+        { name: 'headless (background service)', value: RUN_MODES.HEADLESS }
+      ],
+      default: existingConfig.runMode || DEFAULTS.RUN_MODE
+    }
+  ]);
+  
+  // Q6: Custom llama.cpp args
+  const existingLlamacppArgs = existingConfig.llamacppArgs || '';
+  const hasExistingArgs = existingLlamacppArgs.length > 0;
+  
+  let finalLlamacppArgs;
+  
+  const { useCustomArgs } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'useCustomArgs',
+      message: 'Are there any llama.cpp args you need to set?',
+      default: hasExistingArgs
+    }
+  ]);
+  
+  if (useCustomArgs) {
+    const argsAnswer = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'llamacppArgs',
+        message: 'Enter llama.cpp arguments (comma-separated, e.g., --ctx-size 4096,--batch-size 512):',
+        default: existingLlamacppArgs
+      }
+    ]);
+    finalLlamacppArgs = argsAnswer.llamacppArgs;
+  } else {
+    finalLlamacppArgs = '';
+  }
+  
+  // Q7: Custom llama.cpp build
+  const existingCustomPath = existingConfig.customLlamacppPath || '';
+  const hasExistingBuild = existingCustomPath.length > 0;
+  
+  let customLlamacppPath;
+  let customBackendType = existingConfig.customBackendType || '';
+  let customServerPath = existingConfig.customServerPath || '';
+  let backend = existingConfig.backend || DEFAULTS.BACKEND;
+  
+  const { useCustomBuild } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'useCustomBuild',
+      message: 'Do you want to use a different build for llama cpp?',
+      default: hasExistingBuild
+    }
+  ]);
+  
+  if (useCustomBuild) {
+    const { useInstalled } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'useInstalled',
+        message: 'Use an already installed custom build?',
+        default: hasExistingBuild
+      }
+    ]);
+    
+    if (useInstalled) {
+      const installedAsset = await selectInstalledAssetPrompt();
+      
+      if (installedAsset) {
+        customLlamacppPath = installedAsset.installPath;
+        customBackendType = installedAsset.backendType;
+        customServerPath = installedAsset.serverPath;
+        backend = customBackendType;
+      } else {
+        customLlamacppPath = '';
+        customBackendType = '';
+        customServerPath = '';
+      }
+    } else {
+      console.log('\nFetching recent llama.cpp builds...');
+      const release = await selectLlamaCppRelease();
+      const asset = await selectAsset(release);
+      
+      const version = release.tag_name;
+      customLlamacppPath = await downloadAndExtractLlamaCpp(asset, version);
+      
+      customBackendType = inferBackendType(asset.name);
+      customServerPath = customLlamacppPath;
+      
+      console.log(`\n✓ Custom llama.cpp build installed at: ${customLlamacppPath}`);
+      console.log(`  Backend Type: ${customBackendType.toUpperCase()}`);
+    }
+  } else {
+    const { selectedBackend } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'selectedBackend',
+        message: 'Which llama.cpp backend to use?',
+        choices: [
+          { name: 'auto (automatically select best backend)', value: BACKEND_TYPES.AUTO },
+          { name: 'vulkan (GPU acceleration)', value: BACKEND_TYPES.VULKAN },
+          { name: 'rocm (AMD GPU acceleration)', value: BACKEND_TYPES.ROCM },
+          { name: 'cpu (CPU only)', value: BACKEND_TYPES.CPU }
+        ],
+        default: existingConfig.backend || DEFAULTS.BACKEND
+      }
+    ]);
+    
+    backend = selectedBackend;
+    customLlamacppPath = '';
+    customBackendType = '';
+    customServerPath = '';
+  }
+  
+  // Save configuration
+  const config = {
+    exposeToNetwork,
+    host,
+    port: parseInt(port),
+    logLevel,
+    backend,
+    modelDir: finalModelDir,
+    runMode,
+    llamacppArgs: finalLlamacppArgs,
+    customLlamacppPath,
+    customBackendType,
+    customServerPath,
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString()
+  };
+  
+  const { saveConfiguration } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'saveConfiguration',
+      message: 'Do you want to save this configuration for future use?',
+      default: true
+    }
+  ]);
+  
+  if (saveConfiguration) {
+    saveConfig(config);
+  }
+  
+  displayConfigSummary(config);
+  
+  return config;
+}
+
+module.exports = {
+  runSetupWizard
+};

package/src/config/constants.js

@@ -0,0 +1,83 @@
+const path = require('path');
+const os = require('os');
+
+// Configuration directories
+const USER_CONFIG_DIR = path.join(os.homedir(), '.lemonade-launcher');
+const USER_CONFIG_FILE = path.join(USER_CONFIG_DIR, 'config.json');
+const DEFAULT_LLAMACPP_INSTALL_DIR = path.join(os.homedir(), '.lemonade-launcher', 'llama-cpp');
+
+// GitHub API
+const GITHUB_RELEASES_URL = 'https://api.github.com/repos/ggml-org/llama.cpp/releases';
+const GITHUB_API_HEADERS = {
+  'User-Agent': 'lemonade-launcher',
+  'Accept': 'application/vnd.github.v3+json'
+};
+
+// Default lemonade-server paths by platform
+function getLemonadeServerDefaultPath() {
+  if (process.platform === 'win32') {
+    return path.join(os.homedir(), 'AppData', 'Local', 'lemonade_server', 'bin', 'lemonade-server.exe');
+  } else if (process.platform === 'darwin') {
+    return '/opt/homebrew/bin/lemonade-server';
+  } else {
+    return '/usr/local/bin/lemonade-server';
+  }
+}
+
+const LEMONADE_SERVER_DEFAULT_PATH = getLemonadeServerDefaultPath();
+
+// Supported backends
+const BACKEND_TYPES = {
+  AUTO: 'auto',
+  CPU: 'cpu',
+  CUDA: 'cuda',
+  ROCM: 'rocm',
+  VULKAN: 'vulkan',
+  SYCL: 'sycl',
+  OPENCL: 'opencl'
+};
+
+// Logging levels
+const LOG_LEVELS = {
+  DEBUG: 'debug',
+  INFO: 'info',
+  WARNING: 'warning',
+  ERROR: 'error'
+};
+
+// Run modes
+const RUN_MODES = {
+  HEADLESS: 'headless',
+  SYSTEM_TRAY: 'system-tray'
+};
+
+// Network configuration
+const HOSTS = {
+  LOCALHOST: '127.0.0.1',
+  ALL_INTERFACES: '0.0.0.0'
+};
+
+// Default values
+const DEFAULTS = {
+  PORT: 8080,
+  LOG_LEVEL: LOG_LEVELS.INFO,
+  HOST: HOSTS.LOCALHOST,
+  EXPOSE_TO_NETWORK: false,
+  RUN_MODE: RUN_MODES.SYSTEM_TRAY,
+  MODEL_DIR: 'None',
+  BACKEND: BACKEND_TYPES.AUTO
+};
+
+module.exports = {
+  USER_CONFIG_DIR,
+  USER_CONFIG_FILE,
+  DEFAULT_LLAMACPP_INSTALL_DIR,
+  GITHUB_RELEASES_URL,
+  GITHUB_API_HEADERS,
+  LEMONADE_SERVER_DEFAULT_PATH,
+  BACKEND_TYPES,
+  LOG_LEVELS,
+  RUN_MODES,
+  HOSTS,
+  DEFAULTS
+};

package/src/config/index.js

@@ -0,0 +1,49 @@
+const fs = require('fs');
+const { USER_CONFIG_DIR, USER_CONFIG_FILE } = require('./constants');
+
+/**
+ * Load user configuration from file
+ * @returns {Object} Configuration object or empty object if not found
+ */
+function loadConfig() {
+  if (!fs.existsSync(USER_CONFIG_FILE)) {
+    return {};
+  }
+
+  try {
+    const configData = fs.readFileSync(USER_CONFIG_FILE, 'utf-8');
+    return JSON.parse(configData);
+  } catch (error) {
+    console.warn(`Warning: Could not load config file: ${error.message}`);
+    return {};
+  }
+}
+
+/**
+ * Save user configuration to file
+ * @param {Object} config - Configuration object to save
+ */
+function saveConfig(config) {
+  if (!fs.existsSync(USER_CONFIG_DIR)) {
+    fs.mkdirSync(USER_CONFIG_DIR, { recursive: true });
+  }
+
+  fs.writeFileSync(USER_CONFIG_FILE, JSON.stringify(config, null, 2), 'utf-8');
+  console.log(`\n✓ Configuration saved to ${USER_CONFIG_FILE}`);
+}
+
+/**
+ * Reset configuration to defaults
+ */
+function resetConfig() {
+  if (fs.existsSync(USER_CONFIG_FILE)) {
+    fs.unlinkSync(USER_CONFIG_FILE);
+    console.log('Configuration reset successfully.');
+  }
+}
+
+module.exports = {
+  loadConfig,
+  saveConfig,
+  resetConfig
+};

package/src/index.js

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+
+/**
+ * Lemonade Launcher - Interactive CLI for managing llama.cpp builds and Lemonade Server
+ * 
+ * A professional, modular CLI tool for downloading llama.cpp releases and launching
+ * Lemonade Server with a user-friendly setup wizard.
+ */
+
+const { runCLI } = require('./cli/menu');
+
+/**
+ * Main entry point
+ */
+async function main() {
+  try {
+    await runCLI();
+  } catch (error) {
+    console.error('Error:', error.message);
+    process.exit(1);
+  }
+}
+
+// Export modules for programmatic use
+module.exports = {
+  // Config
+  loadConfig: require('./config').loadConfig,
+  saveConfig: require('./config').saveConfig,
+  resetConfig: require('./config').resetConfig,
+  
+  // Services
+  fetchAllReleases: require('./services/github').fetchAllReleases,
+  fetchLatestRelease: require('./services/github').fetchLatestRelease,
+  downloadFile: require('./services/download').downloadFile,
+  extractArchive: require('./services/download').extractArchive,
+  getAllInstalledAssets: require('./services/asset-manager').getAllInstalledAssets,
+  downloadAndExtractLlamaCpp: require('./services/asset-manager').downloadAndExtractLlamaCpp,
+  deleteInstalledAsset: require('./services/asset-manager').deleteInstalledAsset,
+  launchLemonadeServer: require('./services/server').launchLemonadeServer,
+  
+  // Utils
+  detectSystem: require('./utils/system').detectSystem,
+  formatBytes: require('./utils/system').formatBytes,
+  inferBackendType: require('./utils/system').inferBackendType,
+  categorizeAsset: require('./utils/system').categorizeAsset,
+  getAssetType: require('./utils/system').getAssetType,
+  filterServerAssets: require('./utils/system').filterServerAssets,
+  findLlamaServer: require('./utils/system').findLlamaServer,
+  
+  // CLI
+  runSetupWizard: require('./cli/setup-wizard').runSetupWizard,
+  runCLI: require('./cli/menu').runCLI
+};
+
+// Run if executed directly
+if (require.main === module) {
+  main();
+}

package/src/services/asset-manager.js

@@ -0,0 +1,159 @@
+const fs = require('fs');
+const path = require('path');
+const { DEFAULT_LLAMACPP_INSTALL_DIR } = require('../config/constants');
+const { inferBackendType, findLlamaServer } = require('../utils/system');
+const { downloadFile, extractArchive } = require('./download');
+
+/**
+ * Check if a specific asset is already installed
+ * @param {string} version - Release version
+ * @param {string} assetName - Asset filename
+ * @returns {boolean}
+ */
+function isAssetInstalled(version, assetName) {
+  const installDir = path.join(
+    DEFAULT_LLAMACPP_INSTALL_DIR, 
+    version, 
+    assetName.replace('.tar.gz', '').replace('.zip', '')
+  );
+  const markerFile = path.join(installDir, `.installed-${assetName}`);
+  return fs.existsSync(markerFile);
+}
+
+/**
+ * Mark an asset as installed
+ * @param {string} version - Release version
+ * @param {string} assetName - Asset filename
+ */
+function markAssetAsInstalled(version, assetName) {
+  const archiveBaseName = assetName.endsWith('.tar.gz') 
+    ? assetName.replace('.tar.gz', '')
+    : assetName.replace('.zip', '');
+  
+  const installDir = path.join(DEFAULT_LLAMACPP_INSTALL_DIR, version, archiveBaseName);
+  const markerFile = path.join(installDir, `.installed-${assetName}`);
+  fs.writeFileSync(markerFile, new Date().toISOString(), 'utf-8');
+}
+
+/**
+ * Get all installed assets sorted by install time (newest first)
+ * @returns {Array} Array of installed asset info
+ */
+function getAllInstalledAssets() {
+  const installedAssets = [];
+  
+  if (!fs.existsSync(DEFAULT_LLAMACPP_INSTALL_DIR)) {
+    return installedAssets;
+  }
+  
+  const versions = fs.readdirSync(DEFAULT_LLAMACPP_INSTALL_DIR);
+  
+  for (const version of versions) {
+    const versionPath = path.join(DEFAULT_LLAMACPP_INSTALL_DIR, version);
+    
+    if (!fs.statSync(versionPath).isDirectory()) continue;
+    
+    const assetDirs = fs.readdirSync(versionPath);
+    
+    for (const assetDir of assetDirs) {
+      const assetPath = path.join(versionPath, assetDir);
+      
+      if (!fs.statSync(assetPath).isDirectory()) continue;
+      
+      const entries = fs.readdirSync(assetPath);
+      const markerFiles = entries.filter(e => e.startsWith('.installed-'));
+      
+      for (const markerFile of markerFiles) {
+        const assetName = markerFile.replace('.installed-', '');
+        const installTime = fs.readFileSync(path.join(assetPath, markerFile), 'utf-8');
+        const backendType = inferBackendType(assetName);
+        
+        installedAssets.push({
+          version,
+          assetName,
+          installPath: assetPath,
+          installTime,
+          backendType
+        });
+      }
+    }
+  }
+  
+  installedAssets.sort((a, b) => new Date(b.installTime) - new Date(a.installTime));
+  
+  return installedAssets;
+}
+
+/**
+ * Get the llama-server binary path for an installed asset
+ * @param {string} installPath - Installation directory path
+ * @returns {string|null} Path to llama-server
+ */
+function getLlamaServerPath(installPath) {
+  return findLlamaServer(installPath);
+}
+
+/**
+ * Download and extract llama.cpp build to user directory
+ * @param {Object} asset - Asset object from GitHub API
+ * @param {string} version - Release version
+ * @returns {Promise<string>} Installation directory path
+ */
+async function downloadAndExtractLlamaCpp(asset, version) {
+  const archiveName = asset.name;
+  const archiveBaseName = archiveName.endsWith('.tar.gz') 
+    ? archiveName.replace('.tar.gz', '')
+    : archiveName.replace('.zip', '');
+  
+  const installDir = path.join(DEFAULT_LLAMACPP_INSTALL_DIR, version, archiveBaseName);
+  
+  if (isAssetInstalled(version, asset.name)) {
+    console.log(`\n✓ ${asset.name} is already installed at ${installDir}`);
+    return installDir;
+  }
+  
+  if (!fs.existsSync(installDir)) {
+    fs.mkdirSync(installDir, { recursive: true });
+  }
+  
+  const archivePath = path.join(installDir, archiveName);
+  
+  console.log(`\nDownloading ${archiveName}...`);
+  await downloadFile(asset.browser_download_url, archivePath);
+  
+  console.log(`Extracting to ${installDir}...`);
+  await extractArchive(archivePath, installDir);
+  
+  if (fs.existsSync(archivePath)) {
+    fs.unlinkSync(archivePath);
+  }
+  
+  markAssetAsInstalled(version, asset.name);
+  
+  console.log(`✓ ${asset.name} installed to ${installDir}`);
+  return installDir;
+}
+
+/**
+ * Delete an installed asset
+ * @param {string} installPath - Installation directory path
+ * @returns {boolean} Success status
+ */
+function deleteInstalledAsset(installPath) {
+  try {
+    fs.rmSync(installPath, { recursive: true, force: true });
+    return true;
+  } catch (error) {
+    console.error(`Error deleting asset: ${error.message}`);
+    return false;
+  }
+}
+
+module.exports = {
+  isAssetInstalled,
+  markAssetAsInstalled,
+  getAllInstalledAssets,
+  getLlamaServerPath,
+  downloadAndExtractLlamaCpp,
+  deleteInstalledAsset
+};

package/src/services/download.js

@@ -0,0 +1,102 @@
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+const http = require('http');
+const tar = require('tar');
+const AdmZip = require('adm-zip');
+const { getAssetType } = require('../utils/system');
+
+/**
+ * Download a file from URL
+ * @param {string} url - Download URL
+ * @param {string} outputPath - Local output path
+ * @returns {Promise<void>}
+ */
+function downloadFile(url, outputPath) {
+  return new Promise((resolve, reject) => {
+    const protocol = url.startsWith('https') ? https : http;
+    
+    console.log(`Downloading: ${path.basename(outputPath)}`);
+    
+    const file = fs.createWriteStream(outputPath);
+    
+    const req = protocol.get(url, { headers: { 'User-Agent': 'lemonade-launcher' } }, (res) => {
+      if (res.statusCode === 302 || res.statusCode === 301) {
+        downloadFile(res.headers.location, outputPath)
+          .then(resolve)
+          .catch(reject);
+        return;
+      }
+      
+      if (res.statusCode !== 200) {
+        reject(new Error(`Download failed with status ${res.statusCode}`));
+        return;
+      }
+      
+      const totalSize = parseInt(res.headers['content-length'], 10) || 0;
+      let downloadedSize = 0;
+      
+      res.on('data', (chunk) => {
+        downloadedSize += chunk.length;
+        if (totalSize > 0) {
+          const percent = ((downloadedSize / totalSize) * 100).toFixed(1);
+          process.stdout.write(`\rProgress: ${percent}%`);
+        }
+      });
+      
+      res.pipe(file);
+      
+      file.on('finish', () => {
+        file.close();
+        console.log('\rDownload complete!         ');
+        resolve();
+      });
+    });
+    
+    req.on('error', (e) => {
+      fs.unlink(outputPath, () => {});
+      reject(new Error(`Download error: ${e.message}`));
+    });
+    
+    req.setTimeout(300000, () => {
+      req.destroy();
+      fs.unlink(outputPath, () => {});
+      reject(new Error('Download timed out'));
+    });
+  });
+}
+
+/**
+ * Extract downloaded archive
+ * @param {string} archivePath - Path to archive file
+ * @param {string} extractDir - Directory to extract to
+ * @returns {Promise<void>}
+ */
+async function extractArchive(archivePath, extractDir) {
+  return new Promise((resolve, reject) => {
+    const assetType = getAssetType(archivePath);
+    
+    console.log('Extracting archive...');
+    
+    if (assetType === 'tar') {
+      tar.x({
+        file: archivePath,
+        cwd: extractDir,
+        strip: 1
+      }).then(() => {
+        resolve();
+      }).catch(reject);
+    } else if (assetType === 'zip') {
+      const zip = new AdmZip(archivePath);
+      zip.extractAllTo(extractDir, true);
+      resolve();
+    } else {
+      reject(new Error(`Unsupported archive type: ${assetType}`));
+    }
+  });
+}
+
+module.exports = {
+  downloadFile,
+  extractArchive
+};