@phantomcodes/cli 1.2.4 → 1.2.6

package/README.md

@@ -62,9 +62,11 @@ The Phantom CLI detects supported agents, previews the configuration changes, th
 applying them. It connects their model calls to Phantom AI and wires up the saved
 key. Restart your agent, or open a new terminal, to use the connection.
 
-Codex, Claude Code, opencode, Continue, Goose, Aider, GitHub Copilot CLI and Cline
-support saved setup. Cursor gets instructions for its settings screen; pi gets
-the agent skill.
+Saved setup covers Claude Code, Codex, opencode, Continue, Goose, Aider, GitHub
+Copilot CLI, Cline, Gemini CLI, Crush, Qwen Code, Kilo Code, Kimi Code, Droid,
+Mistral Vibe and Zed. Cursor, VS Code, JetBrains AI Assistant, Warp and Trae
+keep these settings on their own settings screens, so setup prints the steps;
+pi gets the agent skill.
 
 Preview without changing files with `phantom setup --dry-run`. The Phantom CLI keeps backups;
 undo the changes with `phantom setup --restore`.
@@ -79,9 +81,11 @@ phantom workspace status
 phantom codex
 ```
 
-Both setup options require **Node 24+** and your coding agent installed. Connect, fund your
-workspace, then launch **Codex** (`phantom codex`), **Claude Code** (`phantom claude`),
-**pi** (`phantom pi`), or **any other compatible agent**.
+Both setup options require **Node 24+** and your coding agent installed. Connect, then
+launch **Codex** (`phantom codex`), **Claude Code** (`phantom claude`), **pi**
+(`phantom pi`), or **any other compatible agent**. Each runs phantom-1 unless you
+pick a model (`--model` after `--`), and phantom-1 runs on free models until you add
+credit. Free calls leave out web search, which costs money on any model.
 
 Login opens a device approval page and saves a key privately. Funding opens
 checkout; check your workspace balance after payment. Agent runs use temporary

package/dist/agents/command.mjs

@@ -6,7 +6,10 @@ import { die, NO_KEY } from "../core/errors.mjs";
 import { DEFAULT_BASE_URL, httpsOnly, request } from "../core/request.mjs";
 import { keyId, readNamedKey, resolveApiKey } from "../keys/saved.mjs";
 import { workspaceLogin } from "../workspace/command.mjs";
-const DEFAULT_MODEL = 'auto';
+/** The model an agent runs when the user names none: phantom-1, which runs free on a key with no credit. */
+const DEFAULT_MODEL = 'phantom-1';
+/** phantom-1 as Claude Code names it: its picker keeps only ids that say "claude", so Phantom lists them as `claude-code/<id>`. */
+const CLAUDE_DEFAULT_MODEL = `claude-code/${DEFAULT_MODEL}`;
 /** The key's spend and balance, or null when the answer has no numbers, such as a sign-in page that came back with status 200. */
 async function keyStatus(apiKey, baseUrl) {
     const s = await request('GET', '/key/balance', apiKey, undefined, baseUrl);
@@ -23,11 +26,16 @@ export const AGENTS = {
             // --settings outranks settings.json, so an env block or apiKeyHelper
             // `phantom setup` wrote can't send Claude Code past the proxy. The helper
             // reads the token from the environment, so it stays off the command line.
+            // It runs with this phantom's own Node: the curl installer puts none on PATH.
+            const helper = `${JSON.stringify(process.execPath)} -p "process.env.PHANTOM_AGENT_TOKEN || ''"`;
+            // phantom-1 unless the user picks a model. It goes in the environment, which
+            // Claude Code ranks below --model and below a model in its settings file.
+            const model = hasModel(args) || env.ANTHROPIC_MODEL ? {} : { ANTHROPIC_MODEL: CLAUDE_DEFAULT_MODEL };
             const vars = { ANTHROPIC_BASE_URL: proxy, CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY: '1', ENABLE_TOOL_SEARCH: 'true' };
             const { ANTHROPIC_AUTH_TOKEN: _auth, ...rest } = env;
             return {
-                args: ['--settings', JSON.stringify({ apiKeyHelper: 'node -p "process.env.PHANTOM_AGENT_TOKEN || \'\'"', env: vars }), ...args],
-                env: { ...rest, ANTHROPIC_BASE_URL: proxy, ANTHROPIC_API_KEY: token, PHANTOM_AGENT_TOKEN: token },
+                args: ['--settings', JSON.stringify({ apiKeyHelper: helper, env: vars }), ...args],
+                env: { ...rest, ...model, ANTHROPIC_BASE_URL: proxy, ANTHROPIC_API_KEY: token, PHANTOM_AGENT_TOKEN: token },
             };
         },
     },

package/dist/cli/run.mjs

@@ -21,16 +21,21 @@ import { LEGACY_SETUP_HINT, legacySetupFound } from "../setup/legacy.mjs";
  * @param node The Node version it runs on; one too old to reject forged
  *   eMudhra certificates gets a warning on stderr first.
  */
+/** Retired flags, accepted so the command can say what replaced them, and never suggested for a typo. */
+const RETIRED_FLAGS = ['pay', 'mpp'];
+/** The flags every command takes, and the retired ones. */
+const EVERY_COMMAND_FLAGS = ['table', 'json', 'help', 'all', 'version', 'mcp', ...RETIRED_FLAGS];
 /**
- * Every flag phantom reads: each one a command's help names, plus the flags
- * every command takes and two retired ones that explain themselves. A typo
- * such as --yse is refused instead of quietly ignored, which in CI would
- * otherwise drop the flag without a word.
+ * The flags a command reads: each one its help names, plus those of the
+ * command its subcommand names (`workspace fund` reads `fund`'s), plus
+ * {@link EVERY_COMMAND_FLAGS}. A typo such as --yse, or a flag only another
+ * command takes (balance --key), is refused instead of quietly ignored, which
+ * in CI would otherwise drop the flag without a word.
  */
-const KNOWN_FLAGS = new Set([
-    ...COMMANDS.flatMap((command) => [...command.help.matchAll(/--([a-z][a-z0-9-]*)/g)].map((m) => m[1])),
-    'table', 'json', 'help', 'all', 'version', 'mcp', 'pay', 'mpp',
-]);
+function flagsOf(command, subcommand) {
+    const helps = [command.help, COMMANDS.find((c) => c.name === subcommand)?.help ?? ''].join('\n');
+    return new Set([...[...helps.matchAll(/--([a-z][a-z0-9-]*)/g)].map((m) => m[1]), ...EVERY_COMMAND_FLAGS]);
+}
 export async function run(argv = process.argv.slice(2), env = process.env, io = {
     stdout: (s) => process.stdout.write(s),
     stderr: (s) => process.stderr.write(s),
@@ -92,10 +97,11 @@ export async function run(argv = process.argv.slice(2), env = process.env, io =
         const ownFlags = parseFlags(flagArgs.includes('--') ? flagArgs.slice(0, flagArgs.indexOf('--')) : flagArgs);
         // claude, codex and pi hand their arguments to the agent, so they check their own.
         const passesArgs = command.handler === COMMANDS.find((c) => c.name === 'claude')?.handler;
+        const known = flagsOf(command, subcommand);
         for (const name of passesArgs ? [] : Object.keys(ownFlags)) {
-            if (KNOWN_FLAGS.has(name))
+            if (known.has(name))
                 continue;
-            const guess = closestCommand(name, [...KNOWN_FLAGS]);
+            const guess = closestCommand(name, [...known].filter((flag) => !RETIRED_FLAGS.includes(flag)));
             die(`Unknown flag --${name} for phantom ${argv[0]}.${guess ? ` Did you mean --${guess}?` : ''} See phantom ${argv[0]} --help.`, 'unknown_flag');
         }
         // A person at a terminal reads each command's screen; a pipe (scripts, agents) or --json gets JSON.

package/dist/cli/screens.mjs

@@ -109,15 +109,19 @@ export function spendScreen(s, style = {}) {
     lines.push(...(s.scope === 'workspace' ? next(p, 'Pick the models phantom-1 runs:', 'phantom lineup') : next(p, 'Every key in the workspace:', 'phantom spend --workspace')));
     return lines.join('\n');
 }
+/** `text` cut to `width` characters, ending in … when it was longer. */
+const clip = (text, width) => (text.length > width ? `${text.slice(0, width - 1)}…` : text);
 /** The keys, one row each: name, the start of the key, what it spent, and its limit. */
 function keyRows(p, keys) {
     if (!keys.length)
         return [`  ${p.dim('No keys yet.')}`];
     return keys.map((k) => {
         const limit = k.limit_usd != null ? `limit ${usd(k.limit_usd)}` : k.budget_usd != null ? `${usd(k.budget_usd)} every ${plural(k.period_days ?? 30, 'day')}` : 'no limit';
-        const mark = k.is_active === false ? p.dim('off') : p.lime('●');
+        // A revoked or rotated key gets a hollow mark and the word off at the end, so the columns stay in line.
+        const off = k.is_active === false;
+        const mark = off ? p.dim('○') : p.lime('●');
         // The id's first 8 characters: enough for --id, which also takes the name.
-        return `  ${mark} ${(k.name ?? 'Key').slice(0, 15).padEnd(16)}${p.dim((k.id ?? '').slice(0, 8).padEnd(10))}${p.dim((k.prefix ?? '').slice(0, 18).padEnd(20))}${usd(k.spent_usd ?? 0).padStart(8)}  ${p.dim(limit)}`;
+        return `  ${mark} ${clip(k.name ?? 'Key', 20).padEnd(21)}${p.dim((k.id ?? '').slice(0, 8).padEnd(10))}${p.dim((k.prefix ?? '').slice(0, 18).padEnd(20))}${usd(k.spent_usd ?? 0).padStart(8)}  ${p.dim(limit)}${off ? `  ${p.dim('off')}` : ''}`;
     });
 }
 /** `phantom workspace`: the shared balance, each key, and the last few charges. */
@@ -161,7 +165,7 @@ export function routeScreen(r, style = {}) {
     const lines = ['', ...caption(p, w, 'ROUTING', p.dim('how model "auto" picks for this key'))];
     const policy = r.route_policy;
     if (!policy) {
-        lines.push('  No route policy, so requests for model "auto" are refused.', `  ${p.dim('phantom-1 picks a model for you without one.')}`);
+        lines.push('  No route policy, so model "auto" runs phantom-1, which picks a model for each request.');
         lines.push(...next(p, 'Make one:', 'phantom route set --models a,b,c'));
         return lines.join('\n');
     }
@@ -317,7 +321,8 @@ export function savedKeysScreen(keys, style = {}) {
         lines.push(`  ${p.dim('None saved yet.')}`);
     for (const k of keys) {
         const credit = k.credit_balance_usd === undefined ? '' : usd(k.credit_balance_usd).padStart(10);
-        lines.push(`  ${k.active === false ? p.dim('off') : p.lime('●')} ${k.name.slice(0, 19).padEnd(20)}${p.dim(k.id.slice(0, 12).padEnd(14))}${credit}`);
+        const off = k.active === false;
+        lines.push(`  ${off ? p.dim('○') : p.lime('●')} ${clip(k.name, 20).padEnd(21)}${p.dim(k.id.slice(0, 12).padEnd(14))}${credit}${off ? `  ${p.dim('off')}` : ''}`);
     }
     lines.push(...next(p, 'Save another:', 'phantom keys save <name>'));
     return lines.join('\n');

package/dist/core/helpers.mjs

@@ -12,7 +12,7 @@ export function pickIo(input) {
     if (!(io.keys ? io.isTTY : canPick(env, io.isTTY)))
         return null;
     // A command started from the menu goes back to it on Esc; one typed on its own quits.
-    return { write: io.stderr, env, keys: io.keys, esc: io.fromMenu ? 'back' : 'quit', columns: process.stderr.columns };
+    return { write: io.stderr, env, keys: io.keys, esc: io.fromMenu ? 'back' : 'cancel', columns: process.stderr.columns };
 }
 /**
  * Whether a command should draw its screen rather than print JSON: with

package/dist/core/pick.mjs

@@ -96,6 +96,8 @@ function block(write) {
 }
 /** The question line: a lime ? and the question in bold, then the answer once there is one. */
 const asked = (p, question, answer = '') => `  ${p.lime('?')} ${p.bold(question)}${answer ? ` ${p.cyan(answer)}` : ''}`;
+/** The answer a question shows after Esc: back, quit, or cancelled. */
+const escAnswer = (esc) => (esc === 'quit' ? 'quit' : esc === 'cancel' ? 'cancelled' : 'back');
 /** The hint under a picker: which keys do what. */
 const keysHint = (p, words) => `  ${p.dim(words)}`;
 /**
@@ -129,7 +131,7 @@ export async function choose(io, question, choices, start = 0) {
                 return choices[at].value;
             }
             else if (key === 'escape' || key === 'q' || key === 'end') {
-                draw([asked(p, question, io.esc === 'quit' ? 'quit' : 'back')]);
+                draw([asked(p, question, escAnswer(io.esc))]);
                 return null;
             }
             else if (key === 'ctrl-c') {
@@ -190,7 +192,7 @@ export async function checklist(io, question, items) {
                 }
             }
             else if (key === 'escape' || key === 'q' || key === 'end') {
-                draw([asked(p, question, io.esc === 'quit' ? 'quit' : 'back')]);
+                draw([asked(p, question, escAnswer(io.esc))]);
                 return null;
             }
             else if (key === 'ctrl-c') {
@@ -270,7 +272,7 @@ export async function askText(io, question, opts = {}) {
                 problem = why;
             }
             else if (key === 'escape' || key === 'end') {
-                draw([asked(p, question, io.esc === 'quit' ? 'quit' : 'back')]);
+                draw([asked(p, question, escAnswer(io.esc))]);
                 return null;
             }
             else if (key === 'ctrl-c') {

package/dist/core/version.mjs

@@ -1,2 +1,2 @@
 /** This release of phantom. `npm version` keeps it equal to the version in package.json. */
-export const VERSION = '1.2.4';
+export const VERSION = '1.2.6';

package/dist/setup/agents.mjs

@@ -6,6 +6,13 @@ import { die } from "../core/errors.mjs";
 import { resolveApiKey } from "../keys/saved.mjs";
 import { SETUP_MODEL, agentBaseUrl, readText, configHome, onPath, phantomCommand, offResult, unreadable, SETUP_MARK, SETUP_CONTEXT_WINDOW, } from "./shared.mjs";
 import { jsonObject, jsonEdit, tomlSet, tomlRemoveOurs, yamlSetTop, yamlAddModel, yamlRemoveOurs } from "./editors.mjs";
+/** The most output a model call may ask for, for agents that need a number. */
+const SETUP_OUTPUT_TOKENS = 32_000;
+/** A JSON edit's result, or '' when only `$schema` (or nothing) is left, so `off` deletes a file phantom made. */
+function unlessEmpty(file, after) {
+    const left = jsonObject(file, after);
+    return Object.keys(left).every((k) => k === '$schema') ? '' : after;
+}
 // ── Manual Provider Helper ───────────────────────────────────────────────────
 /** An agent whose model settings live on its own settings screen: setup prints the steps. */
 export function manualProvider(where, steps, note) {
@@ -88,7 +95,8 @@ export function claudePlan(env, opts) {
         ANTHROPIC_API_KEY: '',
         ENABLE_TOOL_SEARCH: 'true',
         CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY: '1',
-        ...(opts.model ? { ANTHROPIC_MODEL: opts.model } : {}),
+        // phantom-1 unless a model is named, as Codex gets: it runs free until there is credit.
+        ANTHROPIC_MODEL: opts.model ?? 'claude-code/phantom-1',
     };
     const changes = [[['apiKeyHelper'], `${phantomCommand(opts.onPath ?? onPath)} key show`], ...Object.entries(set).map(([k, v]) => [['env', k], v])];
     // A token outranks apiKeyHelper, and would send a non-Phantom key.
@@ -311,6 +319,312 @@ export function clineProvider(ctx, off) {
         },
     };
 }
+// ── Gemini CLI ───────────────────────────────────────────────────────────────
+/** Gemini CLI's folder: `.gemini` in `$GEMINI_CLI_HOME`, else in the home folder. */
+export function geminiDir(env, home) {
+    return path.join(env.GEMINI_CLI_HOME?.trim() ? env.GEMINI_CLI_HOME : home, '.gemini');
+}
+/**
+ * Gemini CLI speaks Google's API, which Phantom AI serves at `/gemini-cli`.
+ * The shell block sets GOOGLE_GEMINI_BASE_URL to it and GEMINI_API_KEY to
+ * the Phantom key; `settings.json` in Gemini CLI's folder picks API key
+ * sign-in (`security.auth.selectedType`) and the model (`model.name`).
+ * `--provider off` takes out a phantom model; the sign-in choice stays, and
+ * `phantom setup --restore` puts the file back as it was.
+ */
+export function geminiProvider(ctx, off) {
+    const file = path.join(geminiDir(ctx.env, ctx.home), 'settings.json');
+    const text = readText(file);
+    const settings = jsonObject(file, text);
+    if (off) {
+        const ours = typeof settings.model?.name === 'string' && settings.model.name.startsWith('phantom-');
+        const alone = Object.keys(settings.model ?? {}).length === 1;
+        return offResult('Gemini CLI', file, text, ours ? jsonEdit(file, text, [[alone ? ['model'] : ['model', 'name'], undefined]]) : text);
+    }
+    const model = ctx.model ?? SETUP_MODEL;
+    const changes = [
+        [['security', 'auth', 'selectedType'], 'gemini-api-key'],
+        [['model', 'name'], model],
+    ];
+    return {
+        edits: [{ file, after: jsonEdit(file, text, changes) }],
+        result: {
+            settings: file,
+            on: true,
+            base_url: agentBaseUrl(ctx.env, 'gemini-cli'),
+            model,
+            warnings: ['Gemini CLI reads its key from the shell; open a new terminal before running it. Other programs that read GEMINI_API_KEY get the Phantom key too'],
+        },
+    };
+}
+// ── Crush ────────────────────────────────────────────────────────────────────
+/** Crush's config folder: `$CRUSH_GLOBAL_CONFIG`, else `crush` in the config folder. */
+export function crushDir(env, home) {
+    return env.CRUSH_GLOBAL_CONFIG?.trim() ? env.CRUSH_GLOBAL_CONFIG : path.join(configHome(env, home), 'crush');
+}
+/**
+ * Crush: `crush.json` in Crush's config folder gets a `phantom` provider at
+ * `/coding-agent/v1` whose key is `$PHANTOM_API_KEY`, which Crush expands
+ * when it loads, and phantom-1 as both its large and small model. Crush 0.99
+ * reads this file beside a `crushrc`.
+ */
+export function crushProvider(ctx, off) {
+    const file = path.join(crushDir(ctx.env, ctx.home), 'crush.json');
+    const text = readText(file);
+    const config = jsonObject(file, text);
+    const sizes = ['large', 'small'];
+    if (off) {
+        if (!config.providers?.phantom)
+            return offResult('Crush', file, text, text);
+        const changes = [Object.keys(config.providers).length === 1 ? [['providers'], undefined] : [['providers', 'phantom'], undefined]];
+        const mine = Object.keys(config.models ?? {}).filter((k) => sizes.includes(k) && config.models?.[k]?.provider === 'phantom');
+        if (mine.length && mine.length === Object.keys(config.models ?? {}).length)
+            changes.push([['models'], undefined]);
+        else
+            for (const k of mine)
+                changes.push([['models', k], undefined]);
+        return offResult('Crush', file, text, unlessEmpty(file, jsonEdit(file, text, changes)));
+    }
+    const base = agentBaseUrl(ctx.env, 'coding-agent');
+    const model = ctx.model ?? SETUP_MODEL;
+    const changes = [
+        ...(!text?.trim() ? [[['$schema'], 'https://charm.land/crush.json']] : []),
+        [
+            ['providers', 'phantom'],
+            {
+                name: 'Phantom AI',
+                type: 'openai-compat',
+                base_url: base,
+                api_key: '$PHANTOM_API_KEY',
+                models: [{ id: model, name: model, context_window: SETUP_CONTEXT_WINDOW, default_max_tokens: SETUP_OUTPUT_TOKENS }],
+            },
+        ],
+        ...sizes.map((size) => [['models', size], { provider: 'phantom', model }]),
+    ];
+    return { edits: [{ file, after: jsonEdit(file, text, changes) }], result: { settings: file, on: true, base_url: base, model, warnings: [] } };
+}
+// ── Qwen Code ────────────────────────────────────────────────────────────────
+/** Qwen Code's folder: `$QWEN_HOME`, else `~/.qwen`. */
+export function qwenDir(env, home) {
+    return env.QWEN_HOME?.trim() ? env.QWEN_HOME : path.join(home, '.qwen');
+}
+/**
+ * Qwen Code: `settings.json` in its folder gets a model under
+ * `modelProviders.openai` at `/coding-agent/v1` that reads its key from
+ * PHANTOM_API_KEY (`envKey`), is picked as the model (`model.name`), and the
+ * OpenAI-compatible sign-in (`security.auth.selectedType`), so Qwen Code
+ * starts without asking. Its other models stay.
+ */
+export function qwenProvider(ctx, off) {
+    const file = path.join(qwenDir(ctx.env, ctx.home), 'settings.json');
+    const text = readText(file);
+    const config = jsonObject(file, text);
+    const list = config.modelProviders?.openai ?? [];
+    if (!Array.isArray(list))
+        unreadable(file, 'has modelProviders.openai as something other than a list');
+    const base = agentBaseUrl(ctx.env, 'coding-agent');
+    const ours = (m) => m?.baseUrl === base;
+    const others = list.filter((m) => !ours(m));
+    const mineIds = list.filter(ours).map((m) => m.id);
+    if (off) {
+        if (others.length === list.length)
+            return offResult('Qwen Code', file, text, text);
+        const changes = [];
+        if (others.length)
+            changes.push([['modelProviders', 'openai'], others]);
+        else
+            changes.push(Object.keys(config.modelProviders ?? {}).length === 1 ? [['modelProviders'], undefined] : [['modelProviders', 'openai'], undefined]);
+        if (mineIds.includes(config.model?.name))
+            changes.push(Object.keys(config.model ?? {}).length === 1 ? [['model'], undefined] : [['model', 'name'], undefined]);
+        return offResult('Qwen Code', file, text, unlessEmpty(file, jsonEdit(file, text, changes)));
+    }
+    const model = ctx.model ?? SETUP_MODEL;
+    const entry = { id: model, name: `Phantom AI ${model}`, baseUrl: base, envKey: 'PHANTOM_API_KEY', generationConfig: { contextWindowSize: SETUP_CONTEXT_WINDOW } };
+    const changes = [
+        [['modelProviders', 'openai'], [entry, ...others]],
+        [['security', 'auth', 'selectedType'], 'openai'],
+        [['model', 'name'], model],
+    ];
+    return { edits: [{ file, after: jsonEdit(file, text, changes) }], result: { settings: file, on: true, base_url: base, model, warnings: [] } };
+}
+// ── Kilo Code ────────────────────────────────────────────────────────────────
+/** Kilo Code's config file: `kilo.jsonc` (or `kilo.json`) in `$XDG_CONFIG_HOME/kilo`, else `~/.config/kilo`. */
+export function kiloFile(env, home) {
+    const dir = path.join(configHome(env, home), 'kilo');
+    return existsSync(path.join(dir, 'kilo.jsonc')) ? path.join(dir, 'kilo.jsonc') : path.join(dir, 'kilo.json');
+}
+/**
+ * Kilo Code's CLI, a fork of opencode: its global config gets the same
+ * `phantom` provider opencode does, with the key as `{env:PHANTOM_API_KEY}`,
+ * and `phantom/<model>` as the model. Kilo resolves `{env:...}` only in the
+ * global file, which is the one written here.
+ */
+export function kiloProvider(ctx, off) {
+    const file = kiloFile(ctx.env, ctx.home);
+    const text = readText(file);
+    const config = jsonObject(file, text);
+    if (off) {
+        if (!config.provider?.phantom)
+            return offResult('Kilo Code', file, text, text);
+        const changes = [Object.keys(config.provider).length === 1 ? [['provider'], undefined] : [['provider', 'phantom'], undefined]];
+        if (typeof config.model === 'string' && config.model.startsWith('phantom/'))
+            changes.push([['model'], undefined]);
+        return offResult('Kilo Code', file, text, unlessEmpty(file, jsonEdit(file, text, changes)));
+    }
+    const base = agentBaseUrl(ctx.env, 'coding-agent');
+    const model = ctx.model ?? SETUP_MODEL;
+    const changes = [
+        ...(!text?.trim() ? [[['$schema'], 'https://app.kilo.ai/config.json']] : []),
+        [
+            ['provider', 'phantom'],
+            {
+                npm: '@ai-sdk/openai-compatible',
+                name: 'Phantom AI',
+                options: { baseURL: base, apiKey: '{env:PHANTOM_API_KEY}' },
+                // Kilo turns off compaction for a model without limits.
+                models: { [model]: { name: model, tool_call: true, reasoning: true, limit: { context: SETUP_CONTEXT_WINDOW, output: SETUP_OUTPUT_TOKENS } } },
+            },
+        ],
+        [['model'], `phantom/${model}`],
+    ];
+    return { edits: [{ file, after: jsonEdit(file, text, changes) }], result: { settings: file, on: true, base_url: base, model: `phantom/${model}`, warnings: [] } };
+}
+// ── Kimi Code ────────────────────────────────────────────────────────────────
+/** Kimi Code's folder: `$KIMI_CODE_HOME`, else `~/.kimi-code`. */
+export function kimiDir(env, home) {
+    return env.KIMI_CODE_HOME?.trim() ? env.KIMI_CODE_HOME : path.join(home, '.kimi-code');
+}
+/**
+ * Kimi Code CLI: `config.toml` in its folder gets a `phantom` provider at
+ * `/coding-agent/v1` that reads its key from PHANTOM_API_KEY
+ * (`api_key_env`), a `phantom/<model>` model, and that model as
+ * `default_model`. Each run starts from the file without phantom's lines, so
+ * a new `--model` replaces the old one.
+ */
+export function kimiProvider(ctx, off) {
+    const file = path.join(kimiDir(ctx.env, ctx.home), 'config.toml');
+    const text = readText(file);
+    const before = text === null ? null : tomlRemoveOurs(file, text);
+    if (off)
+        return offResult('Kimi Code', file, text, before);
+    const base = agentBaseUrl(ctx.env, 'coding-agent');
+    const model = ctx.model ?? SETUP_MODEL;
+    const alias = `phantom/${model}`;
+    let t = tomlSet(file, before ?? '', [], 'default_model', JSON.stringify(alias));
+    for (const [k, v] of [['type', '"openai"'], ['base_url', JSON.stringify(base)], ['api_key_env', '"PHANTOM_API_KEY"']])
+        t = tomlSet(file, t, ['providers', 'phantom'], k, v);
+    for (const [k, v] of [['provider', '"phantom"'], ['model', JSON.stringify(model)], ['max_context_size', String(SETUP_CONTEXT_WINDOW)], ['capabilities', '["thinking", "tool_use"]']]) {
+        t = tomlSet(file, t, ['models', alias], k, v);
+    }
+    return { edits: [{ file, after: t }], result: { settings: file, on: true, base_url: base, model: alias, warnings: [] } };
+}
+// ── Droid ────────────────────────────────────────────────────────────────────
+/** The name phantom gives its model in Droid. Droid calls it `custom:Phantom-AI-<n>`. */
+const DROID_NAME = 'Phantom AI';
+/**
+ * Factory's Droid: `~/.factory/settings.json` gets a custom model at
+ * `/coding-agent/v1` (chat completions) with the key as `${PHANTOM_API_KEY}`,
+ * which Droid expands, and that model as `model`. Droid names a custom
+ * model by its place in `customModels`, so phantom's goes last, or stays
+ * where it was, and the user's own keep their names.
+ */
+export function droidProvider(ctx, off) {
+    const file = path.join(ctx.home, '.factory', 'settings.json');
+    const text = readText(file);
+    const config = jsonObject(file, text);
+    const list = config.customModels ?? [];
+    if (!Array.isArray(list))
+        unreadable(file, 'has customModels as something other than a list');
+    const base = agentBaseUrl(ctx.env, 'coding-agent');
+    const at = list.findIndex((m) => m?.baseUrl === base);
+    const mine = (m) => typeof m === 'string' && m.startsWith(`custom:${DROID_NAME.replace(/ /g, '-')}-`);
+    if (off) {
+        if (at === -1)
+            return offResult('Droid', file, text, text);
+        const rest = list.filter((_, i) => i !== at);
+        const changes = [[['customModels'], rest.length ? rest : undefined]];
+        if (mine(config.model))
+            changes.push([['model'], undefined]);
+        return offResult('Droid', file, text, unlessEmpty(file, jsonEdit(file, text, changes)));
+    }
+    const model = ctx.model ?? SETUP_MODEL;
+    const entry = { model, displayName: DROID_NAME, baseUrl: base, apiKey: '${PHANTOM_API_KEY}', provider: 'generic-chat-completion-api', maxOutputTokens: SETUP_OUTPUT_TOKENS };
+    const index = at === -1 ? list.length : at;
+    const next = [...list];
+    next[index] = entry;
+    const id = `custom:${DROID_NAME.replace(/ /g, '-')}-${index}`;
+    const changes = [
+        [['customModels'], next],
+        [['model'], id],
+    ];
+    return { edits: [{ file, after: jsonEdit(file, text, changes) }], result: { settings: file, on: true, base_url: base, model: id, warnings: [] } };
+}
+// ── Mistral Vibe ─────────────────────────────────────────────────────────────
+/**
+ * Mistral Vibe: `~/.vibe/config.toml` gets a `phantom` provider at
+ * `/coding-agent/v1` that reads its key from PHANTOM_API_KEY
+ * (`api_key_env_var`), a model on it, and that model as `active_model`.
+ * Providers and models are lists of tables (`[[providers]]`), so phantom's
+ * go at the end as marked lines, which `--provider off` takes out again.
+ */
+export function vibeProvider(ctx, off) {
+    const file = path.join(ctx.home, '.vibe', 'config.toml');
+    const text = readText(file);
+    const before = text === null ? null : tomlRemoveOurs(file, text);
+    if (off)
+        return offResult('Mistral Vibe', file, text, before);
+    const base = agentBaseUrl(ctx.env, 'coding-agent');
+    const model = ctx.model ?? SETUP_MODEL;
+    const block = [
+        '[[providers]]',
+        'name = "phantom"',
+        `api_base = ${JSON.stringify(base)}`,
+        'api_key_env_var = "PHANTOM_API_KEY"',
+        'backend = "generic"',
+        'api_style = "openai"',
+        '',
+        '[[models]]',
+        `name = ${JSON.stringify(model)}`,
+        'provider = "phantom"',
+        `alias = ${JSON.stringify(model)}`,
+    ].map((l) => (l ? `${l}  ${SETUP_MARK}` : l));
+    const body = (before ?? '').replace(/\s*$/, '');
+    const t = tomlSet(file, `${body ? `${body}\n\n` : ''}${block.join('\n')}\n`, [], 'active_model', JSON.stringify(model));
+    return { edits: [{ file, after: t }], result: { settings: file, on: true, base_url: base, model, warnings: [] } };
+}
+// ── Zed ──────────────────────────────────────────────────────────────────────
+/**
+ * Zed's agent panel: `settings.json` in Zed's config folder gets an OpenAI
+ * compatible provider named `phantom` at `/coding-agent/v1`, and its model
+ * as the agent's default. Zed reads the key for a provider named `phantom`
+ * from PHANTOM_API_KEY by itself, so no key goes in the file.
+ */
+export function zedProvider(ctx, off) {
+    const file = path.join(configHome(ctx.env, ctx.home), 'zed', 'settings.json');
+    const text = readText(file);
+    const config = jsonObject(file, text);
+    if (off) {
+        if (!config.language_models?.openai_compatible?.phantom)
+            return offResult('Zed', file, text, text);
+        const changes = [[['language_models', 'openai_compatible', 'phantom'], undefined]];
+        if (config.agent?.default_model?.provider === 'phantom')
+            changes.push([['agent', 'default_model'], undefined]);
+        return offResult('Zed', file, text, jsonEdit(file, text, changes));
+    }
+    const base = agentBaseUrl(ctx.env, 'coding-agent');
+    const model = ctx.model ?? SETUP_MODEL;
+    const changes = [
+        [
+            ['language_models', 'openai_compatible', 'phantom'],
+            { api_url: base, available_models: [{ name: model, display_name: `Phantom AI ${model}`, max_tokens: SETUP_CONTEXT_WINDOW, capabilities: { tools: true } }] },
+        ],
+        [['agent', 'default_model'], { provider: 'phantom', model }],
+    ];
+    return {
+        edits: [{ file, after: jsonEdit(file, text, changes) }],
+        result: { settings: file, on: true, base_url: base, model, warnings: ['Zed reads PHANTOM_API_KEY from your login shell; quit and reopen Zed'] },
+    };
+}
 // ── Registry ─────────────────────────────────────────────────────────────────
 /**
  * The agents `phantom setup` knows, in the order setup runs them. Adding an agent
@@ -418,6 +732,136 @@ export const SETUP_AGENTS = {
         home: '.cline',
         provider: clineProvider,
     },
+    /** Gemini CLI. Its address and key come from the shell block; settings.json picks the sign-in and model. */
+    gemini: {
+        label: 'Gemini CLI',
+        /** ~/.gemini, or under $GEMINI_CLI_HOME */
+        home: '.gemini',
+        detect: (env, home) => existsSync(geminiDir(env, home)),
+        /** ~/.agents/skills, which Gemini CLI reads as well as ~/.gemini/skills */
+        skills: '.agents/skills',
+        provider: geminiProvider,
+        shellEnv: (ctx) => ({
+            GOOGLE_GEMINI_BASE_URL: agentBaseUrl(ctx.env, 'gemini-cli'),
+            GEMINI_API_KEY: '$PHANTOM_API_KEY',
+        }),
+    },
+    /** Crush. */
+    crush: {
+        label: 'Crush',
+        /** ~/.config/crush, or $CRUSH_GLOBAL_CONFIG */
+        home: '.config/crush',
+        detect: (env, home) => existsSync(crushDir(env, home)),
+        /** ~/.agents/skills */
+        skills: '.agents/skills',
+        provider: crushProvider,
+        shellEnv: () => ({}),
+    },
+    /** Qwen Code. */
+    qwen: {
+        label: 'Qwen Code',
+        /** ~/.qwen, or $QWEN_HOME */
+        home: '.qwen',
+        detect: (env, home) => existsSync(qwenDir(env, home)),
+        /** ~/.agents/skills */
+        skills: '.agents/skills',
+        provider: qwenProvider,
+        shellEnv: () => ({}),
+    },
+    /** Kilo Code's CLI. */
+    kilo: {
+        label: 'Kilo Code',
+        /** ~/.config/kilo, or under $XDG_CONFIG_HOME */
+        home: '.config/kilo',
+        detect: (env, home) => existsSync(path.join(configHome(env, home), 'kilo')),
+        /** ~/.agents/skills */
+        skills: '.agents/skills',
+        provider: kiloProvider,
+        shellEnv: () => ({}),
+    },
+    /** Kimi Code CLI. */
+    kimi: {
+        label: 'Kimi Code',
+        /** ~/.kimi-code, or $KIMI_CODE_HOME */
+        home: '.kimi-code',
+        detect: (env, home) => existsSync(kimiDir(env, home)),
+        /** ~/.agents/skills */
+        skills: '.agents/skills',
+        provider: kimiProvider,
+        shellEnv: () => ({}),
+    },
+    /** Factory's Droid. */
+    droid: {
+        label: 'Droid',
+        /** ~/.factory */
+        home: '.factory',
+        /** ~/.factory/skills */
+        skills: '.factory/skills',
+        provider: droidProvider,
+        shellEnv: () => ({}),
+    },
+    /** Mistral Vibe. */
+    vibe: {
+        label: 'Mistral Vibe',
+        /** ~/.vibe */
+        home: '.vibe',
+        provider: vibeProvider,
+        shellEnv: () => ({}),
+    },
+    /** Zed's agent panel. It reads PHANTOM_API_KEY from the login shell. */
+    zed: {
+        label: 'Zed',
+        /** ~/.config/zed, or under $XDG_CONFIG_HOME */
+        home: '.config/zed',
+        detect: (env, home) => existsSync(path.join(configHome(env, home), 'zed')),
+        /** ~/.agents/skills */
+        skills: '.agents/skills',
+        provider: zedProvider,
+        shellEnv: () => ({}),
+    },
+    /** VS Code's chat. Its Custom Endpoint models are added on its Language Models screen. */
+    vscode: {
+        label: 'VS Code',
+        /** ~/.vscode */
+        home: '.vscode',
+        provider: manualProvider('VS Code, Chat: Manage Language Models', (ctx) => [
+            'In VS Code, run Chat: Manage Language Models from the Command Palette, then Add Models, Custom Endpoint.',
+            'Name the group Phantom AI, paste your Phantom AI key (copy it with "Copy my key" in phantom\'s menu, or phantom keys show --copy), and pick Chat Completions.',
+            `In the chatLanguageModels.json file VS Code opens, set the model's id to ${ctx.model ?? SETUP_MODEL}, its url to ${agentBaseUrl(ctx.env, 'coding-agent')}/chat/completions, and toolCalling to true, then save.`,
+        ]),
+    },
+    /** JetBrains AI Assistant, in IntelliJ IDEA, PyCharm and the other JetBrains editors. */
+    jetbrains: {
+        label: 'JetBrains AI Assistant',
+        /** ~/Library/Application Support/JetBrains on macOS, ~/.config/JetBrains elsewhere */
+        home: 'Library/Application Support/JetBrains',
+        detect: (env, home) => existsSync(path.join(home, 'Library', 'Application Support', 'JetBrains')) || existsSync(path.join(configHome(env, home), 'JetBrains')),
+        provider: manualProvider('Settings, Tools, AI Assistant, Providers & API keys', (ctx) => [
+            'In your JetBrains editor, open Settings, then Tools, AI Assistant, Providers & API keys.',
+            `Under OpenAI-compatible, set the URL to ${agentBaseUrl(ctx.env, 'coding-agent')}, paste your Phantom AI key (copy it with "Copy my key" in phantom's menu, or phantom keys show --copy), and turn on Tool calling.`,
+            `Pick ${ctx.model ?? SETUP_MODEL} in the AI Assistant chat.`,
+        ]),
+    },
+    /** Warp. Its custom inference endpoint is set on its settings screen. */
+    warp: {
+        label: 'Warp',
+        /** ~/.warp */
+        home: '.warp',
+        provider: manualProvider('Warp Settings', (ctx) => [
+            'In Warp, open Settings and search for "inference endpoint".',
+            `Set the endpoint to ${agentBaseUrl(ctx.env, 'coding-agent')}, paste your Phantom AI key (copy it with "Copy my key" in phantom's menu, or phantom keys show --copy), and add the model ${ctx.model ?? SETUP_MODEL}.`,
+        ], 'Warp uses a custom endpoint for agents that run on this computer only.'),
+    },
+    /** Trae. Its custom models are added on its settings screen. */
+    trae: {
+        label: 'Trae',
+        /** ~/.trae */
+        home: '.trae',
+        provider: manualProvider('Trae Settings, Models', (ctx) => [
+            'In Trae, open Settings, then Models, Add Model, Custom Model.',
+            `Pick the OpenAI API format, set the request URL to ${agentBaseUrl(ctx.env, 'coding-agent')}, the model id to ${ctx.model ?? SETUP_MODEL}, and paste your Phantom AI key (copy it with "Copy my key" in phantom's menu, or phantom keys show --copy).`,
+        ]),
+    },
 };
 export const SETUP_NAMES = Object.keys(SETUP_AGENTS);
 /** `a, b or c`. */

