@phantomcodes/cli 1.2.3 → 1.2.5

package/dist/setup/plan.mjs

@@ -33,6 +33,8 @@ export function planSetup(env, opts = {}) {
         picked = names.filter((a) => SETUP_AGENTS[a].detect?.(env, home) ?? existsSync(path.join(home, SETUP_AGENTS[a].home)));
         if (picked.length === 0)
             die(`Found no agent to set up. Pass --agent ${names.join('|')}`);
+        if (opts.only)
+            picked = picked.filter((a) => opts.only.includes(a));
     }
     else if (names.includes(opts.agent)) {
         picked = [opts.agent];
@@ -55,8 +57,8 @@ export function planSetup(env, opts = {}) {
     }
     if (provider === true && !resolveApiKey(env)) {
         if (!opts.guided)
-            die('No API key to give the agents. Run: phantom login', 'no_key');
-        notes.push('No Phantom AI key yet, so only the skills are installed. Run phantom login, then phantom setup again.');
+            die('No Phantom key yet to give the agents. Run phantom login to sign in, then run this again.', 'no_key');
+        notes.push('No Phantom key yet, so only the skills are installed. Run phantom setup in a terminal to sign in and set up the rest.');
         provider = false;
     }
     const ctx = { env, home, onPath: opts.onPath, model: opts.model, shellRc: shellRcFile(env, home) };

package/dist/setup/screen.mjs

@@ -0,0 +1,237 @@
+// How `phantom setup` looks in a terminal, drawn in the site's style: the
+// ghost and a title, an uppercase caption over a thin rule, one row per agent
+// with its files lined up in columns, and after the changes a ✓ per agent and
+// the next step in corner brackets, like the site's hero.
+// The JSON result (setupCommand without a terminal) never goes through here.
+import os from 'node:os';
+import path from 'node:path';
+import { paint, unstyled } from "../core/style.mjs";
+import { brandHeader } from "../core/brand.mjs";
+import { inApp } from "../cli/screens.mjs";
+import { SETUP_AGENTS } from "./agents.mjs";
+/** `text` broken at spaces into lines of at most `width` characters; a single longer word stays whole. */
+export function wrapWords(text, width) {
+    const lines = [];
+    let line = '';
+    for (const word of text.split(' ')) {
+        if (line && (line + ' ' + word).length > width) {
+            lines.push(line);
+            line = word;
+        }
+        else
+            line = line ? line + ' ' + word : word;
+    }
+    return [...lines, line];
+}
+/** The name a person knows an agent by: "Claude Code", or "Your shell" for the startup file. */
+const label = (agent) => (agent === 'shell' ? 'Your shell' : (SETUP_AGENTS[agent]?.label ?? agent));
+/** How many lines a diff from `lineDiff` adds and removes. */
+function counts(diff) {
+    const rows = (diff ?? '').split('\n');
+    return { added: rows.filter((r) => r.startsWith('+')).length, removed: rows.filter((r) => r.startsWith('-')).length };
+}
+/** An uppercase caption over a thin rule, like the site's section labels (SPEND, CALLS). */
+function caption(p, text, extra, width) {
+    return [`  ${p.bold(text)}  ${extra}`.trimEnd(), `  ${p.dim('─'.repeat(width))}`];
+}
+/** Text framed by corner brackets, the site's hero frame, for the one thing to do next. */
+function framed(p, text, columns) {
+    const inner = unstyled(text).length + 4;
+    // Too wide for the window: the corners would wrap away from the text, so it's a plain line instead.
+    if (columns && inner + 4 > columns)
+        return [`  ${text}`];
+    return [`  ${p.lime('┌')}${' '.repeat(inner)}${p.lime('┐')}`, `     ${text}`, `  ${p.lime('└')}${' '.repeat(inner)}${p.lime('┘')}`];
+}
+/** `phantom setup`'s screen for one result. See {@link ScreenMode} for the moments it shows. */
+export function setupScreen(r, opts = {}) {
+    const env = opts.env ?? {};
+    const color = Boolean(opts.color);
+    const p = paint(env, color);
+    const mode = opts.mode ?? (r.dry_run ? 'dry' : r.applied === false ? 'declined' : 'done');
+    // The list is already on screen above the question, so a no only needs saying.
+    if (mode === 'declined')
+        return '\n  Nothing was changed.';
+    const home = env.HOME || os.homedir();
+    const short = (file) => (file === home || file.startsWith(home + path.sep) ? '~' + file.slice(home.length) : file);
+    // Rows run in the order setup found the agents, then the shell file last.
+    const agents = [...r.agents.map((a) => a.agent), ...(r.files.some((f) => f.agent === 'shell') ? ['shell'] : [])];
+    const skipped = (r.skipped ?? []).filter((s) => !agents.includes(s.agent));
+    const names = [...agents, ...skipped.map((s) => s.agent)];
+    const width = Math.max(12, ...names.map((a) => label(a).length + 2));
+    const pad = ' '.repeat(width + 4);
+    const name = (agent) => p.bold(label(agent).padEnd(width));
+    // Every path is padded to the longest, so the line counts form one column,
+    // unless that's wider than the window: then rows stay short and unaligned.
+    const longest = Math.max(0, ...r.files.map((f) => short(f.file).length));
+    const columns = opts.columns ?? process.stdout.columns ?? 100;
+    const fits = width + 4 + 10 + longest + 2 + 8 + 4 <= columns;
+    const pathWidth = fits ? longest : 0;
+    // As wide as a file row (name, kind, path, action and a line count), and never wider than the window.
+    const rule = Math.max(20, Math.min(width + 2 + 10 + longest + 2 + 8 + 4, columns - 4));
+    // After the prompt, a blank line sets the result apart from the answer typed above it.
+    const lines = [''];
+    const found = r.agents.length;
+    if (mode !== 'done') {
+        lines.push(...brandHeader(p, color, 'setup'), ...caption(p, 'AGENTS FOUND', p.lime(p.bold(String(found))), rule));
+    }
+    else {
+        lines.push(...caption(p, 'DONE', '', rule));
+    }
+    for (const agent of agents) {
+        const a = r.agents.find((x) => x.agent === agent);
+        // The agent's settings before its skill: the settings are what change how it runs.
+        const files = r.files.filter((f) => f.agent === agent).sort((x, y) => Number(!x.diff) - Number(!y.diff));
+        const skip = (r.skipped ?? []).filter((s) => s.agent === agent);
+        const manual = a?.provider?.manual ?? [];
+        const warnings = a?.provider?.warnings ?? [];
+        const detail = [];
+        if (mode === 'done') {
+            // Turning Phantom off for an agent that was never on changed nothing, so it gets no check mark.
+            const unchanged = !files.length && a?.provider && !a.provider.on;
+            const mark = skip.length ? p.red('✗') : manual.length ? p.yellow('!') : unchanged ? p.dim('·') : p.lime('✓');
+            lines.push(`  ${mark} ${name(agent)}${doneSummary(agent, a, files.length, skip.length > 0, p)}`);
+        }
+        else {
+            // The files first, so the eye reads down one column of paths.
+            const [first, ...rest] = files.map((f) => fileRow(f, p, short, pathWidth));
+            lines.push(`    ${name(agent)}${first ?? p.dim(manual.length ? 'nothing to write' : 'already set up')}`);
+            for (const row of rest)
+                detail.push(pad + row);
+            if (opts.diff) {
+                for (const f of files.filter((x) => x.diff)) {
+                    detail.push('', ...f.diff.split('\n').map((row) => pad + '  ' + diffRow(row, p)), '');
+                }
+            }
+        }
+        for (const s of skip)
+            detail.push(pad + p.red(`skipped: ${s.reason}`));
+        for (const w of warnings)
+            detail.push(pad + p.yellow(w));
+        // Steps to do by hand show once, after the changes, when they can be done.
+        if (manual.length && mode !== 'done')
+            detail.push(pad + p.yellow(`then a few steps by hand in ${a?.provider?.settings}, shown after`));
+        else if (manual.length) {
+            detail.push(pad + p.yellow(`In ${a?.provider?.settings}:`));
+            // Each step wraps under its own first word, not under the number.
+            const room = Math.max(30, (opts.columns ?? 100) - pad.length - 5);
+            manual.forEach((step, k) => {
+                const [first, ...rest] = wrapWords(step, room);
+                detail.push(`${pad}  ${p.dim(`${k + 1}.`)} ${first}`, ...rest.map((l) => `${pad}     ${l}`));
+            });
+        }
+        lines.push(...detail);
+    }
+    for (const s of skipped)
+        lines.push(`  ${mode === 'done' ? p.red('✗') + ' ' : '  '}${name(s.agent)}${p.red(`skipped: ${s.reason}`)}`);
+    const notes = r.notes ?? [];
+    if (notes.length)
+        lines.push('', ...notes.map((n) => `  ${n}`));
+    if (mode === 'ask' || mode === 'dry') {
+        // The file list says where; these lines say what it means, in plain words, before anyone reads a diff.
+        const routes = r.files.some((f) => f.diff && f.agent !== 'shell');
+        const skills = r.files.some((f) => !f.diff);
+        if (routes || skills)
+            lines.push('');
+        if (routes) {
+            lines.push(`  ${p.dim('What this does:')} these agents send their model requests to Phantom AI, and phantom-1 picks the model.`);
+            lines.push(`  ${p.dim('Nothing is bought:')} phantom-1 runs free until you add credit.`);
+        }
+        if (skills)
+            lines.push(`  ${p.dim('skill:')} a short note that teaches the agent the phantom commands.`);
+        // Most people only see the 'ask' screen, so its hint is the plain command they just ran, plus --diff.
+        if (!opts.diff && opts.hint !== false && r.files.some((f) => f.diff)) {
+            lines.push('', mode === 'ask' ? `  To see every line first, answer n and run: ${p.cyan('phantom setup --diff')}` : `  To see every line, add ${p.cyan('--diff')}.`);
+        }
+        if (mode === 'dry')
+            lines.push(p.dim('  This was a preview. Nothing was changed.'));
+    }
+    else if (!r.files.length && !(r.skipped ?? []).length && !r.agents.some((a) => a.provider?.manual?.length)) {
+        const off = r.agents.length > 0 && r.agents.every((a) => a.provider && !a.provider.on);
+        lines.push(off ? `  ${p.dim('·')} Phantom AI was already off for these agents. Nothing to change.` : `  ${p.lime('✓')} Everything is already set up. Nothing to change.`);
+    }
+    else if (r.files.length) {
+        lines.push('', ...nextStep(r, p, opts.columns));
+        lines.push('', inApp() ? `  ${p.dim('Undo any time: More, then Undo setup.')}` : `  Undo any time: ${p.cyan('phantom setup --restore')}`);
+    }
+    return lines.join('\n');
+}
+/** What a file is, in the words the screen uses: its settings (an agent's, or the shell's ~/.zshrc), or its skill. */
+function kind(f) {
+    if (!f.diff)
+        return 'skill';
+    // ~/.zshrc is the shell's own settings file, and the row already says "Your shell".
+    return 'settings';
+}
+/** What happens to a file, in one short word. */
+const ACTION = { create: 'new', update: 'update', remove: 'remove' };
+/**
+ * One file under an agent, in columns: what the file is, where it is, what
+ * happens to it, and how many lines change. For example
+ * `settings  ~/.codex/config.toml  new  +12`.
+ */
+function fileRow(f, p, short, pathWidth) {
+    const action = ACTION[f.action].padEnd(6);
+    const { added, removed } = counts(f.diff);
+    const change = [added ? p.green(`+${added}`) : '', removed ? p.red(`-${removed}`) : ''].filter(Boolean).join(' ');
+    return [
+        p.dim(kind(f).padEnd(8)),
+        short(f.file).padEnd(pathWidth),
+        f.action === 'remove' ? p.red(action) : p.cyan(action),
+        change + (f.backup ? p.dim('  copy kept') : ''),
+    ]
+        .join('  ')
+        .trimEnd();
+}
+/** One line of a diff, colored by whether it adds, removes or only shows context. */
+function diffRow(row, p) {
+    if (row.startsWith('+'))
+        return p.green(row);
+    if (row.startsWith('-'))
+        return p.red(row);
+    return p.dim(row);
+}
+/** After the changes: one plain sentence per agent on what it does now. */
+function doneSummary(agent, a, files, skipped, p) {
+    if (skipped)
+        return p.red('left as it was.');
+    if (agent === 'shell')
+        return 'loads your Phantom AI key in new terminals.';
+    const prov = a?.provider;
+    if (prov?.manual?.length)
+        return p.yellow('not finished: 2 minutes by hand:');
+    if (prov && !prov.on)
+        return !files ? p.dim('already off: nothing to remove.') : agent === 'claude' ? 'back on Anthropic.' : 'Phantom AI settings removed.';
+    if (prov?.on) {
+        const model = prov.model ? ` ${p.pill(` ${prov.model} `)}` : '';
+        return `runs on Phantom AI${model}  ${p.dim(`restart ${label(agent)} to pick it up`)}`;
+    }
+    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', gemini: 'gemini' };
+/**
+ * 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
+ * to open a new terminal first, and names that agent; otherwise it doesn't.
+ */
+function nextStep(r, p, columns) {
+    const on = r.agents.filter((a) => a.provider?.on || (!a.provider && r.files.some((f) => f.agent === a.agent)));
+    const shell = r.files.some((f) => f.agent === 'shell');
+    const readsShell = on.filter((a) => SETUP_AGENTS[a.agent]?.shellEnv);
+    const first = (readsShell.length && shell ? readsShell : on).find((a) => START[a.agent]) ?? on[0];
+    if (!first)
+        return [];
+    const cmd = START[first.agent];
+    const name = label(first.agent);
+    const step = cmd
+        ? shell && readsShell.some((a) => a.agent === first.agent)
+            ? `${p.lime('→')} ${p.bold('Open a new terminal')}, then run ${p.cyan(cmd)}`
+            : `${p.lime('→')} ${p.bold('Next:')} run ${p.cyan(cmd)}`
+        : `${p.lime('→')} ${p.bold('Next:')} open ${name}`;
+    const lines = framed(p, step, columns);
+    if (cmd && ['claude', 'codex', 'pi'].includes(first.agent))
+        lines.push(p.dim(`     or start it through phantom: phantom ${first.agent}`));
+    if (shell && readsShell.length)
+        lines.push(p.dim(`     ${readsShell.map((a) => label(a.agent)).join(', ')} ${readsShell.length === 1 ? 'reads' : 'read'} your Phantom AI key from the shell, so a new terminal is needed.`));
+    return lines;
+}

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/dist/spend/command.mjs

@@ -1,30 +1,19 @@
+import { unknownSub } from "../cli/start.mjs";
 import { readFileSync } from 'node:fs';
 import { die } from "../core/errors.mjs";
-import { flagNum, out } from "../core/helpers.mjs";
+import { flagNum, out, pickIo, showsScreen } from "../core/helpers.mjs";
+import { colorOn, paint } from "../core/style.mjs";
+import { choose } from "../core/pick.mjs";
+import { hideHints, lineupScreen, priceHint, routeScreen, routeTestScreen, TIER_ABOUT } from "../cli/screens.mjs";
 import { getLineup, putLineup, resetLineup, LINEUP_TIERS } from "./lineup.mjs";
 import { getRoute, putRoute, patchRoute, clearRoute, testRoute, parseCondition } from "./routing.mjs";
-/** `--table` output for `route`. */
-export function tableRoute(d) {
-    const p = d.route_policy;
-    if (!p)
-        return 'route           none (model "auto" is refused)';
-    const rules = p.rules ?? [];
-    return [
-        `models          ${p.models.join(', ')}`,
-        `applies_to      ${p.applies_to ?? 'auto'}`,
-        `on_empty        ${p.on_empty ?? 'stop'}`,
-        `fallback        ${p.fallback_on_error ?? false}`,
-        `sticky          ${p.stick_minutes ?? 5} min${(p.stick_by_prompt ?? true) ? '' : ' (x-phantom-session only)'}`,
-        ...(rules.length ? rules.map((r, i) => `rule ${String(i + 1).padEnd(11)}if ${Object.entries(r.if).map(([k, v]) => `${k}=${v}`).join(' ')} use ${r.use}`) : ['rules           none (auto runs the first model)']),
-    ].join('\n');
-}
-/** `--table` output for `route test`. */
-export function tableRouteTest(d) {
-    const t = d;
-    return [`model           ${t.model}`, `reason          ${t.reason}`].join('\n');
-}
 /** `phantom route`: the key's route policy, its rules, and a dry run. Run by `run()`. */
-export async function routeCommand({ argv, io, apiKey, subcommand, flags, table, baseUrl }) {
+export async function routeCommand(input) {
+    const { argv, io, apiKey, subcommand, flags, baseUrl, env } = input;
+    const table = showsScreen(input);
+    const style = { env, color: colorOn(env, io.stdoutIsTTY) };
+    const tableRoute = (d) => routeScreen(d, style);
+    const tableRouteTest = (d) => routeTestScreen(d, style);
     if (!subcommand || subcommand === 'get') {
         out(await getRoute(apiKey, baseUrl), table, tableRoute, io.stdout);
     }
@@ -100,23 +89,10 @@ export async function routeCommand({ argv, io, apiKey, subcommand, flags, table,
         out(await clearRoute(apiKey, baseUrl), table, tableRoute, io.stdout);
     }
     else {
-        die(`Unknown route subcommand: ${subcommand}`);
+        die(unknownSub('route', String(subcommand), ['get', 'set', 'rule', 'test', 'clear']), 'route_usage');
     }
     return 0;
 }
-/** `--table` output for `lineup`. */
-export function tableLineup(d) {
-    const { lineup, tiers, choices } = d;
-    return LINEUP_TIERS.flatMap((tier) => {
-        const pick = lineup?.[tier];
-        const fallback = lineup?.fallbacks?.[tier];
-        return [
-            `${tier.padEnd(15)} ${tiers[tier].model}  ${pick ? '(your pick)' : '(default)'}`,
-            ...(fallback ? [`${''.padEnd(15)} falls back to ${fallback}`] : []),
-            ...(choices ? choices[tier].map((c) => `${''.padEnd(15)} - ${c.model}${c.default ? ' (default)' : ''}`) : []),
-        ];
-    }).join('\n');
-}
 /**
  * Changes one tier's entry in `into` from a flag value: a model id sets it,
  * and `default` clears it so the tier runs its default again.
@@ -132,7 +108,16 @@ function applyPick(into, tier, flag, value) {
         into[tier] = value;
 }
 /** `phantom lineup`: the model phantom-1 runs in each tier, and a fallback for each. Run by `run()`. */
-export async function lineupCommand({ io, apiKey, subcommand, flags, table, baseUrl }) {
+export async function lineupCommand(input) {
+    const { io, apiKey, subcommand, flags, baseUrl, env } = input;
+    const table = showsScreen(input);
+    const style = { env, color: colorOn(env, io.stdoutIsTTY) };
+    const tableLineup = (d) => lineupScreen(d, style);
+    // lineup set with no flags, at a terminal: pick a tier, then its model, from lists with prices.
+    // lineup alone, or set with no flags, at a terminal: the table, then a picker to change it, instead of a command to type.
+    const pick = (!subcommand || subcommand === 'set') && !LINEUP_FLAGS.some((name) => flags[name] !== undefined) ? pickIo(input) : null;
+    if (pick)
+        return lineupPicker(input, pick, tableLineup);
     if (!subcommand || subcommand === 'get') {
         out(await getLineup(apiKey, baseUrl), table, tableLineup, io.stdout);
     }
@@ -166,7 +151,59 @@ export async function lineupCommand({ io, apiKey, subcommand, flags, table, base
         out(await resetLineup(apiKey, baseUrl), table, tableLineup, io.stdout);
     }
     else {
-        die(`Unknown lineup subcommand: ${subcommand}`);
+        die(unknownSub('lineup', String(subcommand), ['get', 'set', 'reset']), 'lineup_usage');
     }
     return 0;
 }
+/** The flags `lineup set` reads; with none of them, at a terminal, it opens the picker instead. */
+const LINEUP_FLAGS = ['economy', 'standard', 'frontier', 'economy-fallback', 'standard-fallback', 'frontier-fallback'];
+/**
+ * `phantom lineup set` at a terminal: choose a tier, then a model for it from
+ * a list with prices (the default marked), and it saves at once. It loops
+ * back to the tiers so you can change another; Esc there is done.
+ */
+async function lineupPicker(input, pick, show) {
+    const { io, apiKey, baseUrl } = input;
+    let read = await getLineup(apiKey, baseUrl);
+    // The table's "→ phantom lineup set" line would point at the picker that's already open.
+    const hintsWere = hideHints(true);
+    // The marker stays on the tier you last changed, so changing it again (or the next one) is one move.
+    let last = 0;
+    try {
+        for (;;) {
+            io.stdout(show(read) + '\n\n');
+            const tier = await choose({ ...pick, esc: 'back' }, 'Which tier do you want to change?', [
+                ...LINEUP_TIERS.map((t) => ({ label: t[0].toUpperCase() + t.slice(1), hint: `${TIER_ABOUT[t]} · now ${read.tiers[t].model}`, value: t })),
+                { label: 'Put every tier back to its default', value: 'reset' },
+            ], last);
+            if (tier === null)
+                return 0;
+            if (tier === 'reset') {
+                read = { ...(await resetLineup(apiKey, baseUrl)), choices: read.choices };
+                continue;
+            }
+            const options = read.choices?.[tier] ?? [];
+            const now = read.tiers[tier].model;
+            const model = await choose({ ...pick, esc: 'back' }, `Which model should ${tier} run?`, options.map((c) => ({ label: c.model, hint: priceHint(c), value: c.model })), Math.max(0, options.findIndex((c) => c.model === now)));
+            if (model === null)
+                continue;
+            const { fallbacks, ...picks } = read.lineup ?? {};
+            const chosen = options.find((c) => c.model === model);
+            if (chosen?.default)
+                delete picks[tier];
+            else
+                picks[tier] = model;
+            // A fallback can't be the tier's own model, which the server refuses.
+            const keep = { ...fallbacks };
+            if (keep[tier] === model)
+                delete keep[tier];
+            read = { ...(await putLineup(apiKey, Object.keys(keep).length ? { ...picks, fallbacks: keep } : picks, baseUrl)), choices: read.choices };
+            last = LINEUP_TIERS.indexOf(tier);
+            // Said on its own line, so the change is plain before the table redraws.
+            io.stdout(`\n  ${paint(input.env, colorOn(input.env, io.stdoutIsTTY)).lime('✓')} ${tier[0].toUpperCase() + tier.slice(1)} now runs ${model}.\n`);
+        }
+    }
+    finally {
+        hideHints(hintsWere);
+    }
+}

package/dist/spend/report.mjs

@@ -1,5 +1,8 @@
 import { die } from "../core/errors.mjs";
-import { out } from "../core/helpers.mjs";
+import { out, showsScreen } from "../core/helpers.mjs";
+import { colorOn } from "../core/style.mjs";
+import { barsGrowing, motionOn, play } from "../core/motion.mjs";
+import { spendScreen } from "../cli/screens.mjs";
 import { request } from "../core/request.mjs";
 import { workspaceGet } from "../workspace/command.mjs";
 /** The dates `--from` and `--to` ask for, as a query string. The server checks them. */
@@ -51,11 +54,17 @@ export function tableSpend(d) {
  * workspace connection `phantom login` saved. Run by `run()`.
  */
 export async function spendCommand(input) {
-    const { io, apiKey, table, baseUrl, flags } = input;
+    const { io, apiKey, baseUrl, flags, env } = input;
     const dates = { from: flags['from'], to: flags['to'] };
     const result = flags['workspace']
         ? (await workspaceGet(input, `/spend${query(dates)}`))
         : await getSpend(apiKey, dates, baseUrl);
-    out(result, table, tableSpend, io.stdout);
+    const screen = showsScreen(input);
+    // The bars grow in, the way the site's cost bars do; JSON, pipes and NO_COLOR get the result at once.
+    if (screen && motionOn(env, io.stdoutIsTTY)) {
+        await play(io.stdout, barsGrowing(spendScreen(result, { env, color: true }).split('\n')), { rows: process.stdout.rows, skipOnKey: true });
+        return 0;
+    }
+    out(result, screen, (d) => spendScreen(d, { env, color: colorOn(env, io.stdoutIsTTY) }), io.stdout);
     return 0;
 }