@polderlabs/bizar 6.2.2 → 6.2.4

package/cli/commands/setup-provider.mjs

@@ -1,25 +1,36 @@
 /**
  * cli/commands/setup-provider.mjs
  *
- * v6.2.2 — `bizar setup-provider` subcommand.
+ * v6.2.3 — `bizar setup-provider` subcommand.
  *
- * The Bizar installer no longer touches provider config. This command
- * is the supported way to add or update a provider in `~/.cline/cline.json`.
+ * v6.2.2 wrote to `~/.cline/cline.json` (the harness config). That was
+ * the wrong place — the Cline CLI and kanban mode read from
+ * `~/.cline/data/settings/providers.json` (the real Cline settings
+ * file). v6.2.3 fixes this.
+ *
+ * The default providerId is `litellm` because:
+ *   - It's a real entry in Cline's built-in provider catalog (works
+ *     in both Cline CLI AND kanban mode)
+ *   - It's `family: "openai-compatible"` and accepts a custom
+ *     baseUrl — the perfect match for the local 9Router gateway
+ *   - The previous v6.2.2 default `9router` (and the user's hand-
+ *     written `openai-compatible`) are NOT in Cline's catalog, so
+ *     kanban mode fails with "Unknown or disabled provider".
  *
  * Usage:
- *   bizar setup-provider                     # interactive; default 9Router
- *   bizar setup-provider --list              # print the model catalog
+ *   bizar setup-provider                     # default 9Router gateway, litellm provider
+ *   bizar setup-provider --list              # print the live model catalog
  *   bizar setup-provider --gateway <url>     # override gateway URL
  *   bizar setup-provider --key <key>         # provider API key
- *   bizar setup-provider --provider <name>   # provider name in cline.json
+ *   bizar setup-provider --provider <name>   # built-in providerId (default: litellm)
+ *   bizar setup-provider --discover          # auto-detect a local gateway and configure
  *   bizar setup-provider --remove <name>     # remove a provider
  *
  * The default gateway is the local 9Router at http://localhost:20128/v1.
- * The catalog is fetched live from `${gateway}/v1/models` so the user
- * always gets the up-to-date list.
+ * The model catalog is fetched live from `${gateway}/v1/models`.
  */
 import chalk from 'chalk';
