feat(cli): take a model per backend, from a flag, the env, the config or the wizard
`--model` reaches whichever agent runs, which is the right shape for a single run and the wrong one the moment the editor's picker can switch backends mid-session: one shared id would follow it and hand Codex something only Claude answers to. So `--claude-model`, `--codex-model` and `--opencode-model` sit beside it, each falling back to `--model`, and the collapse happens once in `toServeOptions` rather than in the server — one place decides it, one place the tests cover. Everything else comes free from the flag registry: `AIRSHIP_CLAUDE_MODEL` and `claudeModel` in the config file both work without a line of new code, and `config.test.ts` asserts all three spellings plus the did-you-mean on a typo. Only `--opencode-model` is validated. That flag names its backend, so a bare id can only be a mistake and `requireModelRef` refuses it outright. `--model` cannot be — a bare id is correct for two of the three — so it keeps a launch warning instead, which is what `warnBackendLimits` is for. That warning had stopped working. It was changed to read the resolved per-backend model, which is the right source, but its only caller still passed `model`, so it read `undefined` and could never fire. `banner.test.ts` is new and is why: there was no test for the launch warnings at all, which is how a flag being silently dropped stayed silent. The dead parameter is gone, so the same miswiring is now a compile error. `airship init` asks which model after it asks which agent, because the answer only means anything against one. It probes the real backend rather than offering a list from memory, and takes the opencode knobs now — that probe starts a server, and without `--opencode-path` and friends it booted a default one the project may not use and then reported it unreachable.
This commit is contained in:
@@ -12,7 +12,8 @@ import { join, relative } from "node:path";
|
||||
import { confirm, isCancel } from "@clack/prompts";
|
||||
import { defineCommand } from "citty";
|
||||
import { argsFor, assertKnownFlags, GLOBAL_FLAGS } from "../lib/args";
|
||||
import { asBoolean, CONFIG_FILENAME } from "../lib/config";
|
||||
import { readOpencodeConfig } from "../lib/backends";
|
||||
import { asBoolean, asString, CONFIG_FILENAME } from "../lib/config";
|
||||
import { CliError, EXIT } from "../lib/errors";
|
||||
import { resolveSettings } from "../lib/settings";
|
||||
import {
|
||||
@@ -24,7 +25,23 @@ import {
|
||||
} from "../lib/terminal";
|
||||
import { runWizard } from "../lib/wizard";
|
||||
|
||||
export const INIT_FLAGS: readonly string[] = ["cwd", ...GLOBAL_FLAGS];
|
||||
/*
|
||||
* The opencode knobs are here because `init` probes for models, and probing
|
||||
* opencode *starts a server* — at `--opencode-path`, or against a running one at
|
||||
* `--opencode-url`, with `--opencode-config` applied. Without them the wizard
|
||||
* booted a default server the project may not use and then reported it as
|
||||
* unreachable, with no flag available to say otherwise.
|
||||
*
|
||||
* `--safe` for the same reason: it changes what the probe is allowed to do.
|
||||
*/
|
||||
export const INIT_FLAGS: readonly string[] = [
|
||||
"cwd",
|
||||
"safe",
|
||||
"opencode-path",
|
||||
"opencode-url",
|
||||
"opencode-config",
|
||||
...GLOBAL_FLAGS,
|
||||
];
|
||||
|
||||
export const init = defineCommand({
|
||||
args: argsFor(INIT_FLAGS),
|
||||
@@ -61,7 +78,17 @@ export const init = defineCommand({
|
||||
}
|
||||
}
|
||||
|
||||
const answers = await runWizard(cwd);
|
||||
const answers = await runWizard(cwd, {
|
||||
askModel: true,
|
||||
probe: {
|
||||
opencode: {
|
||||
config: readOpencodeConfig(asString(settings, "opencode-config")),
|
||||
opencodePath: asString(settings, "opencode-path"),
|
||||
url: asString(settings, "opencode-url"),
|
||||
},
|
||||
safe: asBoolean(settings, "safe"),
|
||||
},
|
||||
});
|
||||
// Only the answers worth persisting. `safe: false` is the default, so
|
||||
// writing it would state a posture the user did not actually choose.
|
||||
const config: Record<string, unknown> = {
|
||||
@@ -72,6 +99,14 @@ export const init = defineCommand({
|
||||
if (answers.safe) {
|
||||
config.safe = true;
|
||||
}
|
||||
// Keyed to the backend it was chosen for, never the bare `model`. The
|
||||
// overlay's picker can move to another harness mid-session, and a flat
|
||||
// `model` would follow it there and hand Codex an id only Claude answers to.
|
||||
// Same rule as `safe` above: absent means "the backend decides", so an
|
||||
// unanswered prompt writes nothing.
|
||||
if (answers.model) {
|
||||
config[`${answers.agent}Model`] = answers.model;
|
||||
}
|
||||
|
||||
writeFileSync(path, `${JSON.stringify(config, null, 2)}\n`);
|
||||
note(
|
||||
|
||||
@@ -0,0 +1,128 @@
|
||||
/**
|
||||
* `toServeOptions` — where merged settings become validated options.
|
||||
*
|
||||
* The function has carried "Exported for the tests" since it was split out of
|
||||
* `main`, and until now there were none: nothing in the repo imported it. That
|
||||
* was survivable while it only read strings across; it stopped being so once it
|
||||
* grew the per-backend model fallback, which is real logic with three inputs
|
||||
* and a precedence order, and which no other layer re-checks.
|
||||
*/
|
||||
|
||||
import { describe, expect, it } from "vitest";
|
||||
import { mergeSettings, type Settings } from "../lib/config";
|
||||
import { CliError } from "../lib/errors";
|
||||
import { toServeOptions } from "./serve";
|
||||
|
||||
const CWD = "/tmp/airship-serve-test";
|
||||
|
||||
/** Settings as the merge chain would hand them over. */
|
||||
function settings(values: Record<string, string | boolean>): Settings {
|
||||
return mergeSettings(values as Settings);
|
||||
}
|
||||
|
||||
function optionsFor(values: Record<string, string | boolean>) {
|
||||
return toServeOptions(settings(values), CWD);
|
||||
}
|
||||
|
||||
/** The message on the CliError a call raises. */
|
||||
function errorFrom(fn: () => unknown): CliError | undefined {
|
||||
try {
|
||||
fn();
|
||||
} catch (err) {
|
||||
if (err instanceof CliError) {
|
||||
return err;
|
||||
}
|
||||
throw err;
|
||||
}
|
||||
}
|
||||
|
||||
describe("toServeOptions — models", () => {
|
||||
it("leaves every backend unset when no model flag is given", () => {
|
||||
const { model, models } = optionsFor({});
|
||||
expect(model).toBeUndefined();
|
||||
// Not `{}`: the keys exist and hold `undefined`, which is what the server
|
||||
// reads as "this backend has no configured default".
|
||||
expect(models.claude).toBeUndefined();
|
||||
expect(models.codex).toBeUndefined();
|
||||
expect(models.opencode).toBeUndefined();
|
||||
});
|
||||
|
||||
it("spreads a bare --model to all three backends", () => {
|
||||
const { models } = optionsFor({ model: "sonnet" });
|
||||
expect(models).toEqual({
|
||||
claude: "sonnet",
|
||||
codex: "sonnet",
|
||||
opencode: "sonnet",
|
||||
});
|
||||
});
|
||||
|
||||
it("lets a per-backend model outrank --model, for that backend only", () => {
|
||||
const { models } = optionsFor({ "claude-model": "opus", model: "sonnet" });
|
||||
expect(models.claude).toBe("opus");
|
||||
// The whole point of the split: switching the picker to Codex must not
|
||||
// carry Claude's id across.
|
||||
expect(models.codex).toBe("sonnet");
|
||||
expect(models.opencode).toBe("sonnet");
|
||||
});
|
||||
|
||||
it("takes all three per-backend models independently", () => {
|
||||
const { models } = optionsFor({
|
||||
"claude-model": "opus",
|
||||
"codex-model": "gpt-5.3-codex",
|
||||
"opencode-model": "anthropic/claude-sonnet-5",
|
||||
});
|
||||
expect(models).toEqual({
|
||||
claude: "opus",
|
||||
codex: "gpt-5.3-codex",
|
||||
opencode: "anthropic/claude-sonnet-5",
|
||||
});
|
||||
});
|
||||
|
||||
it("keeps --model on `model` as well, for the launch banner", () => {
|
||||
// `model` is not superseded by `models` — the banner reads it, and dropping
|
||||
// it would break a surface that has nothing to do with the picker.
|
||||
expect(optionsFor({ model: "sonnet" }).model).toBe("sonnet");
|
||||
expect(optionsFor({ "claude-model": "opus" }).model).toBeUndefined();
|
||||
});
|
||||
|
||||
it("rejects an --opencode-model with no provider", () => {
|
||||
const err = errorFrom(() => optionsFor({ "opencode-model": "sonnet" }));
|
||||
expect(err?.message).toContain("opencode-model");
|
||||
// The hint has to show the shape, not just name it: the fix is invisible
|
||||
// otherwise, since the id itself is perfectly valid for another backend.
|
||||
expect(err?.hint).toContain("anthropic/sonnet");
|
||||
});
|
||||
|
||||
it("accepts an --opencode-model that names its provider", () => {
|
||||
expect(
|
||||
optionsFor({ "opencode-model": "anthropic/x" }).models.opencode
|
||||
).toBe("anthropic/x");
|
||||
});
|
||||
|
||||
it("does not validate a bare --model, which reaches all three", () => {
|
||||
// A bare id is correct for two of the three backends, so this cannot be an
|
||||
// error. `banner.ts` warns at launch instead, once the agent is known.
|
||||
expect(optionsFor({ model: "sonnet" }).models.opencode).toBe("sonnet");
|
||||
});
|
||||
});
|
||||
|
||||
describe("toServeOptions — the surrounding validation still holds", () => {
|
||||
it("defaults the agent and rejects an unknown one", () => {
|
||||
expect(optionsFor({}).agent).toBe("claude");
|
||||
expect(errorFrom(() => optionsFor({ agent: "gemini" }))?.message).toContain(
|
||||
"agent"
|
||||
);
|
||||
});
|
||||
|
||||
it("rejects a port outside the range", () => {
|
||||
expect(errorFrom(() => optionsFor({ port: "70000" }))?.message).toContain(
|
||||
"port"
|
||||
);
|
||||
});
|
||||
|
||||
it("rejects a non-numeric budget", () => {
|
||||
expect(
|
||||
errorFrom(() => optionsFor({ "max-budget": "lots" }))?.message
|
||||
).toContain("max-budget");
|
||||
});
|
||||
});
|
||||
@@ -24,6 +24,7 @@ import {
|
||||
requireAmount,
|
||||
requireEnum,
|
||||
requireInteger,
|
||||
requireModelRef,
|
||||
requirePort,
|
||||
} from "../lib/args";
|
||||
import { parseCodexConfig, readOpencodeConfig } from "../lib/backends";
|
||||
@@ -54,6 +55,9 @@ export const SERVE_FLAGS: readonly string[] = [
|
||||
"max-budget",
|
||||
"commit",
|
||||
"safe",
|
||||
"claude-model",
|
||||
"codex-model",
|
||||
"opencode-model",
|
||||
"codex-path",
|
||||
"codex-config",
|
||||
"opencode-path",
|
||||
@@ -74,6 +78,8 @@ export interface ServeOptions {
|
||||
maxBudgetUsd?: number;
|
||||
maxTurns?: number;
|
||||
model?: string;
|
||||
/** Per-backend model defaults, each already falling back to `model`. */
|
||||
models: Partial<Record<AgentKind, string>>;
|
||||
open: boolean;
|
||||
opencode: OpencodeSettings;
|
||||
port?: number;
|
||||
@@ -98,6 +104,8 @@ export function toServeOptions(settings: Settings, cwd: string): ServeOptions {
|
||||
const turns = asString(settings, "max-turns");
|
||||
const budget = asString(settings, "max-budget");
|
||||
const codexConfig = parseCodexConfig(asList(settings, "codex-config"));
|
||||
const model = asString(settings, "model");
|
||||
const opencodeModel = asString(settings, "opencode-model");
|
||||
|
||||
return {
|
||||
agent: (agent ? requireEnum(agent, "agent") : "claude") as AgentKind,
|
||||
@@ -112,7 +120,18 @@ export function toServeOptions(settings: Settings, cwd: string): ServeOptions {
|
||||
json: asBoolean(settings, "json"),
|
||||
maxBudgetUsd: budget ? requireAmount(budget, "max-budget") : undefined,
|
||||
maxTurns: turns ? requireInteger(turns, "max-turns") : undefined,
|
||||
model: asString(settings, "model"),
|
||||
model,
|
||||
// The fallback collapses here rather than in the server so there is one
|
||||
// place that decides it, and one place the tests have to cover. Only the
|
||||
// opencode entry is validated: that flag names its backend, so a bare id
|
||||
// is unambiguously wrong. `model` reaches all three and cannot be.
|
||||
models: {
|
||||
claude: asString(settings, "claude-model") ?? model,
|
||||
codex: asString(settings, "codex-model") ?? model,
|
||||
opencode: opencodeModel
|
||||
? requireModelRef(opencodeModel, "opencode-model")
|
||||
: model,
|
||||
},
|
||||
open: asBoolean(settings, "open"),
|
||||
opencode: {
|
||||
agent: asString(settings, "opencode-agent"),
|
||||
@@ -262,7 +281,10 @@ export const serve = defineCommand({
|
||||
effort: opts.effort,
|
||||
maxBudgetUsd: opts.maxBudgetUsd,
|
||||
maxTurns: opts.maxTurns,
|
||||
model: opts.model,
|
||||
// The resolved per-backend map, not the raw `--model`. The opencode
|
||||
// warning reads `models.opencode`, so passing only `model` left it reading
|
||||
// `undefined` and the warning could never fire.
|
||||
models: opts.models,
|
||||
});
|
||||
|
||||
let dev: DevServer | undefined;
|
||||
@@ -286,6 +308,7 @@ export const serve = defineCommand({
|
||||
maxBudgetUsd: opts.maxBudgetUsd,
|
||||
maxTurns: opts.maxTurns,
|
||||
model: opts.model,
|
||||
models: opts.models,
|
||||
opencode: opts.opencode,
|
||||
port,
|
||||
safe: opts.safe,
|
||||
@@ -306,6 +329,10 @@ export const serve = defineCommand({
|
||||
agent: opts.agent,
|
||||
cwd: opts.cwd,
|
||||
mode: opts.surface,
|
||||
// The resolved model for the backend that will run, so a scripted
|
||||
// caller can read back which of the four model flags won rather
|
||||
// than re-deriving the precedence itself.
|
||||
model: opts.models?.[opts.agent],
|
||||
port,
|
||||
safe: opts.safe,
|
||||
targetPort,
|
||||
@@ -320,6 +347,7 @@ export const serve = defineCommand({
|
||||
launchBanner({
|
||||
agent: opts.agent,
|
||||
cwd: opts.cwd,
|
||||
model: opts.models?.[opts.agent],
|
||||
safe: opts.safe,
|
||||
surface: opts.surface,
|
||||
targetPort,
|
||||
|
||||
@@ -5,6 +5,7 @@ import {
|
||||
requireAmount,
|
||||
requireEnum,
|
||||
requireInteger,
|
||||
requireModelRef,
|
||||
requirePort,
|
||||
} from "./args";
|
||||
import { CliError, closest, EXIT } from "./errors";
|
||||
@@ -148,6 +149,29 @@ describe("requireEnum", () => {
|
||||
});
|
||||
});
|
||||
|
||||
describe("requireModelRef", () => {
|
||||
it("passes a provider/model reference through", () => {
|
||||
expect(requireModelRef("anthropic/claude-sonnet-5", "opencode-model")).toBe(
|
||||
"anthropic/claude-sonnet-5"
|
||||
);
|
||||
});
|
||||
|
||||
// opencode drops an id it cannot attribute to a provider, so a bare one is
|
||||
// not "close enough" — it means the turn silently runs on something else.
|
||||
it.each(["sonnet", "", "/sonnet", "anthropic/", "anthropic//x"])(
|
||||
"rejects %o",
|
||||
(value) => {
|
||||
expect(() => requireModelRef(value, "opencode-model")).toThrow(CliError);
|
||||
}
|
||||
);
|
||||
|
||||
it("shows the shape rather than only naming it", () => {
|
||||
expect(
|
||||
thrown(() => requireModelRef("sonnet", "opencode-model")).hint
|
||||
).toContain("anthropic/sonnet");
|
||||
});
|
||||
});
|
||||
|
||||
describe("requirePort", () => {
|
||||
it("accepts a port in range", () => {
|
||||
expect(requirePort("3000", "target")).toBe(3000);
|
||||
|
||||
@@ -126,7 +126,7 @@ export const FLAGS: readonly FlagSpec[] = [
|
||||
alias: "m",
|
||||
defaultHint: "the agent's own default",
|
||||
group: "AGENT",
|
||||
help: "Model id.",
|
||||
help: "Model id for whichever agent runs. Per-backend flags outrank it.",
|
||||
hint: "<id>",
|
||||
name: "model",
|
||||
type: "string",
|
||||
@@ -167,6 +167,30 @@ export const FLAGS: readonly FlagSpec[] = [
|
||||
name: "safe",
|
||||
type: "boolean",
|
||||
},
|
||||
{
|
||||
defaultHint: "--model, then the agent's own",
|
||||
group: "BACKEND",
|
||||
help: "Model for the claude backend. Takes an alias or a full id.",
|
||||
hint: "<id>",
|
||||
name: "claude-model",
|
||||
type: "string",
|
||||
},
|
||||
{
|
||||
defaultHint: "--model, then the agent's own",
|
||||
group: "BACKEND",
|
||||
help: "Model for the codex backend.",
|
||||
hint: "<id>",
|
||||
name: "codex-model",
|
||||
type: "string",
|
||||
},
|
||||
{
|
||||
defaultHint: "--model, then the agent's own",
|
||||
group: "BACKEND",
|
||||
help: "Model for the opencode backend. Needs the provider/model form.",
|
||||
hint: "<provider/model>",
|
||||
name: "opencode-model",
|
||||
type: "string",
|
||||
},
|
||||
{
|
||||
defaultHint: "bundled",
|
||||
group: "BACKEND",
|
||||
@@ -410,6 +434,30 @@ export function requireEnum(value: string, name: string): string {
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* An opencode model reference, which must name its provider.
|
||||
*
|
||||
* `modelRefFor` splits on the first slash and drops an id it cannot attribute,
|
||||
* so `--opencode-model sonnet` would be silently ignored and the turn would run
|
||||
* on the server's default — the user having explicitly asked for something else.
|
||||
*
|
||||
* A hard error is right *here* and wrong for `--model`, and the difference is
|
||||
* which backend the flag is aimed at. This one names opencode, so a bare id can
|
||||
* only be a mistake. `--model` applies to whichever agent the picker lands on,
|
||||
* where a bare id is correct for two of the three, so that one keeps the launch
|
||||
* warning in `banner.ts` instead.
|
||||
*/
|
||||
export function requireModelRef(value: string, name: string): string {
|
||||
const [provider, ...rest] = value.split("/");
|
||||
if (provider && rest.length > 0 && rest.every(Boolean)) {
|
||||
return value;
|
||||
}
|
||||
throw new CliError(`Invalid --${name} '${value}'`, {
|
||||
exitCode: EXIT.usage,
|
||||
hint: `opencode resolves a model through its provider, so it needs the provider/model form — try 'anthropic/${value}' or run \`opencode models\` to list what you have configured.`,
|
||||
});
|
||||
}
|
||||
|
||||
const MAX_PORT = 65_535;
|
||||
|
||||
export function requirePort(value: string, name: string): number {
|
||||
|
||||
@@ -0,0 +1,177 @@
|
||||
import { afterEach, beforeAll, describe, expect, it, vi } from "vitest";
|
||||
import { warnBackendLimits } from "./banner";
|
||||
import { setColorEnabled } from "./terminal";
|
||||
|
||||
/*
|
||||
* The launch warnings, which are the only thing standing between a user and a
|
||||
* flag that is being silently dropped.
|
||||
*
|
||||
* This file exists because there was no `banner.test.ts` when `warnBackendLimits`
|
||||
* was switched from reading `--model` to reading the resolved per-backend map.
|
||||
* Its one caller was never updated to pass that map, so the opencode warning read
|
||||
* `undefined` forever and could not fire — and `airship --agent opencode --model
|
||||
* sonnet`, which opencode cannot resolve and drops on the floor, launched clean.
|
||||
* Nothing failed, because nothing was looking.
|
||||
*
|
||||
* `cwd` is this repo throughout, so the unrelated "not a git repository" warning
|
||||
* never fires and each case asserts on the one line it is about.
|
||||
*/
|
||||
|
||||
const REPO = process.cwd();
|
||||
|
||||
/** Everything written to stderr while `run` executes. */
|
||||
function stderrFrom(run: () => void): string {
|
||||
let out = "";
|
||||
const spy = vi
|
||||
.spyOn(process.stderr, "write")
|
||||
.mockImplementation((chunk: string | Uint8Array) => {
|
||||
out += String(chunk);
|
||||
return true;
|
||||
});
|
||||
try {
|
||||
run();
|
||||
} finally {
|
||||
spy.mockRestore();
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
describe("warnBackendLimits", () => {
|
||||
beforeAll(() => {
|
||||
// Assertions match on characters, not on ANSI.
|
||||
setColorEnabled(false);
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
vi.restoreAllMocks();
|
||||
});
|
||||
|
||||
describe("a bare model id on opencode", () => {
|
||||
it("warns, naming the id and the form it needed", () => {
|
||||
const out = stderrFrom(() =>
|
||||
warnBackendLimits({
|
||||
agent: "opencode",
|
||||
cwd: REPO,
|
||||
models: { opencode: "sonnet" },
|
||||
})
|
||||
);
|
||||
|
||||
expect(out).toContain("sonnet");
|
||||
expect(out).toContain("provider/model");
|
||||
// The suggestion has to be actionable, not just a complaint.
|
||||
expect(out).toContain("anthropic/sonnet");
|
||||
});
|
||||
|
||||
it("stays quiet once the id names its provider", () => {
|
||||
const out = stderrFrom(() =>
|
||||
warnBackendLimits({
|
||||
agent: "opencode",
|
||||
cwd: REPO,
|
||||
models: { opencode: "anthropic/claude-sonnet-5" },
|
||||
})
|
||||
);
|
||||
|
||||
expect(out).toBe("");
|
||||
});
|
||||
|
||||
it("stays quiet on the backends that take a bare id", () => {
|
||||
for (const agent of ["claude", "codex"] as const) {
|
||||
const out = stderrFrom(() =>
|
||||
warnBackendLimits({
|
||||
agent,
|
||||
cwd: REPO,
|
||||
models: { [agent]: "sonnet" },
|
||||
})
|
||||
);
|
||||
|
||||
expect(out).toBe("");
|
||||
}
|
||||
});
|
||||
|
||||
it("reads the entry for the running backend, not another one", () => {
|
||||
// The map always carries all three, because `--model` fills every entry
|
||||
// it does not override. Warning off claude's copy while codex runs would
|
||||
// fire on every `airship --agent codex --model sonnet`.
|
||||
const out = stderrFrom(() =>
|
||||
warnBackendLimits({
|
||||
agent: "codex",
|
||||
cwd: REPO,
|
||||
models: {
|
||||
claude: "sonnet",
|
||||
codex: "gpt-5.3-codex",
|
||||
opencode: "sonnet",
|
||||
},
|
||||
})
|
||||
);
|
||||
|
||||
expect(out).toBe("");
|
||||
});
|
||||
});
|
||||
|
||||
describe("claude-only knobs", () => {
|
||||
it("warns that --max-budget is dropped elsewhere", () => {
|
||||
const out = stderrFrom(() =>
|
||||
warnBackendLimits({ agent: "codex", cwd: REPO, maxBudgetUsd: 5 })
|
||||
);
|
||||
|
||||
expect(out).toContain("--max-budget");
|
||||
});
|
||||
|
||||
it("warns that --max-turns is dropped elsewhere", () => {
|
||||
const out = stderrFrom(() =>
|
||||
warnBackendLimits({ agent: "opencode", cwd: REPO, maxTurns: 24 })
|
||||
);
|
||||
|
||||
expect(out).toContain("--max-turns");
|
||||
});
|
||||
|
||||
it("keeps both for claude itself", () => {
|
||||
const out = stderrFrom(() =>
|
||||
warnBackendLimits({
|
||||
agent: "claude",
|
||||
cwd: REPO,
|
||||
maxBudgetUsd: 5,
|
||||
maxTurns: 24,
|
||||
})
|
||||
);
|
||||
|
||||
expect(out).toBe("");
|
||||
});
|
||||
});
|
||||
|
||||
describe("--effort", () => {
|
||||
it("warns that opencode has no reasoning-effort control", () => {
|
||||
const out = stderrFrom(() =>
|
||||
warnBackendLimits({ agent: "opencode", cwd: REPO, effort: "high" })
|
||||
);
|
||||
|
||||
expect(out).toContain("--effort");
|
||||
expect(out).toContain("--opencode-config");
|
||||
});
|
||||
|
||||
it("stays quiet for the two backends that honour it", () => {
|
||||
for (const agent of ["claude", "codex"] as const) {
|
||||
const out = stderrFrom(() =>
|
||||
warnBackendLimits({ agent, cwd: REPO, effort: "high" })
|
||||
);
|
||||
|
||||
expect(out).toBe("");
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
it("says nothing at all when every flag is one the backend honours", () => {
|
||||
const out = stderrFrom(() =>
|
||||
warnBackendLimits({
|
||||
agent: "claude",
|
||||
cwd: REPO,
|
||||
effort: "high",
|
||||
maxBudgetUsd: 5,
|
||||
maxTurns: 24,
|
||||
models: { claude: "opus" },
|
||||
})
|
||||
);
|
||||
|
||||
expect(out).toBe("");
|
||||
});
|
||||
});
|
||||
@@ -36,7 +36,9 @@ export function warnBackendLimits(o: {
|
||||
effort?: string;
|
||||
maxBudgetUsd?: number;
|
||||
maxTurns?: number;
|
||||
model?: string;
|
||||
/** The *resolved* per-backend models, as `serve.ts` collapses them. Not the
|
||||
* raw `--model`: what a turn will actually send is what is worth warning on. */
|
||||
models?: Partial<Record<AgentKind, string>>;
|
||||
}): void {
|
||||
const warn = (message: string): void => {
|
||||
process.stderr.write(`\n ${style.yellow(`⚠ ${message}`)}\n`);
|
||||
@@ -67,9 +69,16 @@ export function warnBackendLimits(o: {
|
||||
}
|
||||
// A bare model id cannot be resolved to a provider, so it would be dropped
|
||||
// silently and the run would quietly use opencode's default instead.
|
||||
if (o.agent === "opencode" && o.model && !o.model.includes("/")) {
|
||||
//
|
||||
// Read off the *resolved* per-backend value, not `--model`: that is what a
|
||||
// turn will actually send. It also makes this unreachable via
|
||||
// `--opencode-model`, which `requireModelRef` already rejects outright — a
|
||||
// flag that names its backend can be a hard error, and only the catch-all
|
||||
// `--model` is left needing a warning.
|
||||
const opencodeModel = o.models?.opencode;
|
||||
if (o.agent === "opencode" && opencodeModel && !opencodeModel.includes("/")) {
|
||||
warn(
|
||||
`--model '${o.model}' is ignored with --agent opencode: it wants the provider/model form (e.g. anthropic/${o.model}).`
|
||||
`--model '${opencodeModel}' is ignored with --agent opencode: it wants the provider/model form (e.g. anthropic/${opencodeModel}).\n Set --opencode-model to give opencode its own.`
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -91,13 +100,21 @@ function surfaceLines(surface: AirshipSurface): string {
|
||||
export function launchBanner(info: {
|
||||
agent: AgentKind;
|
||||
cwd: string;
|
||||
/** The resolved model for `agent`, when one was configured. */
|
||||
model?: string;
|
||||
safe: boolean;
|
||||
surface: AirshipSurface;
|
||||
targetPort: number;
|
||||
url: string;
|
||||
}): string {
|
||||
// Four flags can name a model — `--model`, the three per-backend ones — and
|
||||
// they resolve in an order. Without this the only way to learn which one won
|
||||
// was to run a turn and read the transcript. Omitted rather than guessed when
|
||||
// nothing was configured: the backend picks in that case, and naming a default
|
||||
// airship did not choose would be a claim it cannot make.
|
||||
const on = info.model ? ` on ${info.model}` : "";
|
||||
return (
|
||||
`\n ${style.magenta("◆")} ${style.bold("airship")} — editing ${info.cwd} with ${info.agent}\n` +
|
||||
`\n ${style.magenta("◆")} ${style.bold("airship")} — editing ${info.cwd} with ${info.agent}${on}\n` +
|
||||
` → open ${style.cyan(info.url)}\n` +
|
||||
` ${style.dim(`(proxying your dev server at http://localhost:${info.targetPort})`)}\n\n` +
|
||||
// Stated at every launch, not just in --help: a tool that can write
|
||||
|
||||
@@ -104,6 +104,33 @@ describe("loadConfig", () => {
|
||||
expect(hintOf(() => loadConfig(root))).toBe("Did you mean target?");
|
||||
});
|
||||
|
||||
// The per-backend model keys are not declared anywhere in this module: they
|
||||
// exist in `airship.config.json` only because they are flags, and the schema
|
||||
// is the flag registry. These three assert that pipe end to end, which is
|
||||
// also what makes `airship init` writing `claudeModel` safe.
|
||||
it.each([
|
||||
["claudeModel", "claude-model"],
|
||||
["codexModel", "codex-model"],
|
||||
["opencodeModel", "opencode-model"],
|
||||
])("reads %s as %s", (written, flag) => {
|
||||
const root = fixture({
|
||||
"airship.config.json": `{ "${written}": "some-model" }`,
|
||||
});
|
||||
expect(loadConfig(root).values[flag]).toBe("some-model");
|
||||
});
|
||||
|
||||
it("accepts the kebab spelling of a per-backend model too", () => {
|
||||
const root = fixture({
|
||||
"airship.config.json": '{ "claude-model": "opus" }',
|
||||
});
|
||||
expect(loadConfig(root).values["claude-model"]).toBe("opus");
|
||||
});
|
||||
|
||||
it("suggests the near miss on a mistyped model key", () => {
|
||||
const root = fixture({ "airship.config.json": '{ "claudModel": "opus" }' });
|
||||
expect(hintOf(() => loadConfig(root))).toBe("Did you mean claude-model?");
|
||||
});
|
||||
|
||||
it("rejects a non-boolean for a boolean setting", () => {
|
||||
const root = fixture({ "airship.config.json": '{ "safe": "yes" }' });
|
||||
expect(() => loadConfig(root)).toThrow(CliError);
|
||||
|
||||
+117
-4
@@ -2,15 +2,24 @@
|
||||
* The interactive launcher, and the prompts `init` reuses.
|
||||
*
|
||||
* Running `airship` bare used to print the whole help and exit 1 — a wall of
|
||||
* text as the answer to "what do I do". At a real terminal it now asks the three
|
||||
* text as the answer to "what do I do". At a real terminal it now asks the few
|
||||
* questions that matter and launches.
|
||||
*
|
||||
* What counts as "matters" differs by caller, which is what `WizardOptions` is
|
||||
* for: a bare launch settles only what it needs to start, while `init` is
|
||||
* writing a file meant to outlive the session and can afford to ask more.
|
||||
*
|
||||
* Every prompt is gated on a TTY at both ends by the caller. In a pipe or a CI
|
||||
* job there is nobody to answer, and a prompt there does not fail — it hangs,
|
||||
* which is the worst failure a CLI has.
|
||||
*/
|
||||
|
||||
import { type AgentKind, checkAuth } from "@airship/server";
|
||||
import {
|
||||
type AgentKind,
|
||||
checkAuth,
|
||||
listModels,
|
||||
type ModelProbeOptions,
|
||||
} from "@airship/server";
|
||||
import {
|
||||
cancel,
|
||||
confirm,
|
||||
@@ -29,10 +38,35 @@ import { style } from "./terminal";
|
||||
export interface WizardAnswers {
|
||||
agent: AgentKind;
|
||||
mode: (typeof MODES)[number];
|
||||
/** Absent means "whatever that backend picks", which is the common answer. */
|
||||
model?: string;
|
||||
safe: boolean;
|
||||
target: number;
|
||||
}
|
||||
|
||||
export interface WizardOptions {
|
||||
/**
|
||||
* Ask which model, after the agent is chosen.
|
||||
*
|
||||
* Off by default, and the default is the point: a bare `airship` already asks
|
||||
* four questions before it launches, and a fifth paid on every start to
|
||||
* settle something most runs are happy to leave alone is a bad trade.
|
||||
* `airship init` turns it on, because that call is writing a file whose whole
|
||||
* purpose is to stop the flags being retyped.
|
||||
*/
|
||||
askModel?: boolean;
|
||||
/**
|
||||
* Passed through to the model probe.
|
||||
*
|
||||
* The opencode probe *starts a server* — at `--opencode-path`, or against a
|
||||
* running one at `--opencode-url`, with `--opencode-config` applied. Called
|
||||
* without these it ignored every one of them, so a project that reaches
|
||||
* opencode any way but the default got a probe that asked the wrong thing and
|
||||
* then reported "not signed in" for it.
|
||||
*/
|
||||
probe?: ModelProbeOptions;
|
||||
}
|
||||
|
||||
/** Clack returns a symbol when the user hits Ctrl-C; treat it as an exit. */
|
||||
function unwrap<T>(value: T | symbol): T {
|
||||
if (isCancel(value)) {
|
||||
@@ -72,7 +106,79 @@ async function agentOptions(): Promise<
|
||||
);
|
||||
}
|
||||
|
||||
export async function runWizard(cwd: string): Promise<WizardAnswers> {
|
||||
/** The sentinel for "do not write a model", distinct from any real id. */
|
||||
const MODEL_DEFAULT = "\u0000default";
|
||||
/** The sentinel for "let me type one", distinct from any real id. */
|
||||
const MODEL_CUSTOM = "\u0000custom";
|
||||
|
||||
/**
|
||||
* Which model, for the agent just chosen.
|
||||
*
|
||||
* Asks the backend rather than offering a list from memory, so what is on
|
||||
* screen is what that machine can actually run — `listModels` reports Claude's
|
||||
* account-scoped set and OpenCode's configured providers, and falls back to the
|
||||
* seed for Codex, which can enumerate nothing.
|
||||
*
|
||||
* Leaving it on the default is the first option and the likely answer, so it
|
||||
* costs one Enter. The escape hatch is last, for a model too new to be listed.
|
||||
*/
|
||||
async function askForModel(
|
||||
agent: AgentKind,
|
||||
cwd: string,
|
||||
opts: ModelProbeOptions = {}
|
||||
): Promise<string | undefined> {
|
||||
const probe = spinner();
|
||||
probe.start(`Asking ${agent} which models it offers`);
|
||||
const group = await listModels(agent, cwd, opts);
|
||||
probe.stop(
|
||||
group.note
|
||||
? `${agent}: ${group.note}`
|
||||
: `${agent} offers ${group.models.length} models`
|
||||
);
|
||||
|
||||
const choice = unwrap(
|
||||
await select({
|
||||
message: "Which model?",
|
||||
options: [
|
||||
{
|
||||
hint: group.default ?? "whatever the backend picks",
|
||||
label: "default",
|
||||
value: MODEL_DEFAULT,
|
||||
},
|
||||
...group.models.map((m) => ({
|
||||
hint: m.hint,
|
||||
label: m.label,
|
||||
value: m.id,
|
||||
})),
|
||||
{ hint: "type an id", label: "something else…", value: MODEL_CUSTOM },
|
||||
],
|
||||
})
|
||||
);
|
||||
|
||||
if (choice === MODEL_DEFAULT) {
|
||||
return;
|
||||
}
|
||||
if (choice !== MODEL_CUSTOM) {
|
||||
return choice;
|
||||
}
|
||||
const typed = unwrap(
|
||||
await text({
|
||||
message: "Model id",
|
||||
placeholder:
|
||||
agent === "opencode" ? "anthropic/claude-sonnet-5" : "claude-opus-5",
|
||||
validate: (value) =>
|
||||
agent === "opencode" && value && !value.includes("/")
|
||||
? "opencode needs the provider/model form, e.g. anthropic/claude-sonnet-5."
|
||||
: undefined,
|
||||
})
|
||||
);
|
||||
return typed?.trim() || undefined;
|
||||
}
|
||||
|
||||
export async function runWizard(
|
||||
cwd: string,
|
||||
options: WizardOptions = {}
|
||||
): Promise<WizardAnswers> {
|
||||
intro(style.magenta("◆ airship"));
|
||||
|
||||
const probe = spinner();
|
||||
@@ -101,6 +207,13 @@ export async function runWizard(cwd: string): Promise<WizardAnswers> {
|
||||
})
|
||||
);
|
||||
|
||||
// Straight after the agent, because the answer only means anything against
|
||||
// one: a model id is per backend, and asking before would have nothing to
|
||||
// list.
|
||||
const model = options.askModel
|
||||
? await askForModel(agent, cwd, options.probe)
|
||||
: undefined;
|
||||
|
||||
const mode = unwrap(
|
||||
await select({
|
||||
message: "Which surface?",
|
||||
@@ -127,7 +240,7 @@ export async function runWizard(cwd: string): Promise<WizardAnswers> {
|
||||
);
|
||||
|
||||
outro(style.dim("Starting…"));
|
||||
return { agent, mode, safe, target: Number(target) };
|
||||
return { agent, mode, model, safe, target: Number(target) };
|
||||
}
|
||||
|
||||
/** The message a non-interactive bare invocation gets instead of a prompt. */
|
||||
|
||||
Reference in New Issue
Block a user