Claude Code. Any Model. The most powerful AI coding agent now speaks every language.
fix(cli): make --default-provider reach the proxy and child sessions
Jack Rudenko9be012fc6e2d
diff --git a/packages/cli/src/cli.ts b/packages/cli/src/cli.tsindex 1df129d3..45662be5 100644--- a/packages/cli/src/cli.ts+++ b/packages/cli/src/cli.ts@@ -426,13 +426,14 @@ export async function parseArgs(args: string[]): Promise<ClaudishConfig> {process.exit(1);}config.profile = profileArg;- } else if (arg === "--default-provider") {- const dpArg = args[++i];- if (!dpArg) {- console.error("--default-provider requires a provider name");- process.exit(1);+ } else if (arg === "--default-provider" || arg.startsWith("--default-provider=")) {+ // index.ts strips this flag and exports it as CLAUDISH_DEFAULT_PROVIDER+ // before parseArgs runs (applyDefaultProviderFlag), so this branch fires only+ // for a caller that skipped that step. It consumes the flag and its value so+ // neither leaks to Claude Code as a passthrough arg.+ if (arg === "--default-provider" && i + 1 < args.length && !args[i + 1].startsWith("-")) {+ i++;}- config.defaultProvider = dpArg;} else if (arg === "--anthropic-api-billing") {config.anthropicApiBilling = true;} else if (arg === "--classifier-model") {@@ -852,17 +853,12 @@ export async function parseArgs(args: string[]): Promise<ClaudishConfig> {}}- // Phase 1 (LiteLLM-demotion refactor): resolve the effective default provider- // and emit a one-shot stderr hint when legacy LITELLM auto-promotion kicks in.- // This currently has no routing effect — Phase 2 wires it into auto-route.+ // Phase 1 (LiteLLM-demotion refactor): emit a one-shot stderr hint when legacy+ // LITELLM auto-promotion kicks in. Routing does not read this: it resolves the+ // default provider itself, and `--default-provider` reaches it through the env+ // variable index.ts exports.try {- const fileConfigForResolver = loadConfig();- const resolved = resolveDefaultProvider({- cliFlag: config.defaultProvider,- config: fileConfigForResolver,- env: process.env,- });- config.resolvedDefaultProvider = resolved;+ const resolved = resolveDefaultProvider({ config: loadConfig(), env: process.env });if (resolved.legacyAutoPromoted && !config.quiet) {const markerFile = join(homedir(), ".claudish", ".legacy-litellm-hint-shown");diff --git a/packages/cli/src/default-provider.test.ts b/packages/cli/src/default-provider.test.tsindex a3ccb8a4..6f44b739 100644--- a/packages/cli/src/default-provider.test.ts+++ b/packages/cli/src/default-provider.test.ts@@ -1,7 +1,17 @@import { describe, expect, test } from "bun:test";+import { copyFileSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";+import { tmpdir } from "node:os";+import { join } from "node:path";import { resolveDefaultProvider } from "./default-provider.js";import type { ClaudishProfileConfig } from "./profile-config.js";+const STAGE4_CATALOG_FIXTURE = join(+ import.meta.dir,+ "test-fixtures",+ "stage4-default-provider-catalog.json"+);+const CLI_ENTRY = join(import.meta.dir, "index.ts");+function makeConfig(overrides: Partial<ClaudishProfileConfig> = {}): ClaudishProfileConfig {return {version: "1.0.0",@@ -43,6 +53,44 @@ describe("resolveDefaultProvider precedence", () => {expect(result.legacyAutoPromoted).toBe(false);});+ test("an empty env var disables the fallback and keeps the env-var source", () => {+ expect(+ resolveDefaultProvider({+ config: makeConfig(),+ env: { CLAUDISH_DEFAULT_PROVIDER: "" },+ })+ ).toEqual({ provider: "", source: "env-var", legacyAutoPromoted: false });+ });++ test("an empty config value disables the fallback and keeps the config-file source", () => {+ expect(+ resolveDefaultProvider({ config: makeConfig({ defaultProvider: "" }), env: {} })+ ).toEqual({+ provider: "",+ source: "config-file",+ legacyAutoPromoted: false,+ });+ });++ test("an empty env var beats a non-empty config value", () => {+ expect(+ resolveDefaultProvider({+ config: makeConfig({ defaultProvider: "from-config" }),+ env: { CLAUDISH_DEFAULT_PROVIDER: "" },+ })+ ).toEqual({ provider: "", source: "env-var", legacyAutoPromoted: false });+ });++ test("a non-empty CLI flag beats an empty env var", () => {+ expect(+ resolveDefaultProvider({+ cliFlag: "from-flag",+ config: makeConfig({ defaultProvider: "from-config" }),+ env: { CLAUDISH_DEFAULT_PROVIDER: "" },+ })+ ).toEqual({ provider: "from-flag", source: "cli-flag", legacyAutoPromoted: false });+ });+test("config wins over legacy", () => {const env: NodeJS.ProcessEnv = {LITELLM_BASE_URL: "http://litellm.local",@@ -125,8 +173,64 @@ describe("resolveDefaultProvider precedence", () => {});});-describe("buildLegacyHint (commit 5: now a no-op)", () => {- // Pre-commit-5, this returned a stderr hint when legacyAutoPromoted=true.- // Since LiteLLM auto-promotion was removed, the function always returns- // null — kept for backwards-compat with existing callers.+interface ProbeJson {+ chain: Array<{ provider: string }>;+}++function sandboxedProbe(flagBeforeProbe: boolean, provider: string): ProbeJson {+ const home = mkdtempSync(join(tmpdir(), "claudish-default-provider-probe-"));+ const configDir = join(home, ".claudish");+ mkdirSync(configDir, { recursive: true });+ copyFileSync(STAGE4_CATALOG_FIXTURE, join(configDir, "cloud-models-catalog-v3.json"));+ writeFileSync(+ join(configDir, "config.json"),+ JSON.stringify({ version: "1.0.0", defaultProfile: "default", profiles: {} }),+ "utf8"+ );++ const flag = ["--default-provider", provider];+ const probe = ["--probe", "no-such-model-xyz"];+ const args = flagBeforeProbe+ ? [CLI_ENTRY, ...flag, ...probe, "--json", "--no-probe"]+ : [CLI_ENTRY, ...probe, ...flag, "--json", "--no-probe"];+ const env: Record<string, string> = {+ HOME: home,+ PATH: process.env.PATH ?? "",+ TMPDIR: process.env.TMPDIR ?? tmpdir(),+ CLAUDISH_DISABLE_CATALOG_WARM: "1",+ CLAUDISH_DISABLE_KEYCHAIN: "1",+ CLAUDISH_DISABLE_OP: "1",+ CLAUDISH_SKIP_LIVE_E2E: "1",+ };++ try {+ const result = Bun.spawnSync([process.execPath, ...args], {+ cwd: join(import.meta.dir, "../../.."),+ env,+ stdout: "pipe",+ stderr: "pipe",+ });+ const stdout = result.stdout.toString();+ const stderr = result.stderr.toString();+ expect(result.exitCode, stderr || stdout).toBe(0);+ const parsed = JSON.parse(stdout) as ProbeJson[];+ expect(parsed).toHaveLength(1);+ return parsed[0];+ } finally {+ rmSync(home, { recursive: true, force: true });+ }+}++describe("--default-provider pre-scan reaches --probe", () => {+ test("uses poe when the flag appears before --probe", () => {+ expect(sandboxedProbe(true, "poe").chain.map((entry) => entry.provider)).toEqual(["poe"]);+ });++ test("uses poe when the flag appears after the probed model", () => {+ expect(sandboxedProbe(false, "poe").chain.map((entry) => entry.provider)).toEqual(["poe"]);+ });++ test("an empty flag value produces an empty chain", () => {+ expect(sandboxedProbe(true, "").chain).toEqual([]);+ });});diff --git a/packages/cli/src/default-provider.ts b/packages/cli/src/default-provider.tsindex ab0d32ed..6b2d6a7a 100644--- a/packages/cli/src/default-provider.ts+++ b/packages/cli/src/default-provider.ts@@ -4,6 +4,7 @@** No imports from cli.ts or proxy-server.ts (otherwise we get import cycles).* Reads from a passed-in config object, env vars, and an optional CLI flag.+ * Also `planDefaultProviderFlag`, the argv scan index.ts applies before parseArgs.** LiteLLM auto-promotion was removed in commit 5 of the model-catalog and* routing redesign. Users who relied on `LITELLM_BASE_URL` + `LITELLM_API_KEY`@@ -54,7 +55,9 @@ export interface ResolveOptions {* So an env `""` beats a config `x`, and a flag `x` beats an env `""`.** An empty `cliFlag` is different: it means the caller parsed no flag, and it- * falls through.+ * falls through. The CLI no longer passes the flag here: index.ts exports it to+ * CLAUDISH_DEFAULT_PROVIDER (`planDefaultProviderFlag`), which is also how an+ * explicit `--default-provider ""` arrives.*/export function resolveDefaultProvider(opts: ResolveOptions): ResolvedDefaultProvider {const env = opts.env ?? process.env;@@ -82,6 +85,67 @@ export function resolveDefaultProvider(opts: ResolveOptions): ResolvedDefaultProreturn { provider: "openrouter", source: "hardcoded", legacyAutoPromoted: false };}+/**+ * What a `--default-provider` scan of argv decided. A plan rather than an effect,+ * like `planConfigOverride`: index.ts applies it (strips argv, exports the value).+ */+export type DefaultProviderFlagPlan =+ | { kind: "none" }+ | { kind: "error"; message: string }+ | {+ kind: "apply";+ /** The flag's value. `""` is kept: it disables the fallback hop. */+ value: string;+ /** argv with every occurrence of the flag and its value removed. */+ argv: string[];+ };++const DEFAULT_PROVIDER_FLAG = "--default-provider";++/**+ * Find `--default-provider <name>` (or `--default-provider=<name>`) in argv, before+ * `parseArgs` sees it.+ *+ * Why before: `--probe` runs and exits INSIDE `parseArgs`'s argv loop, so a flag+ * read there, or after it, never reached `--probe` in either argv order. Scanning+ * first gives every path the same answer.+ *+ * - Every occurrence is removed; the last one wins, as `parseArgs` did.+ * - `""` is a value, not a missing one: `--default-provider ""` disables the fallback.+ * - A missing value, or a following token that is itself a flag, is an error, so a+ * dangling flag never swallows the next option or leaks to Claude Code.+ * - Scanning stops at `--`. What follows it belongs to Claude Code, as in `parseArgs`.+ */+export function planDefaultProviderFlag(argv: string[]): DefaultProviderFlagPlan {+ const rest: string[] = [];+ let value: string | undefined;+ for (let i = 0; i < argv.length; i++) {+ const arg = argv[i];+ if (arg === "--") {+ rest.push(...argv.slice(i));+ break;+ }+ if (arg === DEFAULT_PROVIDER_FLAG) {+ const next = argv[i + 1];+ if (next === undefined || next.startsWith("-")) {+ return {+ kind: "error",+ message: `${DEFAULT_PROVIDER_FLAG} requires a provider name ("" for no fallback provider)`,+ };+ }+ value = next;+ i++;+ continue;+ }+ if (arg.startsWith(`${DEFAULT_PROVIDER_FLAG}=`)) {+ value = arg.slice(DEFAULT_PROVIDER_FLAG.length + 1);+ continue;+ }+ rest.push(arg);+ }+ return value === undefined ? { kind: "none" } : { kind: "apply", value, argv: rest };+}+/*** Legacy stub — LiteLLM auto-promotion was removed in commit 5; the hint never* fires anymore. Kept as a no-op for callers that still import it.diff --git a/packages/cli/src/index.ts b/packages/cli/src/index.tsindex 37c6317f..86109d9e 100644--- a/packages/cli/src/index.ts+++ b/packages/cli/src/index.ts@@ -268,9 +268,40 @@ async function applyConfigOverride(): Promise<void> {process.env.CLAUDISH_CONFIG = plan.path;}+// `--default-provider <name>`: strip it from argv and export it as+// CLAUDISH_DEFAULT_PROVIDER before parseArgs and every subcommand dispatch. The env+// variable is the ONE place the flag lives after this: route(), the proxy, `--probe`+// and every child claudish (team, channel sessions) read it through+// `resolveDefaultProvider`. `--probe` is why this cannot wait for parseArgs: it+// runs and exits inside parseArgs's argv loop, so a flag read there or after it+// never reached it, in either argv order.+//+// Runs AFTER the two explicit 1Password flags, which overwrite env+// unconditionally: an --op-env or --op value for CLAUDISH_DEFAULT_PROVIDER must+// not beat the flag the user typed.+async function applyDefaultProviderFlag(): Promise<void> {+ const { planDefaultProviderFlag } = await import("./default-provider.js");+ const plan = planDefaultProviderFlag(process.argv.slice(2));+ if (plan.kind === "none") return;+ if (plan.kind === "error") {+ console.error(`[claudish] ${plan.message}`);+ process.exit(1);+ }++ process.argv = [...process.argv.slice(0, 2), ...plan.argv];+ // An in-process env write reaches children only because they INHERIT process.env:+ // every claudish child today is spawned through node:child_process, with+ // `...process.env` or default inheritance. `Bun.spawn`/`Bun.spawnSync` without an+ // `env` option DROP in-process writes (measured on Bun 1.4.0), so a future spawn+ // written that way silently loses this flag. Pass `env: process.env` there.+ // `""` is exported as-is: it disables the fallback hop.+ process.env.CLAUDISH_DEFAULT_PROVIDER = plan.value;+}+await traceSpan("startup:config-override", () => applyConfigOverride());await traceSpan("startup:op-env-flags", () => applyOpEnvironment());await traceSpan("startup:op-import-flag", () => applyOpImport());+await traceSpan("startup:default-provider-flag", () => applyDefaultProviderFlag());// Check for MCP mode before loading heavy dependenciesconst isMcpMode = process.argv.includes("--mcp");diff --git a/packages/cli/src/providers/routing-rules.ts b/packages/cli/src/providers/routing-rules.tsindex f98b0415..b4c49684 100644--- a/packages/cli/src/providers/routing-rules.ts+++ b/packages/cli/src/providers/routing-rules.ts@@ -387,7 +387,8 @@ export const DEFAULT_FALLBACK_PROVIDER = "openrouter";* fallback hop.** Read per call, like the rules. `route()` without overrides and `--probe`'s- * chain both read it here, so the two cannot name different fallback hops.+ * chain both read it here, so the two cannot name different fallback hops. The+ * `--default-provider` flag arrives through the env variable (index.ts exports it).*/export function effectiveDefaultProvider(): string {return resolveDefaultProvider({ config: loadConfig(), env: process.env }).provider;diff --git a/packages/cli/src/proxy-server.ts b/packages/cli/src/proxy-server.tsindex e054a19c..1c487833 100644--- a/packages/cli/src/proxy-server.ts+++ b/packages/cli/src/proxy-server.ts@@ -583,7 +583,7 @@ export async function createProxyServer(// them. Passing rules alone makes route() read NO default provider (its guard// keeps this machine's setting out of tests), so before this every bare name the// proxy routed fell back to `openrouter`, whatever `defaultProvider` said —- // `""` included.+ // `""` included. `--default-provider` reaches this through the env variable.const effectiveFallbackProvider = effectiveDefaultProvider();// Cache fallback handlers by target model string.diff --git a/packages/cli/src/types.ts b/packages/cli/src/types.tsindex bf07ca62..7151676e 100644--- a/packages/cli/src/types.ts+++ b/packages/cli/src/types.ts@@ -45,8 +45,6 @@ export interface ClaudishConfig {*/skipModelsUpdate?: boolean;profile?: string; // Profile name to use for model mapping- /** --default-provider <name> CLI flag (Phase 1 of LiteLLM-demotion refactor) */- defaultProvider?: string;/*** --anthropic-api-billing: opt IN to using a real ANTHROPIC_API_KEY for native* Claude models, accepting metered API billing. Default (false) hides the key@@ -62,8 +60,6 @@ export interface ClaudishConfig {* stray --op never leaks to Claude Code as a passthrough arg).*/opImport?: string;- /** Resolved default provider (computed via resolveDefaultProvider() after argv parsing) */- resolvedDefaultProvider?: import("./default-provider.js").ResolvedDefaultProvider;claudeArgs: string[];_hasPositionalPrompt?: boolean; // Internal: true when a positional prompt arg was found (not a flag value)_hasPrintFlag?: boolean; // Internal: true when a passthrough -p/--print flag was found (implies single-shot, not interactive)