-import { readFileSync, writeFileSync, existsSync, renameSync, copyFileSync } from 'node:fs';
+import { readFileSync, writeFileSync, existsSync, renameSync, copyFileSync, mkdirSync, readdirSync, statSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { homedir } from 'node:os';
 
@@ -33,10 +44,38 @@ function clineDir() {
   return join(homedir(), '.cline');
 }
 
-const CLINE_DIR = clineDir();
-function clineJsonPath() { return join(clineDir(), 'cline.json'); }
+function dataDir() {
+  if (process.env.CLINE_DATA_DIR && process.env.CLINE_DATA_DIR.trim()) {
+    return process.env.CLINE_DATA_DIR.trim();
+  }
+  return join(clineDir(), 'data');
+}
+
+/** Path to the Cline settings file the CLI + kanban actually read. */
+function settingsPath() {
+  if (process.env.CLINE_PROVIDER_SETTINGS_PATH && process.env.CLINE_PROVIDER_SETTINGS_PATH.trim()) {
+    return process.env.CLINE_PROVIDER_SETTINGS_PATH.trim();
+  }
+  return join(dataDir(), 'settings', 'providers.json');
+}
+
 const DEFAULT_GATEWAY = 'http://localhost:20128/v1';
-const DEFAULT_PROVIDER = '9router';
+// v6.2.3 — `litellm` is the right built-in providerId for a custom
+// OpenAI-compatible endpoint. It's in Cline's catalog (so kanban
+// mode recognizes it) and accepts a custom baseUrl.
+const DEFAULT_PROVIDER = 'litellm';
+
+// v6.2.3 — Built-in Cline providerIds that support `family: "openai-compatible"`
+// with a custom baseUrl. These are the ones the user can pick for
+// "I have my own OpenAI-compatible endpoint". `9router`, `openai-compatible`
+// and other fake IDs are NOT in this list — they fail in kanban mode.
+export const OPENAI_COMPATIBLE_PROVIDERS = [
+  'litellm',      // best fit: defaults to localhost:4000, openai-responses
+  'cline',        // Cline's own API (can be overridden)
+  'ollama',       // localhost:11434
+  'lmstudio',     // localhost:1234
+  'huggingface',  // api-inference.huggingface.co
+];
 
 function readJsonSafe(file) {
   try {
@@ -48,6 +87,7 @@ function readJsonSafe(file) {
 }
 
 function writeJsonAtomic(file, data) {
+  mkdirSync(dirname(file), { recursive: true });
   const tmp = `${file}.tmp`;
   writeFileSync(tmp, JSON.stringify(data, null, 2) + '\n');
   renameSync(tmp, file);
@@ -77,86 +117,173 @@ function looksLikeEnvVar(s) {
   return /^[A-Z][A-Z0-9_]{1,}$/.test(s);
 }
 
-/** Build the cline.json provider block. */
-export function buildProviderBlock({ name, gateway, apiKey, models }) {
-  // Cline supports two ways to express a model:
-  //   - just a string modelId under `models`
-  //   - an object with metadata (interleaved, reasoning, etc.)
-  // We emit the simplest possible form: the bare modelId. The user can
-  // add metadata later by editing the file.
-  const modelsObj = {};
-  for (const m of models) {
-    modelsObj[m] = {};
-  }
+/**
+ * v6.2.3 — Build the Cline settings.json entry for one provider.
+ *
+ * The shape matches `~/.cline/data/settings/providers.json`:
+ *   { "version": 1, "lastUsedProvider": "litellm", "providers": { "litellm": { ... } } }
+ */
+export function buildProviderBlock({ name, gateway, apiKey, model, reason = false }) {
   return {
-    [name]: {
-      baseUrl: gateway,
+    settings: {
+      provider: name,
+      model,
       apiKey: looksLikeEnvVar(apiKey) ? `\${env:${apiKey}}` : apiKey,
-      models: modelsObj,
+      baseUrl: gateway,
+      ...(reason ? { reasoning: { enabled: true, effort: 'medium' } } : { reasoning: { enabled: false, effort: 'medium' } }),
     },
+    updatedAt: new Date().toISOString(),
+    tokenSource: 'manual',
   };
 }
 
-/** Apply a provider block atomically to ~/.cline/cline.json. */
-export function applyProviderBlock(block) {
-  if (!existsSync(clineJsonPath())) {
-    throw new Error(
-      `${clineJsonPath()} not found. Run \`bizar install\` first to set up the Bizar scaffolding.`,
-    );
-  }
-  // Back up the original before mutating.
-  const backup = `${clineJsonPath()}.bak`;
-  try { copyFileSync(clineJsonPath(), backup); } catch { /* best-effort */ }
-
-  const cfg = readJsonSafe(clineJsonPath(), {});
-  if (!cfg.provider || typeof cfg.provider !== 'object') cfg.provider = {};
-  for (const [name, body] of Object.entries(block)) {
-    cfg.provider[name] = body;
+/** Apply (create or update) one provider in the settings file. */
+export function applyProviderBlock(name, body) {
+  const file = settingsPath();
+  if (!existsSync(file)) {
+    // Bootstrap with a minimal but valid providers.json
+    const bootstrap = { version: 1, providers: {}, lastUsedProvider: name };
+    writeJsonAtomic(file, bootstrap);
   }
-  writeJsonAtomic(clineJsonPath(), cfg);
-  return { name: Object.keys(block)[0], path: clineJsonPath(), backup };
+  const backup = `${file}.bak`;
+  try { copyFileSync(file, backup); } catch { /* best-effort */ }
+
+  const cfg = readJsonSafe(file, { version: 1, providers: {} });
+  if (!cfg.providers || typeof cfg.providers !== 'object') cfg.providers = {};
+  cfg.providers[name] = body;
+  // v6.2.3 — Always set lastUsedProvider to the most recently applied
+  // provider. The user is actively configuring this one; they want
+  // it to be the active one. (Previous v6.2.2 only set it when missing,
+  // which left stale `lastUsedProvider: "openai-compatible"` entries
+  // in the file when the user upgraded.)
+  cfg.lastUsedProvider = name;
+  cfg.version = cfg.version || 1;
+  writeJsonAtomic(file, cfg);
+  return { name, path: file, backup };
 }
 
-/** Remove a provider by name. */
+/** Remove a provider by name from the settings file. */
 export function removeProvider(name) {
-  if (!existsSync(clineJsonPath())) {
-    throw new Error(`${clineJsonPath()} not found.`);
-  }
-  const cfg = readJsonSafe(clineJsonPath(), {});
-  if (!cfg.provider || !cfg.provider[name]) {
+  const file = settingsPath();
+  if (!existsSync(file)) return { removed: false, name, reason: 'no settings file' };
+  const cfg = readJsonSafe(file, { version: 1, providers: {} });
+  if (!cfg.providers || !cfg.providers[name]) {
     return { removed: false, name, reason: 'not present' };
   }
-  delete cfg.provider[name];
-  writeJsonAtomic(clineJsonPath(), cfg);
-  return { removed: true, name, path: clineJsonPath() };
+  delete cfg.providers[name];
+  if (cfg.lastUsedProvider === name) {
+    cfg.lastUsedProvider = Object.keys(cfg.providers)[0] || undefined;
+  }
+  writeJsonAtomic(file, cfg);
+  return { removed: true, name, path: file };
+}
+
+/**
+ * v6.2.3 — Detect the broken `openai-compatible` providerId pattern
+ * from earlier installs and the Cline v6.0.1 migration shim.
+ *
+ * Background: v6.0.1's Cline auto-migration created synthetic providers
+ * with `provider: "openai-compatible"` (the `family`, not a real
+ * `id`). Cline CLI accepts this, but Cline kanban mode looks up the
+ * provider in its built-in catalog and fails with:
+ *   "Unknown or disabled provider \"openai-compatible\"."
+ *
+ * The fix: if the settings file has a `provider: "openai-compatible"`
+ * entry, rename it to a real catalog ID (default `litellm`) so
+ * kanban mode recognizes it. We do this IN-PLACE without losing the
+ * user's baseUrl, apiKey, or model.
+ */
+export function migrateLegacyOpenaiCompatible(targetName = 'litellm') {
+  const file = settingsPath();
+  if (!existsSync(file)) return { migrated: false, reason: 'no settings file' };
+  const cfg = readJsonSafe(file, { version: 1, providers: {} });
+  const broken = cfg.providers && cfg.providers['openai-compatible'];
+  if (!broken) return { migrated: false, reason: 'no legacy entry' };
+
+  // Move the entry to a real providerId.
+  const newBody = { ...broken };
+  // Strip the `provider: "openai-compatible"` field (replaced by the
+  // real providerId at the top level) and keep the rest (baseUrl,
+  // apiKey, model, reasoning, etc.).
+  if (newBody.settings) {
+    newBody.settings.provider = targetName;
+  }
+  cfg.providers[targetName] = newBody;
+  delete cfg.providers['openai-compatible'];
+  // If the broken entry was the active one, switch the new one in.
+  if (cfg.lastUsedProvider === 'openai-compatible' || !cfg.lastUsedProvider) {
+    cfg.lastUsedProvider = targetName;
+  }
+  writeJsonAtomic(file, cfg);
+  return { migrated: true, from: 'openai-compatible', to: targetName, path: file };
+}
+
+/**
+ * v6.2.3 — `bizar setup-provider --discover`.
+ *
+ * Probe a list of well-known local gateway URLs and use the first one
+ * that responds. Then write the provider block with the discovered URL.
+ */
+export async function discoverLocalGateway() {
+  const candidates = [
+    'http://localhost:20128/v1', // 9Router (Bizar default)
+    'http://127.0.0.1:20128/v1',
+    'http://localhost:4000/v1',  // LiteLLM
+    'http://localhost:11434/v1', // Ollama
+    'http://localhost:1234/v1',  // LM Studio
+  ];
+  for (const url of candidates) {
+    try {
+      const models = await listGatewayModels(url);
+      if (models.length > 0) {
+        return { url, modelCount: models.length, models };
+      }
+    } catch {
+      // Try the next one
+    }
+  }
+  return null;
 }
 
 export function showSetupProviderHelp() {
   console.log(`
-  bizar setup-provider — Configure a provider in cline.json
+  bizar setup-provider — Configure a provider in Cline's settings
 
   Usage:
-    bizar setup-provider                     Interactive setup (default: 9Router gateway)
+    bizar setup-provider                     Interactive setup (default: litellm + 9Router gateway)
     bizar setup-provider --list              Print the live model catalog
     bizar setup-provider --gateway <url>     Override the gateway URL (default: http://localhost:20128/v1)
     bizar setup-provider --key <key>         Provider API key
                                             - All-caps-with-underscores → \${env:KEY}
                                             - Otherwise → literal value
-    bizar setup-provider --provider <name>   Provider name in cline.json (default: 9router)
+    bizar setup-provider --provider <name>   Built-in providerId (default: litellm)
+                                            See OPENAI_COMPATIBLE_PROVIDERS for the supported list
+    bizar setup-provider --model <id>        Model ID (default: first model from \${gateway}/v1/models)
+    bizar setup-provider --discover          Auto-detect a local gateway and configure
     bizar setup-provider --remove <name>     Remove a provider by name
     bizar setup-provider --help              Show this help
 
   Description:
     Since v6.2.2 the Bizar installer no longer touches provider config.
-    Use this command to add or update a provider in ~/.cline/cline.json.
+    Use this command to add or update a provider in
+    \`~/.cline/data/settings/providers.json\` (the file the Cline CLI
+    and kanban mode both read).
 
-    The default gateway is the local 9Router at http://localhost:20128/v1.
-    The model catalog is fetched live from \${gateway}/v1/models.
+    v6.2.3 changed the default providerId from \`9router\` to \`litellm\`.
+    \`litellm\` is a real entry in Cline's built-in catalog (so it works
+    in kanban mode), \`family: "openai-compatible"\`, and accepts a
+    custom baseUrl — perfect for the local 9Router gateway.
+
+    The previous v6.2.2 default \`9router\` and any hand-written
+    providerId like \`openai-compatible\` are NOT in Cline's catalog,
+    so they fail in kanban mode with:
+      "Unknown or disabled provider \\"openai-compatible\\"."
 
   Examples:
     bizar setup-provider
     bizar setup-provider --list
-    bizar setup-provider --gateway https://api.anthropic.com/v1 --key sk-ant-...
+    bizar setup-provider --discover
+    bizar setup-provider --provider ollama --gateway http://localhost:11434/v1
 
   Related:
     bizar connect        Interactive TUI for provider setup
@@ -170,12 +297,15 @@ export function parseFlags(args) {
   for (let i = 0; i < args.length; i++) {
     const a = args[i];
     if (a === '--list') flags.list = true;
+    else if (a === '--discover') flags.discover = true;
     else if (a === '--gateway' && i + 1 < args.length) { flags.gateway = args[++i]; }
     else if (a.startsWith('--gateway=')) flags.gateway = a.slice('--gateway='.length);
     else if (a === '--key' && i + 1 < args.length) { flags.key = args[++i]; }
     else if (a.startsWith('--key=')) flags.key = a.slice('--key='.length);
     else if (a === '--provider' && i + 1 < args.length) { flags.provider = args[++i]; }
     else if (a.startsWith('--provider=')) flags.provider = a.slice('--provider='.length);
+    else if (a === '--model' && i + 1 < args.length) { flags.model = args[++i]; }
+    else if (a.startsWith('--model=')) flags.model = a.slice('--model='.length);
     else if (a === '--remove' && i + 1 < args.length) { flags.remove = args[++i]; }
     else if (a.startsWith('--remove=')) flags.remove = a.slice('--remove='.length);
   }
@@ -189,6 +319,19 @@ export async function runSetupProvider(args = []) {
   }
   const flags = parseFlags(args);
 
+  // v6.2.3 — Auto-migrate the legacy `openai-compatible` providerId
+  // shim. This runs on every invocation (except --help/--list/--remove)
+  // because it's idempotent and fixes a real bug. Users who hit
+  // "Unknown or disabled provider openai-compatible" in kanban mode
+  // get healed automatically the next time they run setup-provider.
+  if (!flags.list && !flags.remove) {
+    const mig = migrateLegacyOpenaiCompatible(DEFAULT_PROVIDER);
+    if (mig.migrated) {
+      console.log(chalk.yellow(`\n  ⚠ Migrated legacy '${mig.from}' → '${mig.to}'`));
+      console.log(chalk.yellow('    (kanban mode requires a built-in providerId; litellm works for any OpenAI-compatible endpoint.)'));
+    }
+  }
+
   // --list — print the catalog and exit
   if (flags.list) {
     const gateway = flags.gateway || DEFAULT_GATEWAY;
@@ -234,8 +377,27 @@ export async function runSetupProvider(args = []) {
     return;
   }
 
-  // Default flow — set up a provider
-  const gateway = flags.gateway || DEFAULT_GATEWAY;
+  // --discover — auto-detect a local gateway
+  let gateway = flags.gateway;
+  if (flags.discover || (!gateway && !flags.key)) {
+    console.log(chalk.cyan('\n  Probing for local gateways...'));
+    const found = await discoverLocalGateway();
+    if (found) {
+      gateway = found.url;
+      console.log(chalk.green(`  ✓ Found ${found.modelCount} model(s) at ${found.url}`));
+    } else if (flags.discover) {
+      console.log(chalk.red('  ✗ No local gateway found. Tried:'));
+      for (const c of ['20128 (9Router)', '4000 (LiteLLM)', '11434 (Ollama)', '1234 (LM Studio)']) {
+        console.log(chalk.red(`    - localhost:${c.split(' ')[0]}`));
+      }
+      process.exit(1);
+    } else {
+      gateway = DEFAULT_GATEWAY;
+      console.log(chalk.dim(`  ! No local gateway detected, using default ${gateway}`));
+    }
+  }
+  gateway = gateway || DEFAULT_GATEWAY;
+
   const name = flags.provider || DEFAULT_PROVIDER;
   const apiKey = flags.key || process.env.NINEROUTER_KEY || process.env.OPENAI_API_KEY || 'sk-replace-me';
 
@@ -256,27 +418,39 @@ export async function runSetupProvider(args = []) {
 
   const finalKey = flags.key || apiKey;
 
-  console.log(chalk.cyan(`\n  Fetching model catalog from ${gateway}...`));
-  let models = [];
-  try {
-    const catalog = await listGatewayModels(gateway);
-    models = catalog.map((m) => m.id);
-    console.log(chalk.green(`  ✓ Found ${models.length} model(s)`));
-  } catch (err) {
-    console.log(chalk.yellow(`  ! Could not fetch catalog (${err.message})`));
-    console.log(chalk.yellow(`    Continuing with a minimal catalog.`));
-    models = ['minimax/MiniMax-M3', 'minimax/MiniMax-M2.7'];
+  // Pick the model: explicit > first from catalog > sensible default.
+  let model = flags.model;
+  if (!model) {
+    console.log(chalk.cyan(`\n  Fetching model catalog from ${gateway}...`));
+    try {
+      const catalog = await listGatewayModels(gateway);
+      if (catalog.length > 0) {
+        // Prefer minimaxcustom/MiniMax-M3 if available (the Bizar default model)
+        const preferred = catalog.find((m) => m.id === 'minimaxcustom/MiniMax-M3');
+        model = preferred ? preferred.id : catalog[0].id;
+        console.log(chalk.green(`  ✓ Found ${catalog.length} model(s); using '${model}'`));
+      } else {
+        model = 'minimaxcustom/MiniMax-M3';
+        console.log(chalk.yellow(`  ! Empty catalog; defaulting to ${model}`));
+      }
+    } catch (err) {
+      model = 'minimaxcustom/MiniMax-M3';
+      console.log(chalk.yellow(`  ! Could not fetch catalog (${err.message}); defaulting to ${model}`));
+    }
   }
 
-  const block = buildProviderBlock({ name, gateway, apiKey: finalKey, models });
+  const body = buildProviderBlock({ name, gateway, apiKey: finalKey, model });
   try {
-    const result = applyProviderBlock(block);
+    const result = applyProviderBlock(name, body);
     console.log(chalk.green(`\n  ✓ Provider '${result.name}' written to ${result.path}`));
     console.log(chalk.dim(`    backup: ${result.backup}`));
     console.log(chalk.dim(`    baseUrl: ${gateway}`));
-    console.log(chalk.dim(`    models: ${models.length}`));
+    console.log(chalk.dim(`    model: ${model}`));
+    console.log(chalk.dim(`    apiKey: ${looksLikeEnvVar(finalKey) ? `\${env:${finalKey}}` : (finalKey.length > 12 ? finalKey.slice(0, 8) + '...' : finalKey)}`));
     console.log('');
-    console.log(chalk.cyan('  Next: run `bizar validate` to confirm everything is wired up.'));
+    console.log(chalk.cyan('  Next:'));
+    console.log(chalk.cyan('    • Run `bizar validate` to confirm everything is wired up.'));
+    console.log(chalk.cyan('    • The same provider now works in both `cline` CLI and `cline --kanban` mode.'));
   } catch (err) {
     console.log(chalk.red(`  ✗ ${err.message}`));
     process.exit(1);