free-coding-models 0.3.51 → 0.3.54

package/CHANGELOG.md

@@ -1,3 +1,21 @@
+## [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
+
+- **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
 
 ### Changed

package/README.md

@@ -11,10 +11,12 @@
 </p>
 
 <h1 align="center">free-coding-models</h1>
+                                                    
+                                                                                                                                                                                        
 
 <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, 🦞 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>
 
 
@@ -260,10 +262,12 @@ When launching the web dashboard, `free-coding-models` prefers `http://localhost
 |------|----------|
 | `--opencode` | 📦 OpenCode CLI |
 | `--opencode-desktop` | 📦 OpenCode Desktop |
+| `--opencode-web` | 📦 OpenCode WebUI |
 | `--openclaw` | 🦞 OpenClaw |
 | `--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.51",
+  "version": "0.3.54",
   "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

@@ -105,7 +105,7 @@ import { usageForRow as _usageForRow } from '../src/usage-reader.js'
 import { buildProviderModelTokenKey, loadTokenUsageByProviderModel } from '../src/token-usage-reader.js'
 import { parseOpenRouterResponse, fetchProviderQuota as _fetchProviderQuotaFromModule } from '../src/provider-quota-fetchers.js'
 import { isKnownQuotaTelemetry } from '../src/quota-capabilities.js'
-import { ALT_ENTER, ALT_LEAVE, ALT_HOME, PING_TIMEOUT, PING_INTERVAL, FPS, COL_MODEL, COL_MS, CELL_W, FRAMES, TIER_CYCLE, SETTINGS_OVERLAY_BG, HELP_OVERLAY_BG, RECOMMEND_OVERLAY_BG, OVERLAY_PANEL_WIDTH, TABLE_HEADER_LINES, TABLE_FOOTER_LINES, TABLE_FIXED_LINES, WIDTH_WARNING_MIN_COLS, msCell, spinCell } from '../src/constants.js'
+import { ALT_ENTER, ALT_LEAVE, ALT_HOME, PING_TIMEOUT, PING_INTERVAL, FPS, COL_MODEL, COL_MS, CELL_W, FRAMES, TIER_CYCLE, VERDICT_CYCLE, HEALTH_CYCLE, SETTINGS_OVERLAY_BG, HELP_OVERLAY_BG, RECOMMEND_OVERLAY_BG, OVERLAY_PANEL_WIDTH, TABLE_HEADER_LINES, TABLE_FOOTER_LINES, TABLE_FIXED_LINES, WIDTH_WARNING_MIN_COLS, msCell, spinCell } from '../src/constants.js'
 import { TIER_COLOR } from '../src/tier-colors.js'
 import { resolveCloudflareUrl, buildPingRequest, ping, extractQuotaPercent, getProviderQuotaPercentCached, usagePlaceholderForProvider } from '../src/ping.js'
 import { runFiableMode, filterByTierOrExit, fetchOpenRouterFreeModels } from '../src/analysis.js'
@@ -117,7 +117,8 @@ import { promptApiKey } from '../src/setup.js'
 import { syncShellEnv, ensureShellRcSource, promptShellEnvMigration, removeShellEnv } from '../src/shell-env.js'
 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 } from '../src/opencode.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'
