@polderlabs/bizar 6.2.1 → 6.2.2

package/cli/bin.mjs

@@ -129,6 +129,7 @@ function showHelp() {
     eval                   Evaluate AI agent outputs against golden fixtures
     plan                   [v6.0.0+] Reserved for future plan management
     validate               Validate the Bizar install (21 checks)
+    setup-provider         Configure a provider in cline.json (since v6.2.2 installer doesn't touch providers)
 
   Examples:
     bizar install
@@ -205,6 +206,7 @@ async function main() {
       'audit', 'init', 'export', 'test-gate', 'dev-link', 'dev-unlink',
       'doctor', 'repair', 'heads-up', 'bg', 'digest', 'backup', 'restore',
       'agent-browser', 'update', 'providers', 'plan', 'validate',
+      'setup-provider',
     ]);
     const UTIL_ALIASES = new Set(['dashboard', 'agent-browser-up']);
     let mod;
@@ -515,6 +517,23 @@ async function main() {
       break;
     }
 
+    case 'setup-provider': {
+      const mod = await importCommand('setup-provider');
+      if (!mod) {
+        console.error(chalk.red(`  ✗ Could not load setup-provider command module`));
+        process.exit(EXIT_ERROR);
+        return;
+      }
+      dbg('loaded command module:', 'setup-provider');
+      const found = await mod.run(cmd, cmdArgs, isHelpRequest);
+      if (!found) {
+        console.error(chalk.red(`  ✗ Unknown command: ${cmd}`));
+        showHelp();
+        process.exit(EXIT_ERROR);
+      }
+      break;
+    }
+
     default: {
       console.error(chalk.red(`  ✗ Unknown command: ${cmd}`));
       showHelp();

package/cli/commands/setup-provider.mjs

@@ -0,0 +1,292 @@
+/**
+ * cli/commands/setup-provider.mjs
+ *
+ * v6.2.2 — `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`.
+ *
+ * Usage:
+ *   bizar setup-provider                     # interactive; default 9Router
+ *   bizar setup-provider --list              # print the 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 --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.
+ */
+import chalk from 'chalk';
+import { readFileSync, writeFileSync, existsSync, renameSync, copyFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { homedir } from 'node:os';
+
+function clineDir() {
+  if (process.env.CLINE_DIR && process.env.CLINE_DIR.trim()) {
+    return process.env.CLINE_DIR.trim();
+  }
+  if (process.platform === 'win32') {
+    return join(process.env.APPDATA || homedir(), 'cline');
+  }
+  return join(homedir(), '.cline');
+}
+
+const CLINE_DIR = clineDir();
+function clineJsonPath() { return join(clineDir(), 'cline.json'); }
+const DEFAULT_GATEWAY = 'http://localhost:20128/v1';
+const DEFAULT_PROVIDER = '9router';
+
+function readJsonSafe(file) {
+  try {
+    if (!existsSync(file)) return null;
+    return JSON.parse(readFileSync(file, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function writeJsonAtomic(file, data) {
+  const tmp = `${file}.tmp`;
+  writeFileSync(tmp, JSON.stringify(data, null, 2) + '\n');
+  renameSync(tmp, file);
+}
+
+/** Pretty-print the live model catalog from `${gateway}/v1/models`. */
+export async function listGatewayModels(gateway) {
+  const url = `${gateway.replace(/\/$/, '')}/models`;
+  const ac = new AbortController();
+  const timer = setTimeout(() => ac.abort(), 10000);
+  try {
+    const res = await fetch(url, { signal: ac.signal });
+    if (!res.ok) throw new Error(`GET ${url} returned HTTP ${res.status}`);
+    const body = await res.json();
+    const data = Array.isArray(body?.data) ? body.data : [];
+    return data.map((m) => ({
+      id: m.id,
+      ownedBy: m.owned_by || '(unknown)',
+    }));
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+/** Heuristic: an all-caps-with-underscores string is an env var name. */
+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] = {};
+  }
+  return {
+    [name]: {
+      baseUrl: gateway,
+      apiKey: looksLikeEnvVar(apiKey) ? `\${env:${apiKey}}` : apiKey,
+      models: modelsObj,
+    },
+  };
+}
+
+/** 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;
+  }
+  writeJsonAtomic(clineJsonPath(), cfg);
+  return { name: Object.keys(block)[0], path: clineJsonPath(), backup };
+}
+
+/** Remove a provider by name. */
+export function removeProvider(name) {
+  if (!existsSync(clineJsonPath())) {
+    throw new Error(`${clineJsonPath()} not found.`);
+  }
+  const cfg = readJsonSafe(clineJsonPath(), {});
+  if (!cfg.provider || !cfg.provider[name]) {
+    return { removed: false, name, reason: 'not present' };
+  }
+  delete cfg.provider[name];
+  writeJsonAtomic(clineJsonPath(), cfg);
+  return { removed: true, name, path: clineJsonPath() };
+}
+
+export function showSetupProviderHelp() {
+  console.log(`
+  bizar setup-provider — Configure a provider in cline.json
+
+  Usage:
+    bizar setup-provider                     Interactive setup (default: 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 --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.
+
+    The default gateway is the local 9Router at http://localhost:20128/v1.
+    The model catalog is fetched live from \${gateway}/v1/models.
+
+  Examples:
+    bizar setup-provider
+    bizar setup-provider --list
+    bizar setup-provider --gateway https://api.anthropic.com/v1 --key sk-ant-...
+
+  Related:
+    bizar connect        Interactive TUI for provider setup
+    bizar install        Installs the Bizar scaffolding (NOT provider config)
+    bizar validate       Confirms provider config is wired correctly
+  `);
+}
+
+export function parseFlags(args) {
+  const flags = {};
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === '--list') flags.list = 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 === '--remove' && i + 1 < args.length) { flags.remove = args[++i]; }
+    else if (a.startsWith('--remove=')) flags.remove = a.slice('--remove='.length);
+  }
+  return flags;
+}
+
+export async function runSetupProvider(args = []) {
+  if (args.includes('--help') || args.includes('-h')) {
+    showSetupProviderHelp();
+    return;
+  }
+  const flags = parseFlags(args);
+
+  // --list — print the catalog and exit
+  if (flags.list) {
+    const gateway = flags.gateway || DEFAULT_GATEWAY;
+    console.log(chalk.cyan(`\n  Model catalog from ${gateway}/models:\n`));
+    try {
+      const models = await listGatewayModels(gateway);
+      if (models.length === 0) {
+        console.log(chalk.yellow('  (catalog is empty)'));
+        return;
+      }
+      // Group by owner.
+      const byOwner = new Map();
+      for (const m of models) {
+        if (!byOwner.has(m.ownedBy)) byOwner.set(m.ownedBy, []);
+        byOwner.get(m.ownedBy).push(m.id);
+      }
+      for (const [owner, ids] of byOwner) {
+        console.log(chalk.bold(`  ${owner}:`));
+        for (const id of ids) {
+          console.log(`    ${id}`);
+        }
+      }
+    } catch (err) {
+      console.log(chalk.red(`  ✗ Failed to fetch catalog: ${err.message}`));
+      process.exit(1);
+    }
+    return;
+  }
+
+  // --remove <name>
+  if (flags.remove) {
+    try {
+      const r = removeProvider(flags.remove);
+      if (r.removed) {
+        console.log(chalk.green(`  ✓ Removed provider '${r.name}' from ${r.path}`));
+      } else {
+        console.log(chalk.yellow(`  ! Provider '${r.name}' was not present`));
+      }
+    } catch (err) {
+      console.log(chalk.red(`  ✗ ${err.message}`));
+      process.exit(1);
+    }
+    return;
+  }
+
+  // Default flow — set up a provider
+  const gateway = flags.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';
+
+  // Interactive prompt for the key if missing and we're on a TTY.
+  if (!flags.key && !process.env.NINEROUTER_KEY && !process.env.OPENAI_API_KEY &&
+      process.stdin.isTTY && process.stdout.isTTY) {
+    const { createInterface } = await import('node:readline/promises');
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+      const answer = await rl.question(`  Enter API key for ${name} (or env var name like NINEROUTER_KEY): `);
+      if (answer.trim()) {
+        Object.assign(flags, parseFlags(['--key', answer.trim()]));
+      }
+    } finally {
+      rl.close();
+    }
+  }
+
+  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'];
+  }
+
+  const block = buildProviderBlock({ name, gateway, apiKey: finalKey, models });
+  try {
+    const result = applyProviderBlock(block);
+    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('');
+    console.log(chalk.cyan('  Next: run `bizar validate` to confirm everything is wired up.'));
+  } catch (err) {
+    console.log(chalk.red(`  ✗ ${err.message}`));
+    process.exit(1);
+  }
+}
+
+// ── run() entry point (used by bin.mjs dispatcher) ─────────────────────────
+
+export async function run(name, args, isHelpRequest) {
+  if (name !== 'setup-provider') return false;
+  await runSetupProvider(args);
+  return true;
+}

package/cli/commands/setup-provider.test.mjs

@@ -0,0 +1,211 @@
+/**
+ * cli/commands/setup-provider.test.mjs
+ *
+ * v6.2.2 — Unit tests for the setup-provider subcommand.
+ *
+ * Exercises the pure helpers (`buildProviderBlock`, `parseFlags`)
+ * and the filesystem mutations (`applyProviderBlock`, `removeProvider`)
+ * with a mocked CLINE_DIR.
+ */
+import { test, describe, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, readFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+const {
+  buildProviderBlock,
+  applyProviderBlock,
+  removeProvider,
+  listGatewayModels,
+  parseFlags,
+} = await import('./setup-provider.mjs');
+
+const ORIG_CLINE_DIR = process.env.CLINE_DIR;
+let workDir;
+
+function freshWorkDir() {
+  workDir = mkdtempSync(join(tmpdir(), 'bizar-setup-provider-'));
+  process.env.CLINE_DIR = workDir;
+  return workDir;
+}
+
+function makeFakeClineJson(root, body = {}) {
+  const cfg = {
+    $schema: 'https://docs.cline.bot/config.json',
+    plugin: [],
+    default_agent: 'odin',
+    permission: 'allow',
+    snapshot: false,
+    ...body,
+  };
+  writeFileSync(join(root, 'cline.json'), JSON.stringify(cfg, null, 2));
+}
+
+beforeEach(() => {
+  workDir = freshWorkDir();
+});
+
+afterEach(() => {
+  if (workDir && existsSync(workDir)) rmSync(workDir, { recursive: true, force: true });
+  if (ORIG_CLINE_DIR === undefined) delete process.env.CLINE_DIR;
+  else process.env.CLINE_DIR = ORIG_CLINE_DIR;
+});
+
+describe('buildProviderBlock()', () => {
+  test('emits a baseUrl, apiKey, and bare modelIds', () => {
+    const block = buildProviderBlock({
+      name: '9router',
+      gateway: 'http://localhost:20128/v1',
+      apiKey: 'sk-test',
+      models: ['minimax/MiniMax-M3', 'minimax/MiniMax-M2.7'],
+    });
+    assert.ok(block['9router']);
+    assert.equal(block['9router'].baseUrl, 'http://localhost:20128/v1');
+    assert.equal(block['9router'].apiKey, 'sk-test');
+    assert.deepEqual(Object.keys(block['9router'].models), ['minimax/MiniMax-M3', 'minimax/MiniMax-M2.7']);
+  });
+
+  test('wraps env-var-style keys in ${env:...}', () => {
+    const block = buildProviderBlock({
+      name: '9router',
+      gateway: 'http://localhost:20128/v1',
+      apiKey: 'NINEROUTER_KEY',
+      models: ['minimax/MiniMax-M3'],
+    });
+    assert.equal(block['9router'].apiKey, '${env:NINEROUTER_KEY}');
+  });
+
+  test('keeps literal keys as-is when not env-var shaped', () => {
+    const block = buildProviderBlock({
+      name: 'custom',
+      gateway: 'https://x.example/v1',
+      apiKey: 'sk-abc-123',
+      models: ['m1'],
+    });
+    assert.equal(block['custom'].apiKey, 'sk-abc-123');
+  });
+});
+
+describe('applyProviderBlock()', () => {
+  test('writes a new provider to ~/.cline/cline.json', () => {
+    makeFakeClineJson(workDir);
+    const block = buildProviderBlock({
+      name: '9router',
+      gateway: 'http://localhost:20128/v1',
+      apiKey: 'sk-test',
+      models: ['minimax/MiniMax-M3'],
+    });
+    const r = applyProviderBlock(block);
+    assert.equal(r.name, '9router');
+    const cfg = JSON.parse(readFileSync(join(workDir, 'cline.json'), 'utf8'));
+    assert.ok(cfg.provider['9router']);
+    assert.equal(cfg.provider['9router'].baseUrl, 'http://localhost:20128/v1');
+  });
+
+  test('preserves other provider entries when adding a new one', () => {
+    makeFakeClineJson(workDir, {
+      provider: { existing: { baseUrl: 'https://a', apiKey: 'k', models: { m: {} } } },
+    });
+    const block = buildProviderBlock({
+      name: '9router',
+      gateway: 'http://localhost:20128/v1',
+      apiKey: 'sk-test',
+      models: ['minimax/MiniMax-M3'],
+    });
+    applyProviderBlock(block);
+    const cfg = JSON.parse(readFileSync(join(workDir, 'cline.json'), 'utf8'));
+    assert.ok(cfg.provider.existing, 'existing provider preserved');
+    assert.ok(cfg.provider['9router'], 'new provider added');
+  });
+
+  test('overwrites an existing provider with the same name', () => {
+    makeFakeClineJson(workDir, {
+      provider: { '9router': { baseUrl: 'https://old', apiKey: 'old', models: {} } },
+    });
+    const block = buildProviderBlock({
+      name: '9router',
+      gateway: 'http://localhost:20128/v1',
+      apiKey: 'new',
+      models: ['minimax/MiniMax-M3'],
+    });
+    applyProviderBlock(block);
+    const cfg = JSON.parse(readFileSync(join(workDir, 'cline.json'), 'utf8'));
+    assert.equal(cfg.provider['9router'].baseUrl, 'http://localhost:20128/v1');
+    assert.equal(cfg.provider['9router'].apiKey, 'new');
+    assert.ok(cfg.provider['9router'].models['minimax/MiniMax-M3']);
+  });
+
+  test('throws when cline.json is missing', () => {
+    // No makeFakeClineJson call
+    const block = buildProviderBlock({
+      name: '9router',
+      gateway: 'http://localhost:20128/v1',
+      apiKey: 'sk-test',
+      models: ['minimax/MiniMax-M3'],
+    });
+    assert.throws(() => applyProviderBlock(block), /not found/);
+  });
+
+  test('creates a backup file', () => {
+    makeFakeClineJson(workDir, {
+      plugin: [['./plugins/bizar', {}]],
+    });
+    const block = buildProviderBlock({
+      name: '9router',
+      gateway: 'http://localhost:20128/v1',
+      apiKey: 'sk-test',
+      models: ['minimax/MiniMax-M3'],
+    });
+    const r = applyProviderBlock(block);
+    assert.ok(existsSync(r.backup), 'backup file created');
+    const backup = JSON.parse(readFileSync(r.backup, 'utf8'));
+    assert.deepEqual(backup.plugin, [['./plugins/bizar', {}]]);
+  });
+});
+
+describe('removeProvider()', () => {
+  test('removes a named provider', () => {
+    makeFakeClineJson(workDir, {
+      provider: {
+        a: { baseUrl: 'https://a', apiKey: 'k', models: {} },
+        b: { baseUrl: 'https://b', apiKey: 'k', models: {} },
+      },
+    });
+    const r = removeProvider('a');
+    assert.equal(r.removed, true);
+    const cfg = JSON.parse(readFileSync(join(workDir, 'cline.json'), 'utf8'));
+    assert.equal(cfg.provider.a, undefined);
+    assert.ok(cfg.provider.b, 'untouched provider preserved');
+  });
+
+  test('returns removed=false for a missing provider', () => {
+    makeFakeClineJson(workDir);
+    const r = removeProvider('nonexistent');
+    assert.equal(r.removed, false);
+    assert.equal(r.reason, 'not present');
+  });
+});
+
+describe('parseFlags()', () => {
+  test('parses --gateway, --key, --provider with space separator', () => {
+    const f = parseFlags(['--gateway', 'http://x', '--key', 'sk-x', '--provider', 'foo']);
+    assert.equal(f.gateway, 'http://x');
+    assert.equal(f.key, 'sk-x');
+    assert.equal(f.provider, 'foo');
+  });
+
+  test('parses --gateway=, --key=, --provider= equals form', () => {
+    const f = parseFlags(['--gateway=http://x', '--key=sk-x', '--provider=foo']);
+    assert.equal(f.gateway, 'http://x');
+    assert.equal(f.key, 'sk-x');
+    assert.equal(f.provider, 'foo');
+  });
+
+  test('parses --list and --remove', () => {
+    const f = parseFlags(['--list']);
+    assert.equal(f.list, true);
+    const g = parseFlags(['--remove', 'myprov']);
+    assert.equal(g.remove, 'myprov');
+  });
+});

package/cli/commands/validate.mjs

@@ -51,7 +51,7 @@ const REQUIRED_COMMANDS = [
   'audit.md', 'bizar.md', 'explain.md', 'init.md', 'learn.md',
   'plan.md', 'plow-through.md', 'pr-review.md', 'tailscale-serve.md',
   'visual-plan.md',
-  'team.md', 'test.md', 'validate.md',
+  'team.md', 'test.md', 'validate.md', 'setup-provider.md',
 ];
 
 // v6.2.1 — Cline-native hook scripts (executable, shebang, no extension).
@@ -266,20 +266,22 @@ const CHECKS = {
   },
 
   'provider-config': async () => {
+    // v6.2.2 — The installer no longer adds a provider block. The user
+    // must configure their own provider. This check is therefore
+    // ALWAYS lenient (returns a hint, never fails). It just reports
+    // what's in cline.json so the user can see the current state.
     const cfg = readJsonSafe(clineJsonPath());
-    if (!cfg?.provider) throw new Error('no provider block in cline.json');
-    const nine = cfg.provider['9router'];
-    if (nine && nine.baseUrl) {
-      const models = nine.models || {};
-      const count = Object.keys(models).length;
-      if (count === 0) throw new Error('provider.9router has no models');
-      return `provider.9router (${count} models, baseUrl=${nine.baseUrl})`;
+    if (!cfg?.provider || Object.keys(cfg.provider).length === 0) {
+      return 'no provider configured — user must add one. `bizar install` no longer touches provider config (v6.2.2+).';
     }
-    const minimax = cfg.provider.minimax;
-    if (!minimax) {
-      throw new Error('no provider.9router AND no provider.minimax');
-    }
-    return 'provider.minimax (legacy fallback)';
+    const names = Object.keys(cfg.provider);
+    const summary = names.map((n) => {
+      const p = cfg.provider[n];
+      const url = p?.baseUrl || p?.options?.baseURL || '(no baseUrl)';
+      const modelCount = Object.keys(p?.models || {}).length;
+      return `${n} (${modelCount} models, baseUrl=${url})`;
+    });
+    return `user-configured providers: ${summary.join('; ')}`;
   },
 
   '9router-reachable': async () => {
@@ -372,7 +374,10 @@ const CHECK_ORDER = [
   '9router-reachable',
 ];
 
-const LENIENT_CHECKS = new Set(['9router-reachable']);
+const LENIENT_CHECKS = new Set([
+  '9router-reachable',
+  'provider-config', // v6.2.2+ — installer no longer touches provider config; user must configure
+]);
 
 export function showValidateHelp() {
   console.log(`

package/cli/commands/validate.test.mjs

@@ -68,7 +68,7 @@ function makeFakeClineInstall(root) {
     'audit.md', 'bizar.md', 'explain.md', 'init.md', 'learn.md',
     'plan.md', 'plow-through.md', 'pr-review.md', 'tailscale-serve.md',
     'visual-plan.md',
-    'team.md', 'test.md', 'validate.md',
+    'team.md', 'test.md', 'validate.md', 'setup-provider.md',
   ]) {
     writeFileSync(join(cmdsDir, f), '# fake command');
   }
@@ -205,28 +205,54 @@ describe('runValidate() — JSON output', () => {
     assert.equal(exitCode, 1, 'should fail when enableAgentTeams is false');
   });
 
-  test('fails when provider config is missing', async () => {
+  test('passes when no provider is configured (v6.2.2+ — user must configure)', async () => {
+    // v6.2.2: the installer no longer touches provider config. The
+    // user must add their own provider. The provider-config check
+    // is therefore ALWAYS lenient — it just reports state.
     const cfg = JSON.parse(readFileSync(join(workDir, 'cline.json'), 'utf8'));
     delete cfg.provider;
     writeFileSync(join(workDir, 'cline.json'), JSON.stringify(cfg, null, 2));
-    const { exitCode } = await captureRun({ json: true });
-    assert.equal(exitCode, 1);
+    const { exitCode, stdout } = await captureRun({ json: true });
+    assert.equal(exitCode, 0, 'no-provider must not fail validation (v6.2.2+ contract)');
+    const parsed = JSON.parse(stdout);
+    const p = parsed.results.find((r) => r.name === 'provider-config');
+    assert.ok(p, 'provider-config check should be present');
+    assert.equal(p.ok, true, 'provider-config always returns ok (lenient)');
+    assert.match(p.message, /no provider configured/);
   });
 
-  test('passes when only 9router is configured (no minimax)', async () => {
+  test('reports user-configured providers when present', async () => {
+    // User has set up their own provider (anything goes).
     const cfg = JSON.parse(readFileSync(join(workDir, 'cline.json'), 'utf8'));
-    delete cfg.provider.minimax;
+    cfg.provider = {
+      'my-custom-provider': {
+        baseUrl: 'https://my-llm.example/v1',
+        apiKey: 'sk-test',
+        models: { 'my-model-1': {}, 'my-model-2': {} },
+      },
+    };
     writeFileSync(join(workDir, 'cline.json'), JSON.stringify(cfg, null, 2));
-    const { exitCode } = await captureRun({ json: true });
+    const { exitCode, stdout } = await captureRun({ json: true });
     assert.equal(exitCode, 0);
+    const parsed = JSON.parse(stdout);
+    const p = parsed.results.find((r) => r.name === 'provider-config');
+    assert.match(p.message, /my-custom-provider/);
+    assert.match(p.message, /2 models/);
   });
 
-  test('passes when only minimax is configured (no 9router)', async () => {
+  test('reports both providers if user has multiple', async () => {
     const cfg = JSON.parse(readFileSync(join(workDir, 'cline.json'), 'utf8'));
-    delete cfg.provider['9router'];
+    cfg.provider = {
+      'a': { baseUrl: 'https://a.example/v1', models: { 'm1': {} } },
+      'b': { baseUrl: 'https://b.example/v1', models: { 'm2': {}, 'm3': {} } },
+    };
     writeFileSync(join(workDir, 'cline.json'), JSON.stringify(cfg, null, 2));
-    const { exitCode } = await captureRun({ json: true });
+    const { exitCode, stdout } = await captureRun({ json: true });
     assert.equal(exitCode, 0);
+    const parsed = JSON.parse(stdout);
+    const p = parsed.results.find((r) => r.name === 'provider-config');
+    assert.match(p.message, /\ba\b/);
+    assert.match(p.message, /\bb\b/);
   });
 
   test('default mode is lenient on 9router-unreachable', async () => {