@edgible-team/cli 1.2.4 → 1.2.8

package/dist/commands/ai/helpers.js

@@ -0,0 +1,1470 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectModel = selectModel;
+exports.setupLocalOllama = setupLocalOllama;
+exports.setupPlatformIntegration = setupPlatformIntegration;
+exports.displaySetupSummary = displaySetupSummary;
+exports.checkOllamaInstalled = checkOllamaInstalled;
+exports.installOllama = installOllama;
+exports.checkModelAvailable = checkModelAvailable;
+exports.pullModel = pullModel;
+exports.startOllama = startOllama;
+exports.checkOllamaRunning = checkOllamaRunning;
+exports.checkOllamaListeningAddress = checkOllamaListeningAddress;
+exports.fixOllamaBinding = fixOllamaBinding;
+exports.stopOllama = stopOllama;
+exports.normalizeModelName = normalizeModelName;
+exports.checkDockerInstalled = checkDockerInstalled;
+exports.checkHasModels = checkHasModels;
+exports.detectOllamaUrlForDocker = detectOllamaUrlForDocker;
+exports.getComposeDirectory = getComposeDirectory;
+exports.startOpenWebUI = startOpenWebUI;
+exports.stopOpenWebUI = stopOpenWebUI;
+exports.checkOpenWebUIRunning = checkOpenWebUIRunning;
+exports.getOpenWebUIInfo = getOpenWebUIInfo;
+exports.testModelConnectivity = testModelConnectivity;
+exports.verifyModelOnEndpoint = verifyModelOnEndpoint;
+exports.checkOllamaUrlReachable = checkOllamaUrlReachable;
+exports.checkUrlReachable = checkUrlReachable;
+const chalk_1 = __importDefault(require("chalk"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const child_process_1 = require("child_process");
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const instances_1 = require("../../services/instances");
+const SystemCapabilityDetector_1 = require("../../detection/SystemCapabilityDetector");
+const config_validator_1 = require("../utils/config-validator");
+const compose_constants_1 = require("../../generated/compose-constants");
+async function selectModel(providedModel, capabilities) {
+    let selectedModel = providedModel;
+    if (!selectedModel) {
+        // Filter to only excellent and good recommendations
+        const suitableModels = capabilities.recommendedModels.filter((m) => m.suitability === 'excellent' || m.suitability === 'good');
+        if (suitableModels.length === 0) {
+            console.log(chalk_1.default.yellow('⚠ No models are well-suited for your system.'));
+            console.log(chalk_1.default.yellow('You can still run smaller models, but performance may be limited.\n'));
+            const allModels = capabilities.recommendedModels.map((m) => ({
+                name: `${m.modelName} (${m.size}) - ${m.suitability}`,
+                value: m.modelName.toLowerCase().replace(/\s+/g, '-').replace(/[()]/g, ''),
+            }));
+            // Add custom model option
+            allModels.push({
+                name: 'Enter custom model name',
+                value: '__custom__',
+            });
+            const answer = await inquirer_1.default.prompt([
+                {
+                    type: 'list',
+                    name: 'model',
+                    message: 'Select a model to use:',
+                    choices: allModels,
+                },
+            ]);
+            if (answer.model === '__custom__') {
+                const customAnswer = await inquirer_1.default.prompt([
+                    {
+                        type: 'input',
+                        name: 'model',
+                        message: 'Enter Ollama model name (e.g., deepseek-r1:8b, llama3.2:3b):',
+                        validate: (input) => {
+                            if (!input || input.trim().length === 0) {
+                                return 'Model name cannot be empty';
+                            }
+                            return true;
+                        },
+                    },
+                ]);
+                selectedModel = customAnswer.model.trim();
+            }
+            else {
+                selectedModel = answer.model;
+            }
+        }
+        else {
+            console.log(chalk_1.default.green('Recommended models for your system:\n'));
+            suitableModels.forEach((model) => {
+                const icon = model.suitability === 'excellent' ? '✓' : '•';
+                const color = model.suitability === 'excellent' ? chalk_1.default.green : chalk_1.default.cyan;
+                console.log(color(`  ${icon} ${model.modelName} (${model.size})`));
+                console.log(chalk_1.default.gray(`    ${model.reasoning}\n`));
+            });
+            const modelChoices = suitableModels.map((m) => ({
+                name: `${m.modelName} (${m.size}) - ${m.suitability === 'excellent' ? 'Recommended' : 'Good fit'}`,
+                value: m.modelName.toLowerCase().replace(/\s+/g, '-').replace(/[()]/g, ''),
+            }));
+            // Add option to see all models
+            modelChoices.push({
+                name: 'Show all models (including marginal/insufficient)',
+                value: '__all__',
+            });
+            // Add custom model option
+            modelChoices.push({
+                name: 'Enter custom model name',
+                value: '__custom__',
+            });
+            const answer = await inquirer_1.default.prompt([
+                {
+                    type: 'list',
+                    name: 'model',
+                    message: 'Select a model to use:',
+                    choices: modelChoices,
+                },
+            ]);
+            if (answer.model === '__custom__') {
+                const customAnswer = await inquirer_1.default.prompt([
+                    {
+                        type: 'input',
+                        name: 'model',
+                        message: 'Enter Ollama model name (e.g., deepseek-r1:8b, llama3.2:3b):',
+                        validate: (input) => {
+                            if (!input || input.trim().length === 0) {
+                                return 'Model name cannot be empty';
+                            }
+                            return true;
+                        },
+                    },
+                ]);
+                selectedModel = customAnswer.model.trim();
+            }
+            else if (answer.model === '__all__') {
+                const allModels = capabilities.recommendedModels.map((m) => ({
+                    name: `${m.modelName} (${m.size}) - ${m.suitability}`,
+                    value: m.modelName.toLowerCase().replace(/\s+/g, '-').replace(/[()]/g, ''),
+                }));
+                // Add custom model option to all models list too
+                allModels.push({
+                    name: 'Enter custom model name',
+                    value: '__custom__',
+                });
+                const allAnswer = await inquirer_1.default.prompt([
+                    {
+                        type: 'list',
+                        name: 'model',
+                        message: 'Select a model to use:',
+                        choices: allModels,
+                    },
+                ]);
+                if (allAnswer.model === '__custom__') {
+                    const customAnswer = await inquirer_1.default.prompt([
+                        {
+                            type: 'input',
+                            name: 'model',
+                            message: 'Enter Ollama model name (e.g., deepseek-r1:8b, llama3.2:3b):',
+                            validate: (input) => {
+                                if (!input || input.trim().length === 0) {
+                                    return 'Model name cannot be empty';
+                                }
+                                return true;
+                            },
+                        },
+                    ]);
+                    selectedModel = customAnswer.model.trim();
+                }
+                else {
+                    selectedModel = allAnswer.model;
+                }
+            }
+            else {
+                selectedModel = answer.model;
+            }
+        }
+    }
+    // Normalize model name (Ollama uses lowercase with dashes)
+    if (!selectedModel) {
+        throw new Error('No model selected');
+    }
+    // If it's already a custom model (contains : or /), use as-is
+    // Otherwise normalize it (recommended models need to be mapped to Ollama format)
+    let ollamaModelName;
+    if (selectedModel.includes(':') || selectedModel.includes('/')) {
+        // Custom model name format (e.g., deepseek-r1:14b, llama3.2:3b, or org/model:tag)
+        ollamaModelName = selectedModel;
+    }
+    else {
+        // Normalize recommended model names to Ollama format (e.g., deepseek-r1-14b -> deepseek-r1:14b)
+        ollamaModelName = normalizeModelName(selectedModel);
+    }
+    return ollamaModelName;
+}
+/**
+ * Setup local Ollama installation and configuration
+ */
+async function setupLocalOllama(options) {
+    // Step 1: Check if Ollama is installed
+    console.log(chalk_1.default.blue('Step 1: Checking Ollama installation...\n'));
+    const isOllamaInstalled = await checkOllamaInstalled();
+    if (!isOllamaInstalled) {
+        let shouldInstall = options.autoInstall || false;
+        if (!shouldInstall) {
+            const answer = await inquirer_1.default.prompt([
+                {
+                    type: 'confirm',
+                    name: 'install',
+                    message: 'Ollama is not installed. Would you like to install it now?',
+                    default: true,
+                },
+            ]);
+            shouldInstall = answer.install;
+        }
+        if (shouldInstall) {
+            console.log(chalk_1.default.yellow('Installing Ollama...\n'));
+            await installOllama();
+            console.log(chalk_1.default.green('✓ Ollama installed successfully\n'));
+        }
+        else {
+            throw new Error('Ollama is required but not installed. Please install it manually from https://ollama.com');
+        }
+    }
+    else {
+        console.log(chalk_1.default.green('✓ Ollama is already installed\n'));
+    }
+    // Step 2: Discover system capabilities
+    console.log(chalk_1.default.blue('Step 2: Discovering system capabilities...\n'));
+    const capabilities = await SystemCapabilityDetector_1.SystemCapabilityDetector.detectCapabilities();
+    // Show GPU driver support status
+    if (capabilities.gpuDriverSupport.ollamaGpuReady) {
+        console.log(chalk_1.default.green('✓ GPU acceleration is ready for Ollama'));
+        if (capabilities.gpuDriverSupport.ollamaGpuReason) {
+            console.log(chalk_1.default.gray(`  ${capabilities.gpuDriverSupport.ollamaGpuReason}\n`));
+        }
+    }
+    else {
+        console.log(chalk_1.default.yellow('⚠ GPU acceleration not detected - Ollama may run in CPU mode'));
+        if (capabilities.gpuDriverSupport.ollamaGpuReason) {
+            console.log(chalk_1.default.gray(`  ${capabilities.gpuDriverSupport.ollamaGpuReason}\n`));
+        }
+    }
+    // Step 5: Start Ollama service
+    // console.log(chalk.blue('Step 5: Starting Ollama service...\n'));
+    // await startOllama();
+    //
+    // // Step 6: Verify Ollama is running
+    // console.log(chalk.blue('Step 6: Verifying Ollama is running...\n'));
+    // const isRunning = await checkOllamaRunning();
+    //
+    // if (!isRunning) {
+    //   throw new Error('Ollama service failed to start. Please check the logs.');
+    // }
+    //
+    // console.log(chalk.green('✓ Ollama is running\n'));
+    //
+    // // Step 6.5: Check and fix Ollama binding if needed
+    // console.log(chalk.blue('Step 6.5: Checking Ollama network binding...\n'));
+    // const listeningAddress = await checkOllamaListeningAddress();
+    //
+    // if (listeningAddress === '127.0.0.1') {
+    //   console.log(chalk.yellow('⚠ Ollama is listening on localhost only (127.0.0.1:11434)'));
+    //   console.log(chalk.gray('  This will prevent Docker containers and network access from reaching Ollama.\n'));
+    //   console.log(chalk.yellow('  Reconfiguring Ollama to listen on all interfaces (0.0.0.0:11434)...\n'));
+    //
+    //   const fixed = await fixOllamaBinding();
+    //   if (fixed) {
+    //     // Wait a moment and verify it's now on 0.0.0.0
+    //     await new Promise((resolve) => setTimeout(resolve, 2000));
+    //     const newAddress = await checkOllamaListeningAddress();
+    //     if (newAddress === '0.0.0.0') {
+    //       console.log(chalk.green('✓ Ollama reconfigured to listen on 0.0.0.0:11434\n'));
+    //     } else {
+    //       console.log(chalk.yellow('⚠ Could not verify binding change. Ollama may need manual configuration.\n'));
+    //     }
+    //   } else {
+    //     console.log(chalk.yellow('⚠ Could not automatically reconfigure Ollama binding.\n'));
+    //     console.log(chalk.gray('  Please manually set OLLAMA_HOST=0.0.0.0:11434 and restart Ollama.\n'));
+    //   }
+    // } else if (listeningAddress === '0.0.0.0') {
+    //   console.log(chalk.green('✓ Ollama is listening on all interfaces (0.0.0.0:11434)\n'));
+    // } else {
+    //   console.log(chalk.gray('  Could not determine Ollama binding address (this is usually fine)\n'));
+    // }
+    //
+    // Step 7: Test model connectivity
+    // console.log(chalk.blue('Step 7: Testing model connectivity...\n'));
+    // const modelWorks = await testModelConnectivity(ollamaModelName);
+    //
+    // if (modelWorks) {
+    //   console.log(chalk.green('✓ Model is accessible and ready to use\n'));
+    // } else {
+    //   console.log(chalk.yellow('⚠ Model may not be fully loaded yet\n'));
+    //   console.log(chalk.gray(`  This is normal for large models. The model will load on first use.\n`));
+    // }
+    //
+    console.log(chalk_1.default.green('✅ Phase 1: Local Ollama Setup Complete!\n'));
+    return { capabilities };
+}
+/**
+ * Setup platform integration (create applications)
+ */
+async function setupPlatformIntegration(options) {
+    const { model, capabilities, logger: funcLogger } = options;
+    // Always require auth and organization for platform integration
+    try {
+        (0, config_validator_1.validateConfig)(instances_1.configManager, {
+            requireAuth: true,
+            requireOrganization: true,
+            requireDeviceId: true,
+        });
+    }
+    catch (error) {
+        console.log(chalk_1.default.yellow('\n⚠ Platform integration requires authentication'));
+        console.log(chalk_1.default.blue('\nPlease login first:'));
+        console.log(chalk_1.default.gray('  edgible auth login\n'));
+        console.log(chalk_1.default.gray('Then run setup again to continue.\n'));
+        throw error;
+    }
+    // Get device ID from config (same device as agent)
+    const deviceId = (0, config_validator_1.requireDeviceId)(instances_1.configManager);
+    const deviceInfo = await instances_1.edgibleService.getDevice(deviceId);
+    const deviceName = deviceInfo.device?.name || deviceId;
+    console.log(chalk_1.default.blue('\n📡 Creating Platform Applications\n'));
+    // Step 3: Select model based on recommendations (before creating application)
+    console.log(chalk_1.default.blue('Step 3: Selecting model...\n'));
+    const ollamaModelName = await selectModel(model, capabilities);
+    console.log(chalk_1.default.blue(`\nSelected model: ${ollamaModelName}\n`));
+    // Step 7: Create Ollama API Application
+    console.log(chalk_1.default.blue('Step 7: Creating Ollama API application...\n'));
+    console.log(chalk_1.default.gray(`  Device: ${deviceName} (${deviceId.substring(0, 8)}...)\n`));
+    console.log(chalk_1.default.gray(`  Gateway: None (local/internal access only)\n`));
+    console.log(chalk_1.default.gray(`  Protocol: HTTPS\n`));
+    const ollamaResult = await createOllamaApplication({
+        modelName: ollamaModelName,
+        deviceId: deviceId,
+        configManager: instances_1.configManager,
+        applicationService: instances_1.applicationService,
+        gatewayService: instances_1.gatewayService,
+        edgibleService: instances_1.edgibleService,
+        logger: instances_1.logger,
+    });
+    const createdOllamaApp = ollamaResult.app;
+    // Ensure URL has https:// protocol
+    const ollamaUrl = ollamaResult.url.startsWith('http://') || ollamaResult.url.startsWith('https://')
+        ? ollamaResult.url
+        : `https://${ollamaResult.url}`;
+    console.log(chalk_1.default.green('✓ Ollama API application created'));
+    console.log(chalk_1.default.cyan(`  URL: ${ollamaUrl}\n`));
+    // Step 8: Verify endpoint is accessible (retry mechanism)
+    console.log(chalk_1.default.blue('Step 8: Verifying endpoint is accessible...\n'));
+    console.log(chalk_1.default.gray(`  Checking ${ollamaUrl}/api/tags...\n`));
+    let endpointAccessible = false;
+    const maxRetries = 20;
+    const retryDelay = 5000; // 5 seconds
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+        try {
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), 5000);
+            const response = await (0, node_fetch_1.default)(`${ollamaUrl}/api/tags`, {
+                method: 'GET',
+                signal: controller.signal,
+            });
+            clearTimeout(timeout);
+            if (response.ok) {
+                endpointAccessible = true;
+                console.log(chalk_1.default.green(`✓ Endpoint is accessible (attempt ${attempt}/${maxRetries})\n`));
+                break;
+            }
+        }
+        catch (error) {
+            // Endpoint not ready yet, continue retrying
+            if (attempt < maxRetries) {
+                console.log(chalk_1.default.gray(`  Attempt ${attempt}/${maxRetries} failed, retrying in ${retryDelay / 1000} seconds...\n`));
+                await new Promise((resolve) => setTimeout(resolve, retryDelay));
+            }
+        }
+    }
+    if (!endpointAccessible) {
+        console.log(chalk_1.default.yellow(`⚠ Endpoint not accessible after ${maxRetries} attempts\n`));
+        console.log(chalk_1.default.gray(`  The application may still be starting. This can take several minutes.\n`));
+        console.log(chalk_1.default.gray(`  You can check status with: curl ${ollamaUrl}/api/tags\n`));
+    }
+    // Step 4: Check if model is already pulled
+    console.log(chalk_1.default.blue('Step 4: Checking if model is available...\n'));
+    const isModelAvailable = await checkModelAvailable(ollamaModelName);
+    if (!isModelAvailable) {
+        console.log(chalk_1.default.yellow(`Model ${ollamaModelName} is not available locally.`));
+        const answer = await inquirer_1.default.prompt([
+            {
+                type: 'confirm',
+                name: 'pull',
+                message: `Would you like to download ${ollamaModelName} now? (This may take a while)`,
+                default: true,
+            },
+        ]);
+        if (answer.pull) {
+            console.log(chalk_1.default.yellow(`\nDownloading ${ollamaModelName}...\n`));
+            await pullModel(ollamaModelName);
+            console.log(chalk_1.default.green(`✓ Model ${ollamaModelName} downloaded successfully\n`));
+        }
+        else {
+            throw new Error(`Model ${ollamaModelName} is not available. Please pull it manually with: ollama pull ${ollamaModelName}`);
+        }
+    }
+    else {
+        console.log(chalk_1.default.green(`✓ Model ${ollamaModelName} is available\n`));
+    }
+    // Step 9: Create Open WebUI Application
+    console.log(chalk_1.default.blue('Step 9: Creating Open WebUI application...\n'));
+    console.log(chalk_1.default.gray(`  Device: ${deviceName} (${deviceId.substring(0, 8)}...)\n`));
+    console.log(chalk_1.default.gray(`  Gateway: Managed Gateway\n`));
+    console.log(chalk_1.default.gray(`  Protocol: HTTPS\n`));
+    console.log(chalk_1.default.gray(`  Connected to Ollama: ${ollamaUrl}\n`));
+    const webUIResult = await createOpenWebUIApplication({
+        ollamaUrl: ollamaUrl,
+        deviceId: deviceId,
+        configManager: instances_1.configManager,
+        applicationService: instances_1.applicationService,
+        gatewayService: instances_1.gatewayService,
+        edgibleService: instances_1.edgibleService,
+        logger: instances_1.logger,
+    });
+    const createdWebUIApp = webUIResult.app;
+    const webUIUrl = webUIResult.url;
+    console.log(chalk_1.default.green('✓ Open WebUI application created'));
+    console.log(chalk_1.default.cyan(`  URL: ${webUIUrl}\n`));
+    return {
+        ollamaUrl,
+        webUIUrl,
+        createdOllamaApp,
+        createdWebUIApp,
+        deviceName,
+        deviceId,
+        ollamaModelName,
+    };
+}
+/**
+ * Display setup summary
+ */
+function displaySetupSummary(options) {
+    const { ollamaModelName, ollamaUrl, webUIUrl, deviceName, deviceId, createdOllamaApp, createdWebUIApp } = options;
+    console.log(chalk_1.default.blue('\n🎉 AI Setup Complete!\n'));
+    console.log(chalk_1.default.white('📋 Summary:\n'));
+    console.log(chalk_1.default.gray(`  Model: ${ollamaModelName}`));
+    console.log(chalk_1.default.gray(`  Ollama API: ${ollamaUrl} (local/internal only)`));
+    if (webUIUrl) {
+        console.log(chalk_1.default.gray(`  Open WebUI: ${webUIUrl} (public via managed gateway)`));
+    }
+    console.log(chalk_1.default.gray(`  Device: ${deviceName} (${deviceId.substring(0, 8)}...)`));
+    if (createdOllamaApp || createdWebUIApp) {
+        console.log(chalk_1.default.white('\n📱 Created Applications:\n'));
+        if (createdOllamaApp) {
+            console.log(chalk_1.default.gray(`  • ollama-api (${createdOllamaApp.id}) - No gateway (local only)`));
+        }
+        if (createdWebUIApp) {
+            console.log(chalk_1.default.gray(`  • open-webui (${createdWebUIApp.id}) - Managed gateway (public)`));
+        }
+    }
+    console.log(chalk_1.default.white('\n🔧 Next Steps:\n'));
+    console.log(chalk_1.default.gray(`  • Test endpoint: curl ${ollamaUrl}/api/tags`));
+    console.log(chalk_1.default.gray(`  • Test model: edgible ai test --model ${ollamaModelName}`));
+    console.log(chalk_1.default.gray('  • Status: edgible ai status'));
+    console.log(chalk_1.default.gray('  • List apps: edgible application list'));
+    if (createdOllamaApp) {
+        console.log(chalk_1.default.gray('  • Teardown: edgible ai teardown --remove-apps'));
+    }
+}
+/**
+ * Check if Ollama is installed
+ */
+async function checkOllamaInstalled() {
+    try {
+        (0, child_process_1.execSync)('ollama --version', { encoding: 'utf8', timeout: 2000, stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Install Ollama based on platform
+ */
+async function installOllama() {
+    const platform = os.platform();
+    try {
+        if (platform === 'linux') {
+            // Use official Ollama install script
+            (0, child_process_1.execSync)('curl -fsSL https://ollama.com/install.sh | sh', {
+                encoding: 'utf8',
+                stdio: 'inherit',
+            });
+        }
+        else if (platform === 'darwin') {
+            // macOS - check for Homebrew
+            try {
+                (0, child_process_1.execSync)('brew --version', { encoding: 'utf8', timeout: 2000, stdio: 'ignore' });
+                (0, child_process_1.execSync)('brew install ollama', {
+                    encoding: 'utf8',
+                    stdio: 'inherit',
+                });
+            }
+            catch {
+                // Fallback to manual install instructions
+                console.log(chalk_1.default.yellow('Homebrew not found. Please install Ollama manually:'));
+                console.log(chalk_1.default.gray('  Visit: https://ollama.com/download\n'));
+                throw new Error('Ollama installation requires Homebrew or manual installation');
+            }
+        }
+        else if (platform === 'win32') {
+            // Windows - use winget or provide instructions
+            try {
+                (0, child_process_1.execSync)('winget --version', { encoding: 'utf8', timeout: 2000, stdio: 'ignore' });
+                (0, child_process_1.execSync)('winget install Ollama.Ollama', {
+                    encoding: 'utf8',
+                    stdio: 'inherit',
+                });
+            }
+            catch {
+                console.log(chalk_1.default.yellow('winget not found. Please install Ollama manually:'));
+                console.log(chalk_1.default.gray('  Visit: https://ollama.com/download\n'));
+                throw new Error('Ollama installation requires winget or manual installation');
+            }
+        }
+        else {
+            throw new Error(`Unsupported platform: ${platform}`);
+        }
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('Failed to install Ollama:'), error);
+        throw error;
+    }
+}
+/**
+ * Check if a model is available locally
+ */
+async function checkModelAvailable(modelName) {
+    try {
+        const output = (0, child_process_1.execSync)('ollama list', { encoding: 'utf8', timeout: 5000 });
+        // Check if model name appears in the list
+        return output.toLowerCase().includes(modelName.toLowerCase());
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Pull a model from Ollama
+ */
+async function pullModel(modelName) {
+    try {
+        (0, child_process_1.execSync)(`OLLAMA_HOST=127.0.0.1:11435 ollama pull ${modelName}`, {
+            encoding: 'utf8',
+            stdio: 'inherit',
+        });
+    }
+    catch (error) {
+        console.error(chalk_1.default.red(`Failed to pull model ${modelName}:`), error);
+        throw error;
+    }
+}
+/**
+ * Start Ollama service
+ * Configures Ollama to listen on 0.0.0.0:11434 so Docker containers can access it
+ */
+async function startOllama() {
+    const platform = os.platform();
+    try {
+        if (platform === 'linux') {
+            // Check for systemd service (user or system)
+            let serviceType = null;
+            let serviceName = 'ollama';
+            // Check user service first
+            try {
+                (0, child_process_1.execSync)('systemctl --user is-enabled ollama > /dev/null 2>&1', { encoding: 'utf8', timeout: 2000 });
+                serviceType = 'user';
+            }
+            catch {
+                // Check system service
+                try {
+                    (0, child_process_1.execSync)('systemctl is-enabled ollama > /dev/null 2>&1', { encoding: 'utf8', timeout: 2000 });
+                    serviceType = 'system';
+                }
+                catch {
+                    // No systemd service found
+                }
+            }
+            if (serviceType) {
+                // Configure systemd service to listen on all interfaces
+                const systemctlCmd = serviceType === 'user' ? 'systemctl --user' : 'sudo systemctl';
+                const serviceFile = serviceType === 'user'
+                    ? `${os.homedir()}/.config/systemd/user/ollama.service.d/override.conf`
+                    : '/etc/systemd/system/ollama.service.d/override.conf';
+                const serviceDir = path.dirname(serviceFile);
+                try {
+                    // Create override directory if it doesn't exist
+                    if (!fs.existsSync(serviceDir)) {
+                        (0, child_process_1.execSync)(`mkdir -p "${serviceDir}"`, { encoding: 'utf8' });
+                    }
+                    // Check if override already has OLLAMA_HOST
+                    let needsUpdate = true;
+                    if (fs.existsSync(serviceFile)) {
+                        const content = fs.readFileSync(serviceFile, 'utf8');
+                        if (content.includes('OLLAMA_HOST=0.0.0.0:11434')) {
+                            needsUpdate = false;
+                        }
+                    }
+                    if (needsUpdate) {
+                        // Write override file
+                        const overrideContent = `[Service]
+Environment="OLLAMA_HOST=0.0.0.0:11434"
+`;
+                        fs.writeFileSync(serviceFile, overrideContent);
+                        console.log(chalk_1.default.gray(`Configured systemd service to listen on 0.0.0.0:11434\n`));
+                    }
+                    // Reload and restart
+                    (0, child_process_1.execSync)(`${systemctlCmd} daemon-reload`, { encoding: 'utf8', timeout: 3000 });
+                    (0, child_process_1.execSync)(`${systemctlCmd} restart ollama`, { encoding: 'utf8', timeout: 5000 });
+                    await new Promise((resolve) => setTimeout(resolve, 2000));
+                    console.log(chalk_1.default.gray('Started Ollama via systemd listening on 0.0.0.0:11434 (accessible to Docker)\n'));
+                    return;
+                }
+                catch (error) {
+                    console.log(chalk_1.default.yellow(`⚠ Could not configure systemd service: ${error instanceof Error ? error.message : 'Unknown error'}`));
+                    console.log(chalk_1.default.gray('Falling back to manual start...\n'));
+                    // Fall through to manual start
+                }
+            }
+            // Fallback: start ollama serve in background with OLLAMA_HOST set
+            try {
+                // Kill any existing ollama processes first (if not managed by systemd)
+                try {
+                    (0, child_process_1.execSync)('pkill -f "ollama serve"', { encoding: 'utf8', timeout: 2000, stdio: 'ignore' });
+                    await new Promise((resolve) => setTimeout(resolve, 1000));
+                }
+                catch {
+                    // Ignore if no process to kill
+                }
+                // Start Ollama with host binding to all interfaces
+                (0, child_process_1.execSync)('OLLAMA_HOST=0.0.0.0:11434 nohup ollama serve > /dev/null 2>&1 &', {
+                    encoding: 'utf8',
+                    timeout: 1000,
+                    shell: '/bin/bash'
+                });
+                // Wait a bit for it to start
+                await new Promise((resolve) => setTimeout(resolve, 2000));
+                console.log(chalk_1.default.gray('Started Ollama listening on 0.0.0.0:11434 (accessible to Docker)\n'));
+            }
+            catch {
+                // Ignore - may already be running
+            }
+        }
+        else if (platform === 'darwin') {
+            // macOS - try launchctl or start directly
+            try {
+                (0, child_process_1.execSync)('launchctl start com.ollama.ollama', { encoding: 'utf8', timeout: 3000 });
+                console.log(chalk_1.default.gray('Note: Started via launchd. To allow Docker access, set OLLAMA_HOST in launchd config\n'));
+            }
+            catch {
+                // Fallback: start ollama serve with host binding
+                try {
+                    // Kill any existing ollama processes first
+                    try {
+                        (0, child_process_1.execSync)('pkill -f "ollama serve"', { encoding: 'utf8', timeout: 2000, stdio: 'ignore' });
+                        await new Promise((resolve) => setTimeout(resolve, 1000));
+                    }
+                    catch {
+                        // Ignore if no process to kill
+                    }
+                    (0, child_process_1.execSync)('OLLAMA_HOST=0.0.0.0:11434 nohup ollama serve > /dev/null 2>&1 &', {
+                        encoding: 'utf8',
+                        timeout: 1000,
+                        shell: '/bin/bash'
+                    });
+                    await new Promise((resolve) => setTimeout(resolve, 2000));
+                    console.log(chalk_1.default.gray('Started Ollama listening on 0.0.0.0:11434 (accessible to Docker)\n'));
+                }
+                catch {
+                    // Ignore
+                }
+            }
+        }
+        else if (platform === 'win32') {
+            // Windows - Ollama typically runs as a service
+            try {
+                (0, child_process_1.execSync)('net start Ollama', { encoding: 'utf8', timeout: 3000 });
+                console.log(chalk_1.default.gray('Note: Started as Windows service. To allow Docker access, set OLLAMA_HOST environment variable\n'));
+            }
+            catch {
+                // Service might already be running or not installed as service
+                // Try to start it directly with host binding
+                try {
+                    (0, child_process_1.execSync)('set OLLAMA_HOST=0.0.0.0:11434 && start /B ollama serve', {
+                        encoding: 'utf8',
+                        timeout: 1000
+                    });
+                    await new Promise((resolve) => setTimeout(resolve, 2000));
+                    console.log(chalk_1.default.gray('Started Ollama listening on 0.0.0.0:11434 (accessible to Docker)\n'));
+                }
+                catch {
+                    // Ignore
+                }
+            }
+        }
+    }
+    catch (error) {
+        // Ollama might already be running, which is fine
+        console.log(chalk_1.default.gray('Note: Ollama service may already be running\n'));
+    }
+}
+/**
+ * Check if Ollama is running
+ */
+async function checkOllamaRunning() {
+    try {
+        // Try to query Ollama API
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 3000);
+        try {
+            const response = await (0, node_fetch_1.default)('http://localhost:11434/api/tags', {
+                method: 'GET',
+                signal: controller.signal,
+            });
+            clearTimeout(timeout);
+            return response.ok;
+        }
+        catch {
+            clearTimeout(timeout);
+            throw new Error('Fetch failed');
+        }
+    }
+    catch {
+        // Try alternative: check if ollama process is running
+        try {
+            const platform = os.platform();
+            if (platform === 'linux' || platform === 'darwin') {
+                (0, child_process_1.execSync)('pgrep -f ollama', { encoding: 'utf8', timeout: 2000, stdio: 'ignore' });
+                return true;
+            }
+            else if (platform === 'win32') {
+                (0, child_process_1.execSync)('tasklist /FI "IMAGENAME eq ollama.exe"', {
+                    encoding: 'utf8',
+                    timeout: 2000,
+                    stdio: 'ignore',
+                });
+                return true;
+            }
+        }
+        catch {
+            return false;
+        }
+        return false;
+    }
+}
+/**
+ * Check what address Ollama is listening on
+ * @returns '0.0.0.0' if listening on all interfaces, '127.0.0.1' if localhost only, null if unknown
+ */
+async function checkOllamaListeningAddress() {
+    try {
+        const platform = os.platform();
+        let output;
+        if (platform === 'linux' || platform === 'darwin') {
+            // Try ss first (modern), fallback to netstat
+            try {
+                output = (0, child_process_1.execSync)('ss -tlnp 2>/dev/null | grep 11434', {
+                    encoding: 'utf8',
+                    timeout: 2000
+                });
+            }
+            catch {
+                try {
+                    output = (0, child_process_1.execSync)('netstat -tlnp 2>/dev/null | grep 11434', {
+                        encoding: 'utf8',
+                        timeout: 2000
+                    });
+                }
+                catch {
+                    return null;
+                }
+            }
+        }
+        else if (platform === 'win32') {
+            try {
+                output = (0, child_process_1.execSync)('netstat -an | findstr :11434', {
+                    encoding: 'utf8',
+                    timeout: 2000,
+                });
+            }
+            catch {
+                return null;
+            }
+        }
+        else {
+            return null;
+        }
+        if (output.includes('0.0.0.0:11434') || output.includes('*:11434') || output.includes('[::]:11434')) {
+            return '0.0.0.0';
+        }
+        else if (output.includes('127.0.0.1:11434') || output.includes('::1:11434')) {
+            return '127.0.0.1';
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Fix Ollama binding if it's listening on localhost only
+ * Attempts to reconfigure Ollama to listen on 0.0.0.0:11434
+ */
+async function fixOllamaBinding() {
+    const platform = os.platform();
+    try {
+        if (platform === 'linux') {
+            // Check for systemd service first
+            let serviceType = null;
+            try {
+                (0, child_process_1.execSync)('systemctl --user is-enabled ollama > /dev/null 2>&1', { encoding: 'utf8', timeout: 2000 });
+                serviceType = 'user';
+            }
+            catch {
+                try {
+                    (0, child_process_1.execSync)('systemctl is-enabled ollama > /dev/null 2>&1', { encoding: 'utf8', timeout: 2000 });
+                    serviceType = 'system';
+                }
+                catch {
+                    // No systemd service
+                }
+            }
+            if (serviceType) {
+                // Configure systemd service
+                const systemctlCmd = serviceType === 'user' ? 'systemctl --user' : 'sudo systemctl';
+                const serviceFile = serviceType === 'user'
+                    ? `${os.homedir()}/.config/systemd/user/ollama.service.d/override.conf`
+                    : '/etc/systemd/system/ollama.service.d/override.conf';
+                const serviceDir = path.dirname(serviceFile);
+                try {
+                    // Create override directory if it doesn't exist
+                    if (!fs.existsSync(serviceDir)) {
+                        (0, child_process_1.execSync)(`mkdir -p "${serviceDir}"`, { encoding: 'utf8' });
+                    }
+                    // Check if override already has OLLAMA_HOST
+                    let needsUpdate = true;
+                    if (fs.existsSync(serviceFile)) {
+                        const content = fs.readFileSync(serviceFile, 'utf8');
+                        if (content.includes('OLLAMA_HOST=0.0.0.0:11434')) {
+                            needsUpdate = false;
+                        }
+                    }
+                    if (needsUpdate) {
+                        // Write override file
+                        const overrideContent = `[Service]
+Environment="OLLAMA_HOST=0.0.0.0:11434"
+`;
+                        fs.writeFileSync(serviceFile, overrideContent);
+                        // Reload and restart
+                        (0, child_process_1.execSync)(`${systemctlCmd} daemon-reload`, { encoding: 'utf8', timeout: 3000 });
+                        (0, child_process_1.execSync)(`${systemctlCmd} restart ollama`, { encoding: 'utf8', timeout: 5000 });
+                        await new Promise((resolve) => setTimeout(resolve, 2000));
+                        return true;
+                    }
+                }
+                catch (error) {
+                    // Fall through to manual restart
+                }
+            }
+            // Fallback: kill and restart with OLLAMA_HOST
+            try {
+                (0, child_process_1.execSync)('pkill -f "ollama serve"', { encoding: 'utf8', timeout: 2000, stdio: 'ignore' });
+                await new Promise((resolve) => setTimeout(resolve, 1000));
+            }
+            catch {
+                // Ignore if no process to kill
+            }
+            (0, child_process_1.execSync)('OLLAMA_HOST=0.0.0.0:11434 nohup ollama serve > /dev/null 2>&1 &', {
+                encoding: 'utf8',
+                timeout: 1000,
+                shell: '/bin/bash'
+            });
+            await new Promise((resolve) => setTimeout(resolve, 2000));
+            return true;
+        }
+        else if (platform === 'darwin') {
+            // macOS - try to restart with OLLAMA_HOST
+            try {
+                (0, child_process_1.execSync)('pkill -f "ollama serve"', { encoding: 'utf8', timeout: 2000, stdio: 'ignore' });
+                await new Promise((resolve) => setTimeout(resolve, 1000));
+            }
+            catch {
+                // Ignore
+            }
+            (0, child_process_1.execSync)('OLLAMA_HOST=0.0.0.0:11434 nohup ollama serve > /dev/null 2>&1 &', {
+                encoding: 'utf8',
+                timeout: 1000,
+                shell: '/bin/bash'
+            });
+            await new Promise((resolve) => setTimeout(resolve, 2000));
+            return true;
+        }
+        else if (platform === 'win32') {
+            // Windows - try to restart with OLLAMA_HOST
+            try {
+                (0, child_process_1.execSync)('taskkill /F /IM ollama.exe', { encoding: 'utf8', timeout: 2000, stdio: 'ignore' });
+                await new Promise((resolve) => setTimeout(resolve, 1000));
+            }
+            catch {
+                // Ignore
+            }
+            (0, child_process_1.execSync)('set OLLAMA_HOST=0.0.0.0:11434 && start /B ollama serve', {
+                encoding: 'utf8',
+                timeout: 1000
+            });
+            await new Promise((resolve) => setTimeout(resolve, 2000));
+            return true;
+        }
+        return false;
+    }
+    catch (error) {
+        return false;
+    }
+}
+/**
+ * Stop Ollama service
+ */
+async function stopOllama() {
+    const platform = os.platform();
+    try {
+        if (platform === 'linux') {
+            // Try systemd service first
+            try {
+                (0, child_process_1.execSync)('systemctl --user stop ollama', { encoding: 'utf8', timeout: 3000 });
+                return;
+            }
+            catch {
+                // Fallback to killing process
+            }
+            // Fallback: kill ollama processes
+            try {
+                (0, child_process_1.execSync)('pkill -f ollama', { encoding: 'utf8', timeout: 2000 });
+            }
+            catch {
+                // Process might not be running
+            }
+        }
+        else if (platform === 'darwin') {
+            // macOS
+            try {
+                (0, child_process_1.execSync)('launchctl stop com.ollama.ollama', { encoding: 'utf8', timeout: 3000 });
+            }
+            catch {
+                // Fallback
+                try {
+                    (0, child_process_1.execSync)('pkill -f ollama', { encoding: 'utf8', timeout: 2000 });
+                }
+                catch {
+                    // Ignore
+                }
+            }
+        }
+        else if (platform === 'win32') {
+            // Windows
+            try {
+                (0, child_process_1.execSync)('net stop Ollama', { encoding: 'utf8', timeout: 3000 });
+            }
+            catch {
+                // Fallback
+                try {
+                    (0, child_process_1.execSync)('taskkill /F /IM ollama.exe', { encoding: 'utf8', timeout: 2000 });
+                }
+                catch {
+                    // Ignore
+                }
+            }
+        }
+    }
+    catch (error) {
+        console.error(chalk_1.default.yellow('Warning: Error stopping Ollama service:'), error);
+    }
+}
+/**
+ * Normalize model name for Ollama (lowercase, dashes, no special chars)
+ * Maps recommended model names to their Ollama model names
+ * Converts last dash before size to colon (e.g., llama-3.2-3b -> llama3.2:3b)
+ */
+function normalizeModelName(modelName) {
+    // First normalize: lowercase, replace spaces with dashes, remove parentheses
+    // Keep dots for version numbers (e.g., 3.2, 2.5)
+    const normalized = modelName.toLowerCase().replace(/\s+/g, '-').replace(/[()]/g, '');
+    // Map model names to Ollama model names
+    const modelMap = {
+        'llama-32-1b': 'llama3.2:1b',
+        'llama-32-3b': 'llama3.2:3b',
+        'llama-31-8b': 'llama3.1:8b',
+        'llama-31-70b': 'llama3.1:70b',
+        'llama3.2-1b': 'llama3.2:1b',
+        'llama3.2-3b': 'llama3.2:3b',
+        'llama3.1-8b': 'llama3.1:8b',
+        'llama3.1-70b': 'llama3.1:70b',
+        'mistral-7b': 'mistral:7b',
+        'phi-3-mini-38b': 'phi3:mini',
+        'phi-3-mini-3.8b': 'phi3:mini',
+        'qwen25-05b': 'qwen2.5:0.5b',
+        'qwen25-7b': 'qwen2.5:7b',
+        'qwen2.5-0.5b': 'qwen2.5:0.5b',
+        'qwen2.5-7b': 'qwen2.5:7b',
+        'deepseek-r1-15b': 'deepseek-r1:1.5b',
+        'deepseek-r1-7b': 'deepseek-r1:7b',
+        'deepseek-r1-8b': 'deepseek-r1:8b',
+        'deepseek-r1-14b': 'deepseek-r1:14b',
+        'deepseek-r1-32b': 'deepseek-r1:32b',
+        'deepseek-r1-70b': 'deepseek-r1:70b',
+        'deepseek-r1-671b': 'deepseek-r1:671b',
+        'deepseek-r1-1.5b': 'deepseek-r1:1.5b',
+    };
+    // Check if we have a direct mapping
+    if (modelMap[normalized]) {
+        return modelMap[normalized];
+    }
+    // Fallback: try to convert last dash before size indicator to colon
+    // Matches patterns like: model-name-XXb or model-name-X.Xb
+    const match = normalized.match(/^(.+)-(\d+(?:\.\d+)?b)$/);
+    if (match) {
+        return `${match[1]}:${match[2]}`;
+    }
+    // Return as-is if no pattern matches
+    return normalized;
+}
+/**
+ * Check if Docker is installed
+ */
+async function checkDockerInstalled() {
+    try {
+        (0, child_process_1.execSync)('docker --version', { encoding: 'utf8', timeout: 2000, stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if any Ollama models are available
+ */
+async function checkHasModels() {
+    try {
+        const output = (0, child_process_1.execSync)('ollama list', { encoding: 'utf8', timeout: 5000 });
+        const lines = output.trim().split('\n');
+        // First line is header, so check if there's more than one line
+        return lines.length > 1;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Detect the appropriate Ollama URL for Docker containers to use
+ */
+async function detectOllamaUrlForDocker() {
+    const platform = os.platform();
+    if (platform === 'darwin' || platform === 'win32') {
+        // macOS and Windows: Docker Desktop provides host.docker.internal
+        return 'http://host.docker.internal:11434';
+    }
+    // Linux: host.docker.internal may not work, need to detect host IP
+    try {
+        // Try to get the docker0 bridge IP (typically 172.17.0.1)
+        const output = (0, child_process_1.execSync)("ip -4 addr show docker0 | grep -oP '(?<=inet\\s)\\d+(\\.\\d+){3}'", { encoding: 'utf8', timeout: 2000 });
+        const ip = output.trim();
+        if (ip) {
+            return `http://${ip}:11434`;
+        }
+    }
+    catch {
+        // Fallback: try to get the default gateway IP
+        try {
+            const output = (0, child_process_1.execSync)("ip route | grep default | awk '{print $3}'", { encoding: 'utf8', timeout: 2000 });
+            const ip = output.trim();
+            if (ip) {
+                return `http://${ip}:11434`;
+            }
+        }
+        catch {
+            // Last resort
+        }
+    }
+    // Fallback to host.docker.internal (works with newer Docker versions on Linux)
+    return 'http://host.docker.internal:11434';
+}
+/**
+ * Get the path to the docker-compose directory
+ */
+function getComposeDirectory() {
+    // When packaged as npm module, recipes are in package root
+    const packageRecipes = path.join(__dirname, '..', '..', 'recipes', 'compose', 'open-webui');
+    // If copied to dist during build (optional)
+    const distRecipes = path.join(__dirname, '..', 'recipes', 'compose', 'open-webui');
+    // Development location (root level)
+    const devRecipes = path.join(process.cwd(), 'recipes', 'compose', 'open-webui');
+    // Check in order of likelihood
+    if (fs.existsSync(packageRecipes)) {
+        return packageRecipes;
+    }
+    if (fs.existsSync(distRecipes)) {
+        return distRecipes;
+    }
+    if (fs.existsSync(devRecipes)) {
+        return devRecipes;
+    }
+    throw new Error('Could not locate Open WebUI compose directory');
+}
+/**
+ * Start Open WebUI with docker-compose
+ */
+async function startOpenWebUI(composeDir, env) {
+    const composeFile = path.join(composeDir, 'docker-compose.yml');
+    if (!fs.existsSync(composeFile)) {
+        throw new Error(`Docker compose file not found: ${composeFile}`);
+    }
+    try {
+        // Set environment variables
+        const envVars = Object.entries(env)
+            .map(([key, value]) => `${key}=${value}`)
+            .join(' ');
+        // Run docker compose up
+        (0, child_process_1.execSync)(`${envVars} docker compose -f "${composeFile}" up -d`, {
+            encoding: 'utf8',
+            stdio: 'inherit',
+            cwd: composeDir,
+        });
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('Failed to start Open WebUI:'), error);
+        throw error;
+    }
+}
+/**
+ * Stop Open WebUI
+ */
+async function stopOpenWebUI(composeDir, removeVolumes) {
+    const composeFile = path.join(composeDir, 'docker-compose.yml');
+    try {
+        const volumeFlag = removeVolumes ? '-v' : '';
+        (0, child_process_1.execSync)(`docker compose -f "${composeFile}" down ${volumeFlag}`, {
+            encoding: 'utf8',
+            stdio: 'inherit',
+            cwd: composeDir,
+        });
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('Failed to stop Open WebUI:'), error);
+        throw error;
+    }
+}
+/**
+ * Check if Open WebUI is running
+ */
+async function checkOpenWebUIRunning() {
+    try {
+        const output = (0, child_process_1.execSync)('docker ps --format "{{.Names}}"', {
+            encoding: 'utf8',
+            timeout: 2000,
+        });
+        return output.includes('open-webui');
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get Open WebUI information if running
+ */
+async function getOpenWebUIInfo() {
+    try {
+        const output = (0, child_process_1.execSync)('docker ps --filter "name=open-webui" --format "{{.Ports}}"', {
+            encoding: 'utf8',
+            timeout: 2000,
+        });
+        if (!output) {
+            return null;
+        }
+        // Parse port from output like "0.0.0.0:3200->8080/tcp"
+        const portMatch = output.match(/0\.0\.0\.0:(\d+)->/);
+        if (portMatch) {
+            return { port: parseInt(portMatch[1], 10) };
+        }
+        // Default port if we can't parse
+        return { port: 3200 };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Test if a model can be accessed and generates responses
+ * @param modelName - The Ollama model name to test
+ * @param verbose - Show detailed output
+ * @returns true if model responds successfully
+ */
+async function testModelConnectivity(modelName, verbose = false) {
+    try {
+        if (verbose) {
+            console.log(chalk_1.default.gray(`  Sending test prompt to ${modelName}...`));
+        }
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 30000); // 30 second timeout for model loading
+        try {
+            const response = await (0, node_fetch_1.default)('http://localhost:11434/api/generate', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    model: modelName,
+                    prompt: 'Hello',
+                    stream: false,
+                }),
+                signal: controller.signal,
+            });
+            clearTimeout(timeout);
+            if (response.ok) {
+                const data = await response.json();
+                if (data.error) {
+                    if (verbose) {
+                        console.log(chalk_1.default.red(`  ✗ Model error: ${data.error}`));
+                    }
+                    return false;
+                }
+                if (data.response) {
+                    if (verbose) {
+                        console.log(chalk_1.default.green('  ✓ Model responded successfully'));
+                        console.log(chalk_1.default.gray(`  Response: "${data.response.substring(0, 50)}${data.response.length > 50 ? '...' : ''}"`));
+                    }
+                    return true;
+                }
+            }
+            else {
+                if (verbose) {
+                    console.log(chalk_1.default.red(`  ✗ HTTP ${response.status}: ${response.statusText}`));
+                }
+                return false;
+            }
+        }
+        catch (error) {
+            clearTimeout(timeout);
+            if (verbose) {
+                if (error instanceof Error && error.name === 'AbortError') {
+                    console.log(chalk_1.default.yellow('  ⚠ Request timed out (model may be loading)'));
+                }
+                else {
+                    console.log(chalk_1.default.red(`  ✗ Connection error: ${error instanceof Error ? error.message : 'Unknown error'}`));
+                }
+            }
+            return false;
+        }
+        return false;
+    }
+    catch (error) {
+        if (verbose) {
+            console.log(chalk_1.default.red(`  ✗ Test failed: ${error instanceof Error ? error.message : 'Unknown error'}`));
+        }
+        return false;
+    }
+}
+/**
+ * Verify model is available on endpoint
+ */
+async function verifyModelOnEndpoint(endpointUrl, modelName) {
+    try {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 10000);
+        const response = await (0, node_fetch_1.default)(`${endpointUrl}/api/tags`, {
+            method: 'GET',
+            signal: controller.signal,
+        });
+        clearTimeout(timeout);
+        if (response.ok) {
+            const data = await response.json();
+            if (data.models) {
+                // Check if model exists (exact match or starts with model name)
+                const modelExists = data.models.some(m => {
+                    const modelFullName = m.name;
+                    return modelFullName === modelName ||
+                        modelFullName.startsWith(modelName + ':') ||
+                        modelFullName === modelName.split(':')[0];
+                });
+                return modelExists;
+            }
+        }
+        return false;
+    }
+    catch (error) {
+        return false;
+    }
+}
+/**
+ * Helper to parse gateway IDs from comma-separated string
+ */
+function parseGatewayIds(ids) {
+    if (!ids)
+        return [];
+    return ids.split(',').map(s => s.trim()).filter(Boolean);
+}
+/**
+ * Create Ollama application on Edgible platform
+ */
+async function createOllamaApplication(config) {
+    // Device ID is already provided from config (same device as agent)
+    const ollamaDeviceId = config.deviceId;
+    // No gateway - local/internal access only
+    const useManagedGateway = false;
+    // Build configuration for managed-process
+    // Ollama should be installed and available in PATH on the device
+    const configuration = {
+        command: 'ollama serve',
+        env: {
+            OLLAMA_HOST: '0.0.0.0:11435',
+        },
+    };
+    // Create application as managed-process without authentication
+    const result = await config.applicationService.createApplicationProgrammatically({
+        name: 'ollama-api',
+        description: `Ollama AI API (${config.modelName}) - Managed Process`,
+        port: 11435,
+        protocol: 'https',
+        deviceIds: [ollamaDeviceId],
+        gatewayIds: [], // No gateway - local/internal access only
+        useManagedGateway: false,
+        subtype: 'managed-process',
+        configuration,
+        authModes: [], // No authentication required
+    });
+    return {
+        app: result,
+        url: result.url || 'https://ollama-api.your-domain.com',
+    };
+}
+/**
+ * Create Open WebUI application on Edgible platform
+ */
+async function createOpenWebUIApplication(config) {
+    // Always use the same device as Ollama (same device as agent)
+    const webuiDeviceId = config.deviceId;
+    // Use managed gateway for public access
+    const useManagedGateway = true;
+    // Create application
+    // Note: Backend should configure OLLAMA_BASE_URL environment variable to ${config.ollamaUrl}
+    // This URL should be the platform Ollama application URL (not localhost) for remote deployments
+    // Use generated base64 constant (no runtime file reading needed)
+    const dockerComposePathValue = (0, compose_constants_1.getOpenWebUIComposeValue)();
+    const envVars = {
+        'OLLAMA_BASE_URL': config.ollamaUrl
+    };
+    const result = await config.applicationService.createApplicationProgrammatically({
+        name: 'open-webui',
+        description: `Open WebUI - AI Chat Interface (OLLAMA_BASE_URL: ${config.ollamaUrl})`,
+        port: 3200,
+        protocol: 'https',
+        deviceIds: [webuiDeviceId],
+        gatewayIds: undefined, // Managed gateway for public access
+        useManagedGateway: true,
+        subtype: 'docker-compose',
+        configuration: {
+            'dockerComposePath': dockerComposePathValue, // base64:... constant
+            'env': envVars,
+            'isWorking': true
+        },
+        requireOrgAuth: true // Enable authentication - X-Auth-Email header already passed by auth system
+    });
+    return {
+        app: result,
+        url: result.url || 'https://open-webui.your-domain.com',
+    };
+}
+/**
+ * Start Open WebUI locally with docker-compose
+ */
+async function startOpenWebUILocal(ollamaUrl) {
+    // Check if Docker is installed
+    const isDockerInstalled = await checkDockerInstalled();
+    if (!isDockerInstalled) {
+        throw new Error('Docker is required to run Open WebUI locally. Please install Docker first.');
+    }
+    const composeDir = getComposeDirectory();
+    await startOpenWebUI(composeDir, {
+        OLLAMA_BASE_URL: ollamaUrl,
+        OPEN_WEBUI_PORT: '3200',
+    });
+}
+/**
+ * Check if an Ollama URL is reachable and responding
+ */
+async function checkOllamaUrlReachable(url) {
+    try {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 5000); // 5 second timeout
+        try {
+            const response = await (0, node_fetch_1.default)(`${url}/api/tags`, {
+                method: 'GET',
+                signal: controller.signal,
+            });
+            clearTimeout(timeout);
+            return response.ok;
+        }
+        catch (error) {
+            clearTimeout(timeout);
+            return false;
+        }
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if a URL is reachable (general purpose)
+ */
+async function checkUrlReachable(url) {
+    try {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 5000); // 5 second timeout
+        try {
+            const response = await (0, node_fetch_1.default)(url, {
+                method: 'GET',
+                signal: controller.signal,
+            });
+            clearTimeout(timeout);
+            return response.ok || response.status < 500; // Accept redirects and client errors as "reachable"
+        }
+        catch (error) {
+            clearTimeout(timeout);
+            return false;
+        }
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=helpers.js.map