@@ -252,10 +253,12 @@ export async function runApp(cliArgs, config) {
     const flagByMode = {
       opencode: cliArgs.openCodeMode,
       'opencode-desktop': cliArgs.openCodeDesktopMode,
+      'opencode-web': cliArgs.openCodeWebMode,
       openclaw: cliArgs.openClawMode,
       aider: cliArgs.aiderMode,
       crush: cliArgs.crushMode,
       goose: cliArgs.gooseMode,
+      kilo: cliArgs.kiloMode,
       qwen: cliArgs.qwenMode,
       openhands: cliArgs.openHandsMode,
       amp: cliArgs.ampMode,
@@ -423,6 +426,8 @@ export async function runApp(cliArgs, config) {
     mode,                         // 📖 'opencode' or 'openclaw' — controls Enter action
     tierFilterMode: 0,            // 📖 Index into TIER_CYCLE (0=All, 1=S+, 2=S, ...)
     originFilterMode: 0,          // 📖 Index into ORIGIN_CYCLE (0=All, then providers)
+    verdictFilterMode: 0,        // 📖 Index into VERDICT_CYCLE (0=All, then verdicts)
+    healthFilterMode: 0,          // 📖 Index into HEALTH_CYCLE (0=All, then health states)
     hideUnconfiguredModels: config.settings?.hideUnconfiguredModels === true, // 📖 Hide providers with no configured API key when true.
     favoritesPinnedAndSticky: config.settings?.favoritesPinnedAndSticky === true, // 📖 false by default: favorites follow normal sort/filter rules until Y enables pinned+sticky mode.
     footerHidden: config.settings?.footerHidden === true, // 📖 true = footer is collapsed to a single toggle hint
@@ -739,6 +744,8 @@ export async function runApp(cliArgs, config) {
   function applyTierFilter() {
     const activeTier = TIER_CYCLE[state.tierFilterMode]
     const activeOrigin = ORIGIN_CYCLE[state.originFilterMode]
+    const activeVerdict = VERDICT_CYCLE[state.verdictFilterMode]
+    const activeHealth = HEALTH_CYCLE[state.healthFilterMode]
     state.results.forEach(r => {
       // 📖 Sticky-favorites mode keeps favorites visible regardless of configured-only, tier, or provider filters.
       if (state.favoritesPinnedAndSticky && r.isFavorite) {
@@ -754,12 +761,16 @@ export async function runApp(cliArgs, config) {
         r.hidden = true
         return
       }
-      // 📖 Apply both tier and origin filters — model is hidden if it fails either
-      // 📖 TIER_LETTER_MAP is used so --tier S also includes S+ models (tier family behavior).
+      // 📖 Apply tier, origin, verdict, and health filters — model is hidden if it fails any
       const allowedTiers = (activeTier && TIER_LETTER_MAP[activeTier]) ? TIER_LETTER_MAP[activeTier] : [activeTier]
       const tierHide = activeTier !== null && !allowedTiers.includes(r.tier)
       const originHide = activeOrigin !== null && r.providerKey !== activeOrigin
-      if (tierHide || originHide) {
+      // 📖 Verdict filter: match against getVerdict(r) when active
+      const rVerdict = getVerdict(r)
+      const verdictHide = activeVerdict !== null && rVerdict !== activeVerdict
+      // 📖 Health filter: match against r.status when active
+      const healthHide = activeHealth !== null && r.status !== activeHealth
+      if (tierHide || originHide || verdictHide || healthHide) {
         r.hidden = true
         return
       }
@@ -864,6 +875,8 @@ export async function runApp(cliArgs, config) {
     runUpdate,
     startOpenClaw,
     startOpenCodeDesktop,
+    startOpenCodeWeb,
+    startKilo,
     startOpenCode,
     startExternalTool,
     getToolModeOrder,
@@ -1042,7 +1055,10 @@ export async function runApp(cliArgs, config) {
           state.versionAlertsEnabled,
           state.favoritesPinnedAndSticky,
           state.customTextFilter,
-          state.lastReleaseDate
+          state.lastReleaseDate,
+          state.footerHidden,
+          state.verdictFilterMode,
+          state.healthFilterMode
         )
       }
       tableContent = state.commandPaletteFrozenTable
@@ -1077,7 +1093,10 @@ export async function runApp(cliArgs, config) {
         state.versionAlertsEnabled,
         state.favoritesPinnedAndSticky,
         state.customTextFilter,
-        state.lastReleaseDate
+        state.lastReleaseDate,
+        state.footerHidden,
+        state.verdictFilterMode,
+        state.healthFilterMode
       )
     }
 
@@ -1121,7 +1140,7 @@ export async function runApp(cliArgs, config) {
     pinFavorites: state.favoritesPinnedAndSticky,
   })
 
-      process.stdout.write(ALT_HOME + renderTable(state.results, state.pendingPings, state.frame, state.cursor, state.sortColumn, state.sortDirection, state.pingInterval, state.lastPingTime, state.mode, state.tierFilterMode, state.scrollOffset, state.terminalRows, state.terminalCols, state.originFilterMode, null, state.pingMode, state.pingModeSource, state.hideUnconfiguredModels, state.widthWarningStartedAt, state.widthWarningDismissed, state.widthWarningShowCount, state.settingsUpdateState, state.settingsUpdateLatestVersion, false, state.startupLatestVersion, state.versionAlertsEnabled, state.favoritesPinnedAndSticky, state.customTextFilter, state.lastReleaseDate, state.footerHidden))
+      process.stdout.write(ALT_HOME + renderTable(state.results, state.pendingPings, state.frame, state.cursor, state.sortColumn, state.sortDirection, state.pingInterval, state.lastPingTime, state.mode, state.tierFilterMode, state.scrollOffset, state.terminalRows, state.terminalCols, state.originFilterMode, null, state.pingMode, state.pingModeSource, state.hideUnconfiguredModels, state.widthWarningStartedAt, state.widthWarningDismissed, state.widthWarningShowCount, state.settingsUpdateState, state.settingsUpdateLatestVersion, false, state.startupLatestVersion, state.versionAlertsEnabled, state.favoritesPinnedAndSticky, state.customTextFilter, state.lastReleaseDate, state.footerHidden, state.verdictFilterMode, state.healthFilterMode))
   if (process.stdout.isTTY) {
     process.stdout.flush && process.stdout.flush()
   }

package/src/command-palette.js

@@ -20,11 +20,13 @@ import { TOOL_METADATA, TOOL_MODE_ORDER } from './tool-metadata.js'
 const TOOL_MODE_DESCRIPTIONS = {
   opencode: 'Launch in OpenCode CLI with the selected model.',
   'opencode-desktop': 'Set model in shared config, then open OpenCode Desktop.',
+  'opencode-web': 'Set model in shared config, then open OpenCode WebUI.',
   openclaw: 'Set default model in OpenClaw and launch it.',
   crush: 'Launch Crush with this provider/model pair.',
   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/constants.js

@@ -77,6 +77,14 @@ export const FRAMES = ['⠋','⠙','⠹','⠸','⠼','⠴','⠦','⠧','⠇','
 // 📖 Index 0 = no filter (show all), then each tier name in descending quality order.
 export const TIER_CYCLE = [null, 'S+', 'S', 'A+', 'A', 'A-', 'B+', 'B', 'C']
 
+// 📖 VERDICT_CYCLE: cycles through health verdict labels (0=All, then each verdict).
+// 📖 Based on VERDICT_ORDER from utils.js — includes all possible getVerdict() values.
+export const VERDICT_CYCLE = [null, 'Perfect', 'Normal', 'Slow', 'Spiky', 'Very Slow', 'Overloaded', 'Unstable', 'Not Active', 'Pending']
+
+// 📖 HEALTH_CYCLE: cycles through ping status states (0=All, then each status).
+// 📖 Based on the status values in the app: up, timeout, down, auth_error, noauth, pending.
+export const HEALTH_CYCLE = [null, 'up', 'timeout', 'down', 'auth_error', 'noauth', 'pending']
+
 // 📖 Overlay background chalk functions — each overlay panel has a distinct tint
 // 📖 so users can tell Settings, Help, Recommend, and Log panels apart at a glance.
 export const SETTINGS_OVERLAY_BG  = chalk.bgRgb(0, 0, 0)
@@ -93,8 +101,8 @@ export const WIDTH_WARNING_MIN_COLS = 80
 
 // 📖 Table row-budget constants — must stay in sync with renderTable()'s actual output.
 // 📖 If this drifts, model rows overflow and can push the title row out of view.
-export const TABLE_HEADER_LINES = 4  // 📖 title, spacer, column headers, separator
-export const TABLE_FOOTER_LINES = 5  // 📖 spacer, hints line 1, hints line 2, spacer, credit+links
+export const TABLE_HEADER_LINES = 5  // 📖 title, filter bar, spacer, column headers, separator
+export const TABLE_FOOTER_LINES = 1  // 📖 single toggle-hint line when collapsed, full footer otherwise
 export const TABLE_FIXED_LINES  = TABLE_HEADER_LINES + TABLE_FOOTER_LINES
 
 // ─── Small cell-formatting helpers ────────────────────────────────────────────

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

@@ -39,7 +39,7 @@ import { getLastLayout, COLUMN_SORT_MAP } from './render-table.js'
 import { cycleThemeSetting, detectActiveTheme } from './theme.js'
 import { syncShellEnv, ensureShellRcSource, removeShellEnv } from './shell-env.js'
 import { buildCommandPaletteTree, flattenCommandTree, filterCommandPaletteEntries } from './command-palette.js'
-import { WIDTH_WARNING_MIN_COLS } from './constants.js'
+import { WIDTH_WARNING_MIN_COLS, VERDICT_CYCLE, HEALTH_CYCLE } from './constants.js'
 import { scanAllToolConfigs, softDeleteModel } from './installed-models-manager.js'
 import { startExternalTool } from './tool-launchers.js'
 
@@ -264,6 +264,8 @@ export function createKeyHandler(ctx) {
     runUpdate,
     startOpenClaw,
     startOpenCodeDesktop,
+    startOpenCodeWeb,
+    startKilo,
     startOpenCode,
     startExternalTool,
     getToolModeOrder,
@@ -495,6 +497,10 @@ export function createKeyHandler(ctx) {
       exitCode = await startOpenClaw(userSelected, state.config, { launchCli: true })
     } else if (state.mode === 'opencode-desktop') {
       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 {
@@ -2414,6 +2420,7 @@ export function createKeyHandler(ctx) {
       if (!state.config.settings || typeof state.config.settings !== 'object') state.config.settings = {}
       state.config.settings.footerHidden = state.footerHidden
       saveConfig(state.config)
+      state.frame++ // 📖 Force immediate re-render
       return
     }
 
@@ -2449,6 +2456,24 @@ export function createKeyHandler(ctx) {
       return
     }
 
+    // 📖 Verdict filter key: V = cycle through each verdict (All → Perfect → Normal → Slow → ... → All)
+    if (key.name === 'v') {
+      state.verdictFilterMode = (state.verdictFilterMode + 1) % VERDICT_CYCLE.length
+      applyTierFilter()
+      refreshVisibleSorted({ resetCursor: true })
+      persistUiSettings()
+      return
+    }
+
+    // 📖 Health filter key: H = cycle through each health status (All → Up → Timeout → Down → ... → All)
+    if (key.name === 'h') {
+      state.healthFilterMode = (state.healthFilterMode + 1) % HEALTH_CYCLE.length
+      applyTierFilter()
+      refreshVisibleSorted({ resetCursor: true })
+      persistUiSettings()
+      return
+    }
+
     // 📖 Help overlay key: Ctrl+H = toggle help overlay
     if (key.ctrl && key.name === 'h') {
       state.helpVisible = !state.helpVisible

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)
+}