package/dist/setup/command.mjs

@@ -168,7 +168,7 @@ export async function setupCommand(input) {
         // At a terminal: a choice instead of typing y or n, with a look at every line first if wanted.
         if (pick && !io.ask) {
             for (;;) {
-                const answer = await choose({ ...pick, esc: ticks || io.fromMenu ? 'back' : 'quit' }, 'Make these changes?', [
+                const answer = await choose({ ...pick, esc: ticks || io.fromMenu ? 'back' : 'cancel' }, 'Make these changes?', [
                     { label: 'Make these changes', value: 'yes' },
                     { label: 'Show every line first', value: 'diff' },
                     { label: 'Cancel', hint: 'change nothing', value: 'no' },

package/dist/setup/screen.mjs

@@ -208,7 +208,7 @@ function doneSummary(agent, a, files, skipped, p) {
     return files ? 'skill installed.' : p.dim('already set up.');
 }
 /** The command that starts each agent that runs in a terminal. Editors (Cursor, Continue, Cline) are opened, not run. */
-const START = { claude: 'claude', codex: 'codex', pi: 'pi', opencode: 'opencode', goose: 'goose', aider: 'aider', copilot: 'copilot' };
+const START = { claude: 'claude', codex: 'codex', pi: 'pi', opencode: 'opencode', goose: 'goose', aider: 'aider', copilot: 'copilot', gemini: 'gemini', crush: 'crush', qwen: 'qwen', kilo: 'kilo', kimi: 'kimi', droid: 'droid', vibe: 'vibe' };
 /**
  * The one thing to do after setup, in corner brackets: run the agent. When an
  * agent reads its key from the shell (Codex, Goose and others), the step says

package/dist/setup/shared.mjs

@@ -11,13 +11,14 @@ export function onPath(bin) {
 export const SETUP_MODEL = 'phantom-1';
 /**
  * The address Phantom AI serves a coding agent at, from PHANTOM_BASE_URL
- * without its `/v1`: `/claude-code` (Claude Code adds `/v1` itself), or
- * `/codex/v1`, `/cursor/v1` and `/coding-agent/v1` for the others.
+ * without its `/v1`: `/claude-code` (Claude Code adds `/v1` itself),
+ * `/gemini-cli` (Gemini CLI adds Google's `/v1beta`), or `/codex/v1`,
+ * `/cursor/v1` and `/coding-agent/v1` for the others.
  * @throws {@link CliError} when PHANTOM_BASE_URL is not https ({@link httpsOnly}).
  */
 export function agentBaseUrl(env, agent) {
     const origin = httpsOnly(env.PHANTOM_BASE_URL || DEFAULT_BASE_URL).replace(/\/+$/, '').replace(/\/v1$/, '');
-    return agent === 'claude-code' ? `${origin}/claude-code` : `${origin}/${agent}/v1`;
+    return agent === 'claude-code' || agent === 'gemini-cli' ? `${origin}/${agent}` : `${origin}/${agent}/v1`;
 }
 /** The end of every line phantom adds to a TOML, YAML or shell file. */
 export const SETUP_MARK = '# phantom setup';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phantomcodes/cli",
-  "version": "1.2.4",
+  "version": "1.2.6",
   "description": "AI inference for your coding agents. Route models, control spending, and fund your workspace.",
   "keywords": [
     "phantom",
@@ -66,10 +66,10 @@
   "license": "SEE LICENSE IN LICENSE",
   "author": "Harbor Financial LLC",
   "devDependencies": {
-    "@types/node": "^24.19.1",
+    "@types/node": "^24.19.2",
     "@vitest/coverage-v8": "^5.0.3",
     "typescript": "^6.0.3",
-    "vitest": "^5.0.2"
+    "vitest": "^5.0.5"
   },
   "publishConfig": {
     "access": "public"