free-coding-models 0.3.52 → 0.3.55

package/CHANGELOG.md

@@ -1,8 +1,27 @@
-## [0.3.52] - 2026-04-18
+## [0.3.55] - 2026-04-18
+
+### Changed
+
+- **Direct Launch Attempt** — Tool launchers for OpenCode and Kilo now attempt to spawn the command directly instead of blocking with a pre-installation check. Installation instructions are now provided via the process error handler for a more seamless experience.
+- **Fixed OpenCode NPM Command** — Updated the suggested installation command for OpenCode to `npm install -g opencode-ai`.
+
+## [0.3.54] - 2026-04-18
+
+### Changed
+
+- **Improved OpenCode WebUI Launch** — The `--opencode-web` flag now correctly spawns the `opencode web` command, providing a integrated browser-based coding experience with pre-configured model selection.
 
 ### Added
 
-- **OpenCode WebUI Support** — Added `--opencode-web` flag to open the OpenCode WebUI dashboard after configuring the selected model. This mirrors the existing `--opencode-desktop` behavior.
+- **Kilo CLI Support** — Added `--kilo` flag to launch the Kilo CLI with the selected model. Kilo is a fork of OpenCode and shares the same configuration structure (stored in `~/.config/kilo/opencode.json`).
+
+## [0.3.53] - 2026-04-18
+
+### Added
+
+- **OpenCode WebUI Support** — Added `--opencode-web` flag to open the OpenCode WebUI dashboard after configuring the selected model.
+
+## [0.3.52] - 2026-04-18
 
 ## [0.3.51] - 2026-04-11
 

package/README.md

@@ -16,7 +16,7 @@
 
 <p align="center">
   <strong>Find the fastest free coding model in seconds</strong><br>
-  <sub>Ping 238 models across 25 AI Free providers in real-time </sub><br>  <sub> Install Free API endpoints to your favorite AI coding tool: <br>📦 OpenCode, 📦 OpenCode Desktop, 📦 OpenCode WebUI, 🦞 OpenClaw, 💘 Crush, 🪿 Goose, 🛠 Aider, 🐉 Qwen Code, 🤲 OpenHands, ⚡ Amp, 🔮 Hermes, ▶️ Continue, 🧠 Cline, 🛠️ Xcode, π Pi, 🦘 Rovo or ♊ Gemini in one keystroke</sub>
+  <sub>Ping 238 models across 25 AI Free providers in real-time </sub><br>  <sub> Install Free API endpoints to your favorite AI coding tool: <br>📦 OpenCode, 📦 OpenCode Desktop, 📦 OpenCode WebUI, 🦞 OpenClaw, 💘 Crush, 🪿 Goose, 🛠 Aider, ⚡️ Kilo CLI, 🐉 Qwen Code, 🤲 OpenHands, ⚡ Amp, 🔮 Hermes, ▶️ Continue, 🧠 Cline, 🛠️ Xcode, π Pi, 🦘 Rovo or ♊ Gemini in one keystroke</sub>
 </p>
 
 
