mixdog 0.7.17 → 0.7.18

package/scripts/gateway-model.mjs

@@ -0,0 +1,596 @@
+#!/usr/bin/env bun
+/**
+ * mixdog gateway model selector — backs the /mixdog:model slash command.
+ *
+ * Usage:
+ *   bun scripts/gateway-model.mjs                              # list providers/models + current target
+ *   bun scripts/gateway-model.mjs --json                      # same, machine-readable
+ *   bun scripts/gateway-model.mjs --set <provider> [model]    # set routing target (config only)
+ *   bun scripts/gateway-model.mjs --enable <provider> [model] # set routing + modules.gateway.enabled
+ *                                                             #   AND point Claude Code at the gateway
+ *   bun scripts/gateway-model.mjs --disable                   # remove the settings.json env entry
+ *                                                             #   (and set modules.gateway.enabled=false)
+ *   bun scripts/gateway-model.mjs on [provider] [model]       # alias of --enable; bare `on` reuses
+ *                                                             #   the current target
+ *   bun scripts/gateway-model.mjs off                         # alias of --disable
+ *
+ * --set / --enable write gateway.defaultProvider / gateway.defaultModel and
+ * modules.gateway.enabled into mixdog-config.json through the SAME write path
+ * the setup UI uses (updateSection from src/shared/config.mjs: file lock +
+ * atomic RMW + backup restore). When <model> is omitted, the provider's first
+ * preset model (or its configured `model`) is used.
+ *
+ * Only --enable / --disable ever touch Claude Code's settings.json:
+ *   • --enable  writes env.ANTHROPIC_BASE_URL = http://127.0.0.1:<gatewayPort>
+ *   • --disable removes that one env key (restore), leaving env otherwise intact
+ * via the SAME safe read-merge-write path injectStatusLine() uses in
+ * hooks/session-start.cjs (.mixdog-tmp sibling + atomic rename).
+ *
+ * If the gateway child is RUNNING, it re-reads gateway.defaultProvider /
+ * gateway.defaultModel per request (1.5s TTL cache) and lazily inits the
+ * selected provider, so a routing change takes effect on the NEXT request
+ * WITHOUT a gateway restart. server-main also watches modules.gateway.enabled,
+ * so --enable/`on` live-starts the gateway child and --disable/`off` live-stops
+ * it in the current daemon. Claude Code itself still reads ANTHROPIC_BASE_URL
+ * only at process start, so settings.json changes require a Claude Code restart
+ * if the current process did not already load that env.
+ *
+ * Pure Node/Bun built-ins + the shared config module. Exit 0 on success,
+ * 1 on error / unknown provider.
+ */
+import { dirname, join, basename } from 'path';
+import { existsSync, readFileSync } from 'fs';
+import { tmpdir, homedir } from 'os';
+import { fileURLToPath, pathToFileURL } from 'url';
+import net from 'net';
+import { execFileSync } from 'child_process';
+// Shared settings.json env writer — SAME helper uninstall.mjs uses, so
+// --enable / --disable / uninstall never diverge on path or write mechanics.
+import { resolveSettingsPath, setAnthropicBaseUrl } from './lib/gateway-settings.mjs';
+// Shared inventory + target-write helpers — SAME module the gateway_select_model
+// elicitation tool (src/agent/index.mjs) uses, so the CLI and the interactive
+// dropdown build the model list and persist the target through one code path.
+import { buildInventory as buildInventoryFromConfig, inventoryChoices, resolveTargetChoice, writeGatewayTarget } from './lib/gateway-inventory.mjs';
+import { CLAUDE_CURRENT_CHOICE_ID, CLAUDE_CURRENT_MODE } from '../src/gateway/claude-current.mjs';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PLUGIN_ROOT = process.env.CLAUDE_PLUGIN_ROOT || dirname(__dirname);
+
+// The /mixdog:model slash command (commands/model.md) runs
+// `!bun ".../scripts/gateway-model.mjs"` and only interpolates
+// ${CLAUDE_PLUGIN_ROOT} into the PATH argument — it does NOT propagate
+// CLAUDE_PLUGIN_DATA / CLAUDE_PLUGIN_ROOT into the child process env. The
+// shared config module (src/shared/config.mjs) resolves the plugin-data dir at
+// IMPORT time via resolvePluginData() (src/shared/plugin-paths.mjs), which
+// THROWS when both env vars are unset.
+//
+// We CANNOT just seed CLAUDE_PLUGIN_ROOT and let the shared resolver derive the
+// data dir: plugin-paths.mjs derives from homedir()/.claude and IGNORES
+// CLAUDE_CONFIG_DIR. The daemon and doctor.mjs both key off
+// CLAUDE_CONFIG_DIR || ~/.claude, so on a custom-CLAUDE_CONFIG_DIR install that
+// would point /mixdog:model at ~/.claude/.../mixdog-config.json while the
+// daemon writes $CLAUDE_CONFIG_DIR/.../mixdog-config.json — divergent config.
+//
+// Instead, replicate doctor.mjs's self-contained resolvePluginData (which
+// RESPECTS CLAUDE_CONFIG_DIR) and seed CLAUDE_PLUGIN_DATA directly, so the
+// shared resolvePluginData() short-circuits on it and returns the SAME dir the
+// daemon uses. Keep the CLAUDE_PLUGIN_ROOT seed too (harmless; helps any other
+// code that reads it). This keeps both config reads (readSection) and writes
+// (updateSection RMW) targeting the daemon's config file in the slash context.
+if (!process.env.CLAUDE_PLUGIN_ROOT) process.env.CLAUDE_PLUGIN_ROOT = PLUGIN_ROOT;
+function resolveActivePluginData() {
+  try {
+    const activePath = join(process.env.MIXDOG_RUNTIME_ROOT ? process.env.MIXDOG_RUNTIME_ROOT : join(tmpdir(), 'mixdog'), 'active-instance.json');
+    const active = JSON.parse(readFileSync(activePath, 'utf8'));
+    const pgData = typeof active?.pg_pgdata === 'string' ? active.pg_pgdata : '';
+    if (!pgData) return null;
+    const dataDir = dirname(pgData);
+    if (existsSync(join(dataDir, 'mixdog-config.json'))) return dataDir;
+  } catch { /* fall through */ }
+  return null;
+}
+if (!process.env.CLAUDE_PLUGIN_DATA) {
+  // Exact mirror of doctor.mjs resolvePluginData() (scripts/doctor.mjs:32-49):
+  // base = CLAUDE_CONFIG_DIR || ~/.claude, then plugins/data/<plugin>-<marketplace>.
+  const claudeConfigBase = () => process.env.CLAUDE_CONFIG_DIR || join(homedir(), '.claude');
+  const dirName = basename(PLUGIN_ROOT);
+  let dataDir = resolveActivePluginData();
+  if (dataDir) {
+    // Source-tree dev commands should operate on the live daemon's data dir,
+    // not on a guessed mixdog-mixdog path.
+  } else if (/^\d+\.\d+\.\d+/.test(dirName)) {
+    // Cache layout: .../cache/{marketplace}/{plugin}/{version}/
+    const pluginName = basename(join(PLUGIN_ROOT, '..'));
+    const marketplace = basename(join(PLUGIN_ROOT, '..', '..'));
+    dataDir = join(claudeConfigBase(), 'plugins', 'data', `${pluginName}-${marketplace}`);
+  } else {
+    // Marketplace layout: PLUGIN_ROOT itself is the marketplace dir.
+    const marketplace = dirName;
+    let pluginName = 'mixdog';
+    try {
+      const manifest = JSON.parse(readFileSync(join(PLUGIN_ROOT, '.claude-plugin', 'plugin.json'), 'utf8'));
+      if (typeof manifest?.name === 'string' && manifest.name.trim()) pluginName = manifest.name.trim();
+    } catch { /* fall through to default */ }
+    dataDir = join(claudeConfigBase(), 'plugins', 'data', `${pluginName}-${marketplace}`);
+  }
+  process.env.CLAUDE_PLUGIN_DATA = dataDir;
+}
+
+const { readSection, updateSection } = await import(
+  pathToFileURL(`${PLUGIN_ROOT}/src/shared/config.mjs`).href
+);
+const { loadConfig } = await import(
+  pathToFileURL(`${PLUGIN_ROOT}/src/agent/orchestrator/config.mjs`).href
+);
+
+// ── Running-state detection ──────────────────────────────────────────
+// The gateway advertises gateway_port + gateway_server_pid into the shared
+// active-instance.json (see advertiseGatewayPort in src/gateway/server.mjs),
+// under RUNTIME_ROOT. The gateway is "running" iff a port is advertised AND
+// the advertising pid is alive. Mirrors RUNTIME_ROOT + isPidAlive there.
+const RUNTIME_ROOT = process.env.MIXDOG_RUNTIME_ROOT
+  ? process.env.MIXDOG_RUNTIME_ROOT
+  : join(tmpdir(), 'mixdog');
+const ACTIVE_INSTANCE_FILE = join(RUNTIME_ROOT, 'active-instance.json');
+
+function isPidAlive(pid) {
+  const n = Number(pid);
+  if (!Number.isFinite(n) || n <= 0) return false;
+  try { process.kill(n, 0); return true; }
+  catch (err) { return err && err.code === 'EPERM'; }
+}
+
+function isGatewayRunning() {
+  let active = {};
+  try { active = JSON.parse(readFileSync(ACTIVE_INSTANCE_FILE, 'utf8')); }
+  catch { return { running: false, port: null, pid: null }; }
+  const port = Number(active && active.gateway_port);
+  const pid = Number(active && active.gateway_server_pid);
+  const running = Number.isFinite(port) && port > 0 && isPidAlive(pid);
+  return { running, port: running ? port : null, pid: running ? pid : null };
+}
+
+const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+
+function canConnectPort(port, timeoutMs = 400) {
+  const n = Number(port);
+  if (!Number.isFinite(n) || n <= 0) return Promise.resolve(false);
+  return new Promise((resolve) => {
+    const socket = net.createConnection({ host: '127.0.0.1', port: n });
+    let settled = false;
+    const done = (ok) => {
+      if (settled) return;
+      settled = true;
+      try { socket.destroy(); } catch {}
+      resolve(!!ok);
+    };
+    socket.setTimeout(timeoutMs, () => done(false));
+    socket.once('connect', () => done(true));
+    socket.once('error', () => done(false));
+  });
+}
+
+async function pingGatewayModels(port, timeoutMs = 800) {
+  const n = Number(port);
+  if (!Number.isFinite(n) || n <= 0) return false;
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(), timeoutMs);
+  try {
+    const res = await fetch(`http://127.0.0.1:${n}/v1/models`, { signal: ctrl.signal });
+    return !!res && res.ok;
+  } catch {
+    return false;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+async function waitForGatewayReady(expectedPort, timeoutMs = 12000) {
+  const deadline = Date.now() + timeoutMs;
+  const expected = Number(expectedPort);
+  while (Date.now() < deadline) {
+    const gw = isGatewayRunning();
+    if (gw.running && Number(gw.port) === expected) {
+      const ready = await pingGatewayModels(gw.port);
+      if (ready) return { ...gw, ready: true };
+    }
+    await sleep(250);
+  }
+  const gw = isGatewayRunning();
+  const ready = gw.running && Number(gw.port) === expected && await pingGatewayModels(gw.port);
+  return { ...gw, ready: !!ready };
+}
+
+async function waitForGatewayStopped(expectedPort, timeoutMs = 8000) {
+  const deadline = Date.now() + timeoutMs;
+  const expected = Number(expectedPort);
+  while (Date.now() < deadline) {
+    const gw = isGatewayRunning();
+    const portOpen = await canConnectPort(expected);
+    if (!gw.running && !portOpen) {
+      return { stopped: true, running: false, port: expected, pid: null, portOpen: false };
+    }
+    await sleep(250);
+  }
+  const gw = isGatewayRunning();
+  const portOpen = await canConnectPort(expected);
+  return { stopped: !gw.running && !portOpen, ...gw, port: gw.port || expected, portOpen };
+}
+
+function signalGatewayPid(pid, force = false) {
+  const n = Number(pid);
+  if (!Number.isFinite(n) || n <= 0) return false;
+  try {
+    if (force && process.platform === 'win32') {
+      execFileSync('taskkill', ['/PID', String(n), '/T', '/F'], { stdio: 'ignore', windowsHide: true, timeout: 3000 });
+    } else {
+      process.kill(n, force ? 'SIGKILL' : 'SIGTERM');
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function forceStopGatewayUntilClosed(expectedPort, timeoutMs = 8000) {
+  const expected = Number(expectedPort);
+  const deadline = Date.now() + timeoutMs;
+  const phases = new Map();
+  const attemptedPids = [];
+  while (Date.now() < deadline) {
+    const gw = isGatewayRunning();
+    const portOpen = await canConnectPort(expected);
+    if (!gw.running && !portOpen) {
+      return { stopped: true, running: false, port: expected, pid: null, portOpen: false, forceStopAttempted: attemptedPids.length > 0, forceStopPids: attemptedPids };
+    }
+    if (gw.pid) {
+      const phase = phases.get(gw.pid) || 0;
+      if (phase === 0) {
+        if (signalGatewayPid(gw.pid, false)) attemptedPids.push(gw.pid);
+        phases.set(gw.pid, 1);
+      } else if (phase === 1 && Date.now() + 1000 < deadline) {
+        signalGatewayPid(gw.pid, true);
+        phases.set(gw.pid, 2);
+      }
+    }
+    await sleep(500);
+  }
+  const gw = isGatewayRunning();
+  const portOpen = await canConnectPort(expected);
+  return { stopped: !gw.running && !portOpen, ...gw, port: gw.port || expected, portOpen, forceStopAttempted: attemptedPids.length > 0, forceStopPids: attemptedPids };
+}
+
+// ── Gateway port resolution ──────────────────────────────────────────
+// Mirrors readGatewayConfig() in src/gateway/server.mjs: env pin →
+// gateway.port → DEFAULT_GATEWAY_PORT (3468). Used to build the
+// ANTHROPIC_BASE_URL written into Claude Code settings.json on --enable.
+const DEFAULT_GATEWAY_PORT = 3468;
+function resolveGatewayPort() {
+  const envPort = Number(process.env.MIXDOG_GATEWAY_PORT);
+  if (Number.isFinite(envPort) && envPort > 0) return envPort;
+  let section = {};
+  try { section = readSection('gateway') || {}; } catch { section = {}; }
+  const cfgPort = Number(section.port);
+  if (Number.isFinite(cfgPort) && cfgPort > 0) return cfgPort;
+  return DEFAULT_GATEWAY_PORT;
+}
+
+// settings.json env read-merge-write lives in ./lib/gateway-settings.mjs
+// (resolveSettingsPath / setAnthropicBaseUrl) — the SAME helper uninstall.mjs
+// uses, so --enable / --disable / uninstall share one code path.
+
+// ── Inventory: enabled providers + their candidate models ────────────
+// Delegates to the shared lib (./lib/gateway-inventory.mjs) — loadConfig()
+// overlays keychain keys + marks providers enabled; the lib surfaces, per
+// enabled provider, the preset models plus its own configured `model`.
+function buildInventory() {
+  return buildInventoryFromConfig(loadConfig());
+}
+
+function readCurrentTarget() {
+  let section = {};
+  try { section = readSection('gateway') || {}; } catch { section = {}; }
+  let modules = {};
+  try { modules = readSection('modules') || {}; } catch { modules = {}; }
+  const enabled = !!(modules && typeof modules === 'object' && modules.gateway && modules.gateway.enabled === true);
+  return {
+    mode: typeof section.mode === 'string' ? section.mode : null,
+    provider: typeof section.defaultProvider === 'string' ? section.defaultProvider : null,
+    model: typeof section.defaultModel === 'string' ? section.defaultModel : null,
+    enabled,
+  };
+}
+
+// ── Write path: shared lib (updateSection RMW under lock) ─────────────
+// Delegates to writeGatewayTarget so the CLI --set/--enable and the
+// gateway_select_model elicitation tool persist through one code path.
+function setTarget(provider, model, meta = {}) {
+  writeGatewayTarget(updateSection, provider, model, meta);
+}
+
+// modules.gateway.enabled toggle — preserve sibling module toggles.
+function setModuleEnabled(enabled) {
+  updateSection('modules', (current) => {
+    const cur = current && typeof current === 'object' ? current : {};
+    return { ...cur, gateway: { ...(cur.gateway || {}), enabled: !!enabled } };
+  });
+}
+
+function resolveModelForProvider(inventory, provider, explicitModel) {
+  if (provider === CLAUDE_CURRENT_CHOICE_ID || provider === CLAUDE_CURRENT_MODE) {
+    return resolveTargetChoice(inventory, provider, explicitModel || null, false).model;
+  }
+  if (explicitModel) return explicitModel;
+  const entry = inventory.find((e) => e.provider === provider);
+  return entry && entry.models.length ? entry.models[0] : null;
+}
+
+function resolveTargetForProvider(inventory, provider, explicitModel) {
+  if (provider === CLAUDE_CURRENT_CHOICE_ID || provider === CLAUDE_CURRENT_MODE) {
+    const meta = resolveTargetChoice(inventory, provider, explicitModel || null, false);
+    return { model: meta.model, meta };
+  }
+  const model = resolveModelForProvider(inventory, provider, explicitModel);
+  const meta = resolveTargetChoice(inventory, provider, model, !!explicitModel);
+  return { model, meta };
+}
+
+function isClaudeCurrentProvider(provider) {
+  return provider === CLAUDE_CURRENT_CHOICE_ID || provider === CLAUDE_CURRENT_MODE;
+}
+
+function targetDisplay(provider, model, meta = {}) {
+  if (meta?.mode === CLAUDE_CURRENT_MODE || isClaudeCurrentProvider(provider)) {
+    const label = meta?.modelDisplay || model || 'current model';
+    const suffix = [
+      meta?.effort ? String(meta.effort).toUpperCase() : '',
+      meta?.fast === true ? 'fast' : '',
+    ].filter(Boolean).join(' · ');
+    return `Claude Code current (${label}${suffix ? ` · ${suffix}` : ''})`;
+  }
+  return `${provider} / ${model}${meta?.effort ? ` · ${String(meta.effort).toUpperCase()}` : ''}${meta?.fast ? ' · fast' : ''}`;
+}
+
+// ── CLI ──────────────────────────────────────────────────────────────
+const argv = process.argv.slice(2);
+const asJson = argv.includes('--json');
+// Positional aliases backing the slash command's quick toggle:
+//   `on`  == --enable, reusing the already-configured routing target when no
+//            provider is given (or `on <provider> [model]` to also re-point).
+//   `off` == --disable.
+const positional = argv.find((a) => !a.startsWith('--'));
+const wantOn = positional === 'on';
+const wantOff = positional === 'off';
+const setIdx = argv.indexOf('--set');
+const enableIdx = argv.indexOf('--enable');
+const wantDisable = argv.includes('--disable') || wantOff;
+
+// ── --enable / `on`: config write (routing + module on) + settings.json env ─
+// Only --enable / --disable (and their `on`/`off` aliases) touch settings.json.
+if (enableIdx !== -1 || wantOn) {
+  let provider = null;
+  let explicitModel = null;
+  if (enableIdx !== -1) {
+    const nextArg = argv[enableIdx + 1];
+    provider = nextArg && !nextArg.startsWith('--') ? nextArg : null;
+    const maybeModel = argv[enableIdx + 2];
+    explicitModel = maybeModel && !maybeModel.startsWith('--') ? maybeModel : null;
+  } else {
+    // `on [provider] [model]` — args after the `on` token; when omitted, fall
+    // back to the currently configured target so a bare `on` just re-enables it.
+    const onIdx = argv.indexOf('on');
+    const a1 = argv[onIdx + 1];
+    provider = a1 && !a1.startsWith('--') ? a1 : null;
+    const a2 = argv[onIdx + 2];
+    explicitModel = a2 && !a2.startsWith('--') ? a2 : null;
+    if (!provider) {
+      const cur = readCurrentTarget();
+      provider = cur.mode === CLAUDE_CURRENT_MODE ? CLAUDE_CURRENT_CHOICE_ID : cur.provider;
+      explicitModel = cur.model;
+    }
+  }
+  if (!provider) {
+    console.error('error: no provider to enable. Pass one (`on <provider> [model]` / `--enable <provider> [model]`) or set a target first with --set.');
+    process.exit(1);
+  }
+  const inventory = buildInventory();
+  const known = inventory.find((e) => e.provider === provider);
+  if (!known && !isClaudeCurrentProvider(provider)) {
+    const names = inventory.map((e) => e.provider).join(', ') || '(none enabled)';
+    console.error(`error: provider "${provider}" is not enabled in the agent config. Enabled: ${names}`);
+    process.exit(1);
+  }
+  const { model, meta } = resolveTargetForProvider(inventory, provider, explicitModel);
+  if (!model) {
+    console.error(`error: no model resolved for "${provider}" — pass one explicitly: --enable ${provider} <model>`);
+    process.exit(1);
+  }
+  // 1) config: routing + modules.gateway.enabled=true (same path as --set).
+  setTarget(provider, model, meta);
+  // 2) live daemon: wait for server-main's config watcher to start the child
+  // and for the HTTP endpoint to answer before pointing Claude Code at it.
+  const port = resolveGatewayPort();
+  const url = `http://127.0.0.1:${port}`;
+  const ready = await waitForGatewayReady(port);
+  if (!ready.ready) {
+    if (asJson) {
+      console.log(JSON.stringify({
+        ok: false,
+        provider,
+        model,
+        effort: meta?.effort || undefined,
+        fast: meta?.fast === true || undefined,
+        enabled: true,
+        baseUrl: url,
+        gatewayReady: false,
+        gatewayRunning: ready.running,
+        gatewayPort: ready.port,
+        gatewayPid: ready.pid,
+        error: `gateway did not become ready on ${url}`,
+      }));
+    } else {
+      console.error(`Gateway config saved (${provider} / ${model}), but the gateway did not become ready on ${url}.`);
+      console.error('settings.json was NOT changed, so Claude Code will not be pointed at a dead gateway.');
+      console.error('Run /mixdog:model off to restore the module flag, or restart Claude Code and try /mixdog:model on again.');
+    }
+    process.exit(1);
+  }
+  // 3) settings.json: point Claude Code's main model at the ready gateway.
+  const sres = setAnthropicBaseUrl(url);
+  if (!sres.ok) {
+    // Config is already written; surface the settings.json failure clearly so
+    // the user can fix it (e.g. missing ~/.claude/settings.json) and re-run.
+    if (asJson) console.log(JSON.stringify({ ok: false, provider, model, effort: meta?.effort || undefined, fast: meta?.fast === true || undefined, baseUrl: url, gatewayReady: true, gatewayPort: ready.port, gatewayPid: ready.pid, error: sres.error }));
+    else {
+      console.error(`Gateway config saved (${provider} / ${model}), but settings.json update FAILED: ${sres.error}`);
+      console.error(`Add this manually to ${resolveSettingsPath()} under "env": "ANTHROPIC_BASE_URL": "${url}"`);
+    }
+    process.exit(1);
+  }
+  if (asJson) {
+    console.log(JSON.stringify({ ok: true, provider, model, effort: meta?.effort || undefined, fast: meta?.fast === true || undefined, enabled: true, baseUrl: url, gatewayReady: true, gatewayRunning: true, gatewayPort: ready.port, gatewayPid: ready.pid, settingsPath: sres.path, settingsChanged: sres.changed }));
+  } else {
+    console.log(`Gateway ENABLED: ${targetDisplay(provider, model, meta)}`);
+    console.log(`Gateway is running and ready on ${url} (pid ${ready.pid || 'unknown'}).`);
+    console.log(`settings.json env.ANTHROPIC_BASE_URL = ${url}  (${sres.path})`);
+    console.log('');
+    console.log('⚠ This routes the ENTIRE main Claude Code model through the mixdog gateway');
+    console.log(`  to ${provider}/${model}. mixdog\'s own Anthropic subagents stay on`);
+    console.log('  api.anthropic.com (hardcoded), so they are unaffected.');
+    console.log('RESTART Claude Code for ANTHROPIC_BASE_URL to take effect if this process has not already loaded it.');
+    console.log('Run /mixdog:model --disable (or this script --disable) to restore settings.json.');
+  }
+  process.exit(0);
+}
+
+// ── --disable: remove settings.json env entry (restore) + module off ─────
+if (wantDisable) {
+  const port = resolveGatewayPort();
+  const sres = setAnthropicBaseUrl(null);
+  // Also flip the module off so a restart doesn't re-spawn the gateway.
+  let moduleErr = null;
+  try { setModuleEnabled(false); } catch (e) { moduleErr = e?.message || String(e); }
+  let stopped = moduleErr ? { stopped: false, running: null, port, pid: null, portOpen: null } : await waitForGatewayStopped(port);
+  if (!moduleErr && !stopped.stopped) {
+    stopped = await forceStopGatewayUntilClosed(port);
+  }
+  if (!sres.ok) {
+    if (asJson) console.log(JSON.stringify({ ok: false, error: sres.error, moduleDisabled: !moduleErr, gatewayStopped: stopped.stopped, gatewayPort: stopped.port }));
+    else console.error(`settings.json restore FAILED: ${sres.error}`);
+    process.exit(1);
+  }
+  const ok = !moduleErr && stopped.stopped;
+  if (asJson) {
+    console.log(JSON.stringify({
+      ok,
+      enabled: false,
+      settingsPath: sres.path,
+      settingsChanged: sres.changed,
+      moduleDisabled: !moduleErr,
+      moduleError: moduleErr,
+      gatewayStopped: stopped.stopped,
+      gatewayRunning: stopped.running,
+      gatewayPort: stopped.port,
+      gatewayPid: stopped.pid,
+      gatewayPortOpen: stopped.portOpen,
+      gatewayForceStopAttempted: stopped.forceStopAttempted === true,
+      gatewayForceStopPids: stopped.forceStopPids || [],
+    }));
+  } else {
+    console.log(ok ? 'Gateway DISABLED.' : 'Gateway disable requested.');
+    console.log(sres.changed
+      ? `Removed env.ANTHROPIC_BASE_URL from ${sres.path} — Claude Code reverts to api.anthropic.com.`
+      : `No env.ANTHROPIC_BASE_URL was set in ${sres.path} — nothing to remove.`);
+    console.log('modules.gateway.enabled = false' + (moduleErr ? ` (config write failed: ${moduleErr})` : ''));
+    if (stopped.stopped) {
+      console.log(`Gateway process stopped and port ${stopped.port} is closed.`);
+      if (stopped.forceStopAttempted) console.log(`Gateway child stop fallback used for pid(s): ${(stopped.forceStopPids || []).join(', ')}`);
+    } else {
+      console.log(`WARNING: gateway did not fully stop within the wait window (running=${stopped.running}, portOpen=${stopped.portOpen}).`);
+    }
+    console.log('RESTART Claude Code for the settings change to take effect if this process has already loaded ANTHROPIC_BASE_URL.');
+  }
+  process.exit(ok ? 0 : 1);
+}
+
+if (setIdx !== -1) {
+  const provider = argv[setIdx + 1];
+  const explicitModel = argv[setIdx + 2] && !argv[setIdx + 2].startsWith('--') ? argv[setIdx + 2] : null;
+  if (!provider) {
+    console.error('error: --set requires a <provider> argument');
+    process.exit(1);
+  }
+  const inventory = buildInventory();
+  const known = inventory.find((e) => e.provider === provider);
+  if (!known && !isClaudeCurrentProvider(provider)) {
+    const names = inventory.map((e) => e.provider).join(', ') || '(none enabled)';
+    console.error(`error: provider "${provider}" is not enabled in the agent config. Enabled: ${names}`);
+    process.exit(1);
+  }
+  const { model, meta } = resolveTargetForProvider(inventory, provider, explicitModel);
+  if (!model) {
+    console.error(`error: no model resolved for "${provider}" — pass one explicitly: --set ${provider} <model>`);
+    process.exit(1);
+  }
+  setTarget(provider, model, meta);
+  // Detect whether a gateway child is actually running RIGHT NOW. server-main
+  // watches modules.gateway.enabled, so a stopped gateway should live-start
+  // shortly after this write when the daemon is active.
+  const port = resolveGatewayPort();
+  const gw = await waitForGatewayReady(port, 4000);
+  const result = { ok: true, provider, model, effort: meta?.effort || undefined, fast: meta?.fast === true || undefined, enabled: true, gatewayReady: gw.ready, gatewayRunning: gw.running, gatewayPort: gw.port, gatewayPid: gw.pid };
+  if (asJson) {
+    console.log(JSON.stringify(result));
+  } else {
+    console.log(`Gateway routing set: ${targetDisplay(provider, model, meta)}`);
+    console.log('modules.gateway.enabled = true');
+    if (gw.ready) {
+      console.log(`Gateway is ready (port ${gw.port}) — live on the NEXT request, no gateway restart needed.`);
+    } else {
+      console.log('NOTE: config is saved, but the gateway did not report ready within the short wait window.');
+      console.log('If the daemon is running, it should keep reconciling this setting; rerun /mixdog:model to check.');
+    }
+  }
+  process.exit(0);
+}
+
+// Default action: list.
+const inventory = buildInventory();
+const current = readCurrentTarget();
+const gw = isGatewayRunning();
+
+if (asJson) {
+  console.log(JSON.stringify({ current, providers: inventory, gatewayRunning: gw.running, gatewayPort: gw.port }));
+  process.exit(0);
+}
+
+console.log('== mixdog gateway model ==');
+console.log(
+  `Current target: ${current.mode === CLAUDE_CURRENT_MODE
+    ? `Claude Code current (${current.model || 'current model'})`
+    : current.provider ? `${current.provider} / ${current.model || '(no model)'}` : '(unset)'}` +
+  ` | module ${current.enabled ? 'ENABLED' : 'disabled'}` +
+  ` | gateway ${gw.running ? `RUNNING (port ${gw.port})` : 'not running'}`
+);
+console.log('');
+if (inventory.length === 0) {
+  console.log('No enabled agent providers found. Enable a provider in /mixdog:config first.');
+} else {
+  const choices = inventoryChoices(inventory);
+  const currentChoice = choices.find(c => c.id === CLAUDE_CURRENT_CHOICE_ID);
+  if (currentChoice) {
+    console.log(`Default: ${currentChoice.label}`);
+    console.log('');
+  }
+  console.log('Available providers (enabled) and candidate models:');
+  for (const e of inventory) {
+    const models = e.models.length ? e.models.join(', ') : '(no preset/model — pass one explicitly)';
+    console.log(`  • ${e.provider}: ${models}`);
+  }
+}
+console.log('');
+console.log('Switch routing:  bun scripts/gateway-model.mjs --set <provider> [model]');
+console.log('Enable gateway:  bun scripts/gateway-model.mjs --enable <provider> [model]   (live-starts + writes settings.json)');
+console.log('Disable gateway: bun scripts/gateway-model.mjs --disable                     (live-stops + restores settings.json)');
+console.log('Quick toggle:    bun scripts/gateway-model.mjs on [provider] [model]  |  off   (aliases of --enable/--disable)');
+process.exit(0);