@@ -267,6 +267,7 @@ When launching the web dashboard, `free-coding-models` prefers `http://localhost
 | `--crush` | 💘 Crush |
 | `--goose` | 🪿 Goose |
 | `--aider` | 🛠 Aider |
+| `--kilo` | ⚡️ Kilo CLI |
 | `--qwen` | 🐉 Qwen Code |
 | `--openhands` | 🤲 OpenHands |
 | `--amp` | ⚡ Amp |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "free-coding-models",
-  "version": "0.3.52",
+  "version": "0.3.55",
   "description": "Find the fastest coding LLM models in seconds — ping free models from multiple providers, pick the best one for OpenCode, Cursor, or any AI coding assistant.",
   "keywords": [
     "nvidia",

package/src/app.js

@@ -118,6 +118,7 @@ import { syncShellEnv, ensureShellRcSource, promptShellEnvMigration, removeShell
 import { stripAnsi, maskApiKey, displayWidth, padEndDisplay, tintOverlayLines, keepOverlayTargetVisible, sliceOverlayLines, calculateViewport, sortResultsWithPinnedFavorites, adjustScrollOffset } from '../src/render-helpers.js'
 import { renderTable, PROVIDER_COLOR } from '../src/render-table.js'
 import { setOpenCodeModelData, startOpenCode, startOpenCodeDesktop, startOpenCodeWeb } from '../src/opencode.js'
+import { startKilo } from '../src/kilo.js'
 import { startOpenClaw } from '../src/openclaw.js'
 import { createOverlayRenderers } from '../src/overlays.js'
 import { createKeyHandler, createMouseEventHandler } from '../src/key-handler.js'
@@ -257,6 +258,7 @@ export async function runApp(cliArgs, config) {
       aider: cliArgs.aiderMode,
       crush: cliArgs.crushMode,
       goose: cliArgs.gooseMode,
+      kilo: cliArgs.kiloMode,
       qwen: cliArgs.qwenMode,
       openhands: cliArgs.openHandsMode,
       amp: cliArgs.ampMode,
@@ -874,6 +876,7 @@ export async function runApp(cliArgs, config) {
     startOpenClaw,
     startOpenCodeDesktop,
     startOpenCodeWeb,
+    startKilo,
     startOpenCode,
     startExternalTool,
     getToolModeOrder,

package/src/command-palette.js

@@ -26,6 +26,7 @@ const TOOL_MODE_DESCRIPTIONS = {
   goose: 'Launch Goose and preselect the active model.',
   pi: 'Launch Pi with model/provider flags.',
   aider: 'Launch Aider configured on the selected model.',
+  kilo: 'Set model in shared config, then launch Kilo CLI.',
   qwen: 'Launch Qwen Code using the selected provider model.',
   openhands: 'Launch OpenHands with the selected model endpoint.',
   amp: 'Launch Amp with this model as active target.',

package/src/endpoint-installer.js

@@ -52,7 +52,7 @@ import { getToolMeta } from './tool-metadata.js'
 const DIRECT_INSTALL_UNSUPPORTED_PROVIDERS = new Set(['replicate', 'zai', 'rovo', 'gemini', 'opencode-zen'])
 // 📖 Install Endpoints only lists tools whose persisted config shape is actually supported here.
 // 📖 Claude Code, Codex, and Gemini stay out while their dedicated bridges are being rebuilt.
-const INSTALL_TARGET_MODES = ['opencode', 'opencode-desktop', 'openclaw', 'crush', 'goose', 'pi', 'aider', 'qwen', 'openhands', 'amp', 'hermes', 'continue', 'cline']
+const INSTALL_TARGET_MODES = ['opencode', 'opencode-desktop', 'opencode-web', 'openclaw', 'kilo', 'crush', 'goose', 'pi', 'aider', 'qwen', 'openhands', 'amp', 'hermes', 'continue', 'cline']
 
 function getDefaultPaths() {
   const home = homedir()

package/src/installed-models-manager.js

@@ -14,6 +14,7 @@
  *   - Goose (~/.config/goose/config.yaml + custom_providers/*.json)
  *   - Crush (~/.config/crush/crush.json)
  *   - Aider (~/.aider.conf.yml)
+ *   - Kilo (~/.config/kilo/opencode.json)
  *   - Qwen (~/.qwen/settings.json)
  *   - Pi (~/.pi/agent/models.json + settings.json)
  *   - OpenHands (~/.fcm-openhands-env)
@@ -29,6 +30,7 @@
  *   → parseGooseConfig — Parse Goose YAML config
  *   → parseCrushConfig — Parse Crush JSON config
  *   → parseAiderConfig — Parse Aider YAML config
+ *   → parseKiloConfig — Parse Kilo JSON config
  *   → parseQwenConfig — Parse Qwen JSON config
  *   → parsePiConfig — Parse Pi JSON configs
  *   → parseOpenHandsConfig — Parse OpenHands env file
@@ -58,6 +60,7 @@ function getToolConfigPaths(homeDir = homedir()) {
     goose: join(homeDir, '.config', 'goose', 'config.yaml'),
     crush: join(homeDir, '.config', 'crush', 'crush.json'),
     aider: join(homeDir, '.aider.conf.yml'),
+    kilo: join(homeDir, '.config', 'kilo', 'opencode.json'),
     qwen: join(homeDir, '.qwen', 'settings.json'),
     piModels: join(homeDir, '.pi', 'agent', 'models.json'),
     piSettings: join(homeDir, '.pi', 'agent', 'settings.json'),
@@ -270,6 +273,43 @@ function parseAiderConfig(paths = getToolConfigPaths()) {
   }
 }
 
+/**
+ * 📖 Parse Kilo config for model
+ */
+function parseKiloConfig(paths = getToolConfigPaths()) {
+  const configPath = paths.kilo
+  if (!existsSync(configPath)) {
+    return { isValid: false, models: [], configPath }
+  }
+
+  try {
+    const content = readFileSync(configPath, 'utf8')
+    const config = JSON.parse(content)
+
+    const models = []
+    if (config.model) {
+      models.push({
+        modelId: config.model,
+        label: config.model,
+        tier: '-',
+        sweScore: '-',
+        providerKey: 'external',
+        isExternal: true,
+        canLaunch: true,
+      })
+    }
+
+    return {
+      isValid: true,
+      hasManagedMarker: true, // Kilo CLI integration always uses modelRef format
+      models,
+      configPath,
+    }
+  } catch (err) {
+    return { isValid: false, models: [], configPath }
+  }
+}
+
 /**
  * 📖 Parse Qwen config for model
  */
@@ -459,6 +499,8 @@ export function parseToolConfig(toolMode, paths = getToolConfigPaths()) {
       return parseCrushConfig(paths)
     case 'aider':
       return parseAiderConfig(paths)
+    case 'kilo':
+      return parseKiloConfig(paths)
     case 'qwen':
       return parseQwenConfig(paths)
     case 'pi':
@@ -476,7 +518,7 @@ export function parseToolConfig(toolMode, paths = getToolConfigPaths()) {
  * 📖 Scan all tool configs and return structured results
  */
 export function scanAllToolConfigs(paths = getToolConfigPaths()) {
-  const toolModes = ['goose', 'crush', 'aider', 'qwen', 'pi', 'openhands', 'amp']
+  const toolModes = ['goose', 'crush', 'aider', 'kilo', 'qwen', 'pi', 'openhands', 'amp']
 
   return toolModes.map((toolMode) => {
     const result = parseToolConfig(toolMode, paths)
@@ -499,6 +541,7 @@ function getToolEmoji(toolMode) {
     goose: '🪿',
     crush: '💘',
     aider: '🛠',
+    kilo: '⚡️',
     qwen: '🐉',
     pi: 'π',
     openhands: '🤲',
@@ -576,6 +619,15 @@ export function softDeleteModel(toolMode, modelId, paths = getToolConfigPaths())
         }
         break
 
+      case 'kilo':
+        const kiloConfig = JSON.parse(originalContent)
+        if (kiloConfig.model === modelId) {
+          delete kiloConfig.model
+          newContent = JSON.stringify(kiloConfig, null, 2)
+          modified = true
+        }
+        break
+
       case 'qwen':
         const qwenConfig = JSON.parse(originalContent)
         if (qwenConfig.model === modelId) {

package/src/key-handler.js

@@ -265,6 +265,7 @@ export function createKeyHandler(ctx) {
     startOpenClaw,
     startOpenCodeDesktop,
     startOpenCodeWeb,
+    startKilo,
     startOpenCode,
     startExternalTool,
     getToolModeOrder,
@@ -306,7 +307,10 @@ export function createKeyHandler(ctx) {
   }
 
   function shouldCheckMissingTool(mode) {
-    return mode !== 'opencode-desktop'
+    // 📖 opencode-desktop doesn't have a binary check (it uses 'open -a').
+    // 📖 opencode-web, opencode, and kilo manage their own ENOENT errors in spawn handlers.
+    // 📖 xcode uses 'open -a Xcode' which doesn't need a binary path resolution.
+    return !['opencode-desktop', 'opencode-web', 'opencode', 'kilo', 'xcode'].includes(mode)
   }
 
   function getModelTelemetryFamily(providerKey) {
@@ -498,6 +502,8 @@ export function createKeyHandler(ctx) {
       exitCode = await startOpenCodeDesktop(userSelected, state.config)
     } else if (state.mode === 'opencode-web') {
       exitCode = await startOpenCodeWeb(userSelected, state.config)
+    } else if (state.mode === 'kilo') {
+      exitCode = await startKilo(userSelected, state.config)
     } else if (state.mode === 'opencode') {
       exitCode = await startOpenCode(userSelected, state.config)
     } else {

package/src/kilo-config.js

@@ -0,0 +1,43 @@
+/**
+ * @file src/kilo-config.js
+ * @description Small filesystem helpers for the shared Kilo config file (OpenCode fork).
+ *
+ * @details
+ *   📖 Kilo is a fork of OpenCode and uses the same config structure,
+ *   📖 but stored in a different directory: ~/.config/kilo/opencode.json
+ *
+ * @functions
+ *   → `loadKiloConfig` — read `~/.config/kilo/opencode.json` safely
+ *   → `saveKiloConfig` — write `opencode.json` with a simple backup
+ *
+ * @exports loadKiloConfig, saveKiloConfig
+ */
+
+import { readFileSync, writeFileSync, copyFileSync, existsSync, mkdirSync } from 'node:fs'
+import { join } from 'node:path'
+import { homedir } from 'node:os'
+
+const KILO_CONFIG_DIR = join(homedir(), '.config', 'kilo')
+const KILO_CONFIG_PATH = join(KILO_CONFIG_DIR, 'opencode.json')
+const KILO_BACKUP_PATH = join(KILO_CONFIG_DIR, 'opencode.json.bak')
+
+export function loadKiloConfig() {
+  try {
+    if (existsSync(KILO_CONFIG_PATH)) {
+      return JSON.parse(readFileSync(KILO_CONFIG_PATH, 'utf8'))
+    }
+  } catch {}
+  return {}
+}
+
+export function saveKiloConfig(config) {
+  mkdirSync(KILO_CONFIG_DIR, { recursive: true })
+  if (existsSync(KILO_CONFIG_PATH)) {
+    copyFileSync(KILO_CONFIG_PATH, KILO_BACKUP_PATH)
+  }
+  writeFileSync(KILO_CONFIG_PATH, JSON.stringify(config, null, 2) + '\n')
+}
+
+export function getKiloConfigPath() {
+  return KILO_CONFIG_PATH
+}

package/src/kilo.js

@@ -0,0 +1,200 @@
+/**
+ * @file kilo.js
+ * @description Kilo CLI integration helpers for direct launches (OpenCode fork).
+ */
+
+import chalk from 'chalk'
+import { PROVIDER_COLOR } from './render-table.js'
+import { loadKiloConfig, saveKiloConfig, getKiloConfigPath } from './kilo-config.js'
+import { getApiKey } from './config.js'
+import { ENV_VAR_NAMES, OPENCODE_MODEL_MAP } from './provider-metadata.js'
+import { resolveToolBinaryPath } from './tool-bootstrap.js'
+
+// 📖 Map source model IDs to Kilo built-in IDs (same as OpenCode).
+function getKiloModelId(providerKey, modelId) {
+  if (providerKey === 'nvidia') return modelId.replace(/^nvidia\//, '')
+  if (providerKey === 'zai') return modelId.replace(/^zai\//, '')
+  return OPENCODE_MODEL_MAP[providerKey]?.[modelId] || modelId
+}
+
+// 📖 spawnKilo: Resolve API keys + spawn kilo CLI with correct env.
+async function spawnKilo(args, providerKey, fcmConfig) {
+  const envVarName = ENV_VAR_NAMES[providerKey]
+  const resolvedKey = getApiKey(fcmConfig, providerKey)
+  const childEnv = { ...process.env }
+  childEnv.NODE_NO_WARNINGS = '1'
+  const finalArgs = [...args]
+  
+  if (envVarName && resolvedKey) childEnv[envVarName] = resolvedKey
+
+  const { spawn } = await import('child_process')
+  const child = spawn(resolveToolBinaryPath('kilo') || 'kilo', finalArgs, {
+    stdio: 'inherit',
+    shell: true,
+    detached: false,
+    env: childEnv
+  })
+
+  return new Promise((resolve, reject) => {
+    child.on('exit', (code) => resolve(code))
+    child.on('error', (err) => {
+      if (err.code === 'ENOENT') {
+        console.error(chalk.red('\n  X Could not find "kilo" -- is it installed and in your PATH?'))
+        console.error(chalk.dim('    Install: npm i -g @kilocode/cli   or see https://kilo.ai'))
+        resolve(1)
+      } else {
+        reject(err)
+      }
+    })
+  })
+}
+
+// ─── Start Kilo CLI ──────────────────────────────────────────────────────────
+
+export async function startKilo(model, fcmConfig) {
+  const providerKey = model.providerKey ?? 'nvidia'
+  const ocModelId = getKiloModelId(providerKey, model.modelId)
+  const modelRef = `${providerKey}/${ocModelId}`
+
+  console.log(chalk.green(`  Setting ${chalk.bold(model.label)} as default...`))
+  console.log(chalk.dim(`  Model: ${modelRef}`))
+  console.log()
+
+  const config = loadKiloConfig()
+
+  if (!config.provider) config.provider = {}
+  if (!config.provider[providerKey]) {
+    // 📖 Auto-configure provider if missing (same as OpenCode logic)
+    if (providerKey === 'nvidia') {
+      config.provider.nvidia = {
+        npm: '@ai-sdk/openai-compatible',
+        name: 'NVIDIA NIM',
+        options: { baseURL: 'https://integrate.api.nvidia.com/v1', apiKey: '{env:NVIDIA_API_KEY}' },
+        models: {}
+      }
+    } else if (providerKey === 'groq') {
+      config.provider.groq = { options: { apiKey: '{env:GROQ_API_KEY}' }, models: {} }
+    } else if (providerKey === 'cerebras') {
+      config.provider.cerebras = {
+        npm: '@ai-sdk/openai-compatible',
+        name: 'Cerebras',
+        options: { baseURL: 'https://api.cerebras.ai/v1', apiKey: '{env:CEREBRAS_API_KEY}' },
+        models: {}
+      }
+    } else if (providerKey === 'sambanova') {
+      config.provider.sambanova = {
+        npm: '@ai-sdk/openai-compatible',
+        name: 'SambaNova',
+        options: { baseURL: 'https://api.sambanova.ai/v1', apiKey: '{env:SAMBANOVA_API_KEY}' },
+        models: {}
+      }
+    } else if (providerKey === 'openrouter') {
+      config.provider.openrouter = {
+        npm: '@ai-sdk/openai-compatible',
+        name: 'OpenRouter',
+        options: { baseURL: 'https://openrouter.ai/api/v1', apiKey: '{env:OPENROUTER_API_KEY}' },
+        models: {}
+      }
+    } else if (providerKey === 'huggingface') {
+      config.provider.huggingface = {
+        npm: '@ai-sdk/openai-compatible',
+        name: 'Hugging Face Inference',
+        options: { baseURL: 'https://router.huggingface.co/v1', apiKey: '{env:HUGGINGFACE_API_KEY}' },
+        models: {}
+      }
+    } else if (providerKey === 'deepinfra') {
+      config.provider.deepinfra = {
+        npm: '@ai-sdk/openai-compatible',
+        name: 'DeepInfra',
+        options: { baseURL: 'https://api.deepinfra.com/v1/openai', apiKey: '{env:DEEPINFRA_API_KEY}' },
+        models: {}
+      }
+    } else if (providerKey === 'fireworks') {
+      config.provider.fireworks = {
+        npm: '@ai-sdk/openai-compatible',
+        name: 'Fireworks AI',
+        options: { baseURL: 'https://api.fireworks.ai/inference/v1', apiKey: '{env:FIREWORKS_API_KEY}' },
+        models: {}
+      }
+    } else if (providerKey === 'codestral') {
+      config.provider.codestral = {
+        npm: '@ai-sdk/openai-compatible',
+        name: 'Mistral Codestral',
+        options: { baseURL: 'https://api.mistral.ai/v1', apiKey: '{env:CODESTRAL_API_KEY}' },
+        models: {}
+      }
+    } else if (providerKey === 'hyperbolic') {
+      config.provider.hyperbolic = {
+        npm: '@ai-sdk/openai-compatible',
+        name: 'Hyperbolic',
+        options: { baseURL: 'https://api.hyperbolic.xyz/v1', apiKey: '{env:HYPERBOLIC_API_KEY}' },
+        models: {}
+      }
+    } else if (providerKey === 'scaleway') {
+      config.provider.scaleway = {
+        npm: '@ai-sdk/openai-compatible',
+        name: 'Scaleway',
+        options: { baseURL: 'https://api.scaleway.ai/v1', apiKey: '{env:SCALEWAY_API_KEY}' },
+        models: {}
+      }
+    } else if (providerKey === 'googleai') {
+      config.provider.googleai = {
+        npm: '@ai-sdk/openai-compatible',
+        name: 'Google AI Studio',
+        options: { baseURL: 'https://generativelanguage.googleapis.com/v1beta/openai', apiKey: '{env:GOOGLE_API_KEY}' },
+        models: {}
+      }
+    } else if (providerKey === 'siliconflow') {
+      config.provider.siliconflow = {
+        npm: '@ai-sdk/openai-compatible',
+        name: 'SiliconFlow',
+        options: { baseURL: 'https://api.siliconflow.com/v1', apiKey: '{env:SILICONFLOW_API_KEY}' },
+        models: {}
+      }
+    } else if (providerKey === 'together') {
+      config.provider.together = {
+        npm: '@ai-sdk/openai-compatible',
+        name: 'Together AI',
+        options: { baseURL: 'https://api.together.xyz/v1', apiKey: '{env:TOGETHER_API_KEY}' },
+        models: {}
+      }
+    } else if (providerKey === 'perplexity') {
+      config.provider.perplexity = {
+        npm: '@ai-sdk/openai-compatible',
+        name: 'Perplexity API',
+        options: { baseURL: 'https://api.perplexity.ai', apiKey: '{env:PERPLEXITY_API_KEY}' },
+        models: {}
+      }
+    } else if (providerKey === 'chutes') {
+      config.provider.chutes = {
+        npm: '@ai-sdk/openai-compatible',
+        name: 'Chutes AI',
+        options: { baseURL: 'https://chutes.ai/v1', apiKey: '{env:CHUTES_API_KEY}' },
+        models: {}
+      }
+    } else if (providerKey === 'ovhcloud') {
+      config.provider.ovhcloud = {
+        npm: '@ai-sdk/openai-compatible',
+        name: 'OVHcloud AI',
+        options: { baseURL: 'https://oai.endpoints.kepler.ai.cloud.ovh.net/v1', apiKey: '{env:OVH_AI_ENDPOINTS_ACCESS_TOKEN}' },
+        models: {}
+      }
+    }
+  }
+
+  const isBuiltinMapped = OPENCODE_MODEL_MAP[providerKey]?.[model.modelId]
+  if (!isBuiltinMapped && config.provider[providerKey]) {
+    if (!config.provider[providerKey].models) config.provider[providerKey].models = {}
+    config.provider[providerKey].models[ocModelId] = { name: model.label }
+  }
+
+  config.model = modelRef
+  saveKiloConfig(config)
+
+  console.log(chalk.dim(`  Config saved to: ${getKiloConfigPath()}`))
+  console.log()
+  console.log(chalk.dim('  Starting Kilo...'))
+  console.log()
+
+  await spawnKilo(['--model', modelRef], providerKey, fcmConfig)
+}

package/src/opencode.js

@@ -203,7 +203,7 @@ async function spawnOpenCode(args, providerKey, fcmConfig, existingZaiProxy = nu
       if (zaiProxy) zaiProxy.close()
       if (err.code === 'ENOENT') {
         console.error(chalk.red('\n  X Could not find "opencode" -- is it installed and in your PATH?'))
-        console.error(chalk.dim('    Install: npm i -g opencode   or see https://opencode.ai'))
+        console.error(chalk.dim('    Install: npm i -g opencode-ai   or see https://opencode.ai'))
         resolve(1)
       } else {
         reject(err)
@@ -550,26 +550,10 @@ export async function startOpenCodeWeb(model, fcmConfig) {
   const ocModelId = getOpenCodeModelId(providerKey, model.modelId)
   const modelRef = `${providerKey}/${ocModelId}`
 
-  const launchWeb = async () => {
-    const { exec } = await import('child_process')
-    const url = 'https://opencode.ai'
-    let command
-    if (isMac) {
-      command = `open "${url}"`
-    } else if (isWindows) {
-      command = `start "${url}"`
-    } else {
-      command = `xdg-open "${url}"`
-    }
-    exec(command, (err) => {
-      if (err) {
-        console.error(chalk.red('  Could not open OpenCode WebUI'))
-        console.error(chalk.dim(`    Please visit ${url} manually`))
-      }
-    })
-  }
+  console.log(chalk.green(`  Setting ${chalk.bold(model.label)} as default...`))
+  console.log(chalk.dim(`  Model: ${modelRef}`))
+  console.log()
 
-  // 📖 Mirror OpenCode Desktop behavior: set the model in opencode.json
   const config = loadOpenCodeConfig()
   const backupPath = `${getOpenCodeConfigPath()}.backup-${Date.now()}`
 
@@ -599,8 +583,6 @@ export async function startOpenCodeWeb(model, fcmConfig) {
     }
   }
   // ... other providers are handled as they are selected
-
-  console.log(chalk.green(`  Setting ${chalk.bold(model.label)} as default (mirroring Desktop)...`))
   
   if (providerKey !== 'opencode-zen' && config.provider[providerKey]) {
     if (!config.provider[providerKey].models) config.provider[providerKey].models = {}
@@ -611,10 +593,10 @@ export async function startOpenCodeWeb(model, fcmConfig) {
   saveOpenCodeConfig(config)
 
   console.log(chalk.dim(`  Config saved to: ${getOpenCodeConfigPath()}`))
-  console.log(chalk.dim('  Opening OpenCode WebUI...'))
+  console.log(chalk.dim('  Starting OpenCode Web...'))
   console.log()
 
-  await launchWeb()
+  await spawnOpenCode(['web', '--model', modelRef], providerKey, fcmConfig)
 }
 
 // ─── Start OpenCode Desktop ───────────────────────────────────────────────────

package/src/tool-bootstrap.js

@@ -173,6 +173,16 @@ export const TOOL_BOOTSTRAP_METADATA = {
       },
     },
   },
+  kilo: {
+    binary: 'kilo',
+    docsUrl: 'https://kilo.ai/docs/cli',
+    install: {
+      default: {
+        shellCommand: 'npm install -g @kilocode/cli',
+        summary: 'Install Kilo CLI globally via npm.',
+      },
+    },
+  },
   qwen: {
     binary: 'qwen',
     docsUrl: 'https://qwenlm.github.io/qwen-code-docs/en/users/quickstart/',

package/src/tool-metadata.js

@@ -34,6 +34,7 @@ export const TOOL_METADATA = {
   goose:             { label: 'Goose',             emoji: '🪿', flag: '--goose',            color: [132, 235, 168] },
   pi:                { label: 'Pi',                emoji: 'π',  flag: '--pi',               color: [173, 216, 230] },
   aider:             { label: 'Aider',             emoji: '🛠', flag: '--aider',            color: [255, 208, 102] },
+  kilo:              { label: 'Kilo CLI',          emoji: '⚡️', flag: '--kilo',             color: [255, 107, 107] },
   qwen:              { label: 'Qwen Code',         emoji: '🐉', flag: '--qwen',             color: [255, 213, 128] },
   openhands:         { label: 'OpenHands',         emoji: '🤲', flag: '--openhands',        color: [228, 191, 239] },
   amp:               { label: 'Amp',               emoji: '⚡', flag: '--amp',              color: [255, 232, 98] },
@@ -56,6 +57,7 @@ export const COMPAT_COLUMN_SLOTS = [
   { emoji: '🪿', toolKeys: ['goose'],                        color: [132, 235, 168] },
   { emoji: 'π',  toolKeys: ['pi'],                           color: [173, 216, 230] },
   { emoji: '🛠', toolKeys: ['aider'],                        color: [255, 208, 102] },
+  { emoji: '⚡️', toolKeys: ['kilo'],                         color: [255, 107, 107] },
   { emoji: '🐉', toolKeys: ['qwen'],                         color: [255, 213, 128] },
   { emoji: '🤲', toolKeys: ['openhands'],                    color: [228, 191, 239] },
   { emoji: '⚡', toolKeys: ['amp'],                          color: [255, 232, 98] },
@@ -78,6 +80,7 @@ export const TOOL_MODE_ORDER = [
   'crush',
   'goose',
   'aider',
+  'kilo',
   'qwen',
   'openhands',
   'amp',

package/src/utils.js

@@ -388,7 +388,7 @@ export function findBestModel(results) {
 // 📖 Argument types:
 //   - API key: first positional arg that does not look like a CLI flag (e.g., "nvapi-xxx")
 //   - Boolean flags: --best, --fiable, --opencode, --opencode-desktop, --opencode-web, --openclaw,
-//     --aider, --crush, --goose, --qwen,
+//     --aider, --crush, --goose, --qwen, --kilo,
 //     --openhands, --amp, --pi, --no-telemetry, --json, --help/-h (case-insensitive)
 //   - Value flag: --tier <letter> (the next non-flag arg is the tier value)
 //
@@ -452,6 +452,7 @@ export function parseArgs(argv) {
   const crushMode = flags.includes('--crush')
   const gooseMode = flags.includes('--goose')
   const qwenMode = flags.includes('--qwen')
+  const kiloMode = flags.includes('--kilo')
   const openHandsMode = flags.includes('--openhands')
   const ampMode = flags.includes('--amp')
   const piMode = flags.includes('--pi')
@@ -499,6 +500,7 @@ export function parseArgs(argv) {
     crushMode,
     gooseMode,
     qwenMode,
+    kiloMode,
     openHandsMode,
     ampMode,
     piMode,