@phantomcodes/cli 1.2.3 → 1.2.4

package/dist/core/motion.mjs

@@ -0,0 +1,156 @@
+import { colorOn } from "./style.mjs";
+import { GHOST, WORDMARK } from "./brand.mjs";
+/** Whether to animate: color is on for that stream (a terminal, no NO_COLOR), it isn't CI, and PHANTOM_NO_MOTION isn't set. */
+export function motionOn(env, isTTY) {
+    if (env.PHANTOM_NO_MOTION && env.PHANTOM_NO_MOTION !== '0')
+        return false;
+    if (env.CI && env.CI !== 'false' && env.CI !== '0')
+        return false;
+    // FORCE_COLOR can color a pipe, but cursor moves only make sense on a real terminal.
+    return colorOn(env, isTTY) && Boolean(isTTY);
+}
+/** Fast at first, then easing to a stop: the curve for things that arrive. */
+export const easeOut = (t) => 1 - (1 - Math.min(1, Math.max(0, t))) ** 3;
+/**
+ * Lines appearing top to bottom: frame k shows the first k lines and keeps the
+ * rest blank, so the block's height never changes. `delay(line)` is how long
+ * the line waits before it appears; 0 lets it come with the one before.
+ */
+export function reveal(lines, delay) {
+    const book = { frames: [], delays: [] };
+    lines.forEach((line, k) => {
+        const wait = delay(line, k);
+        const frame = lines.map((l, j) => (j <= k ? l : ''));
+        // A line with no wait joins the frame before it instead of making its own.
+        if (book.frames.length && wait === 0)
+            book.frames[book.frames.length - 1] = frame;
+        else {
+            book.frames.push(frame);
+            book.delays.push(book.frames.length === 1 ? 0 : wait);
+        }
+    });
+    return book;
+}
+/**
+ * Every bar in `lines` (a run of ━ followed by its ─ track) drawn at
+ * `progress` of its length, 0 to 1. The track grows to fill what the bar gives
+ * up, so each line keeps its width.
+ */
+export function growBars(lines, progress) {
+    return lines.map((line) => line.replace(/(━+)((?:\x1b\[[0-9;]*m)*)(─*)/g, (_all, fill, codes, track) => {
+        const shown = Math.round(fill.length * progress);
+        return '━'.repeat(shown) + codes + '─'.repeat(fill.length - shown + track.length);
+    }));
+}
+/** Bars growing from nothing to their length over `ms`, easing out. */
+export function barsGrowing(lines, ms = 250, steps = 10) {
+    const frames = Array.from({ length: steps + 1 }, (_, k) => growBars(lines, easeOut(k / steps)));
+    return { frames, delays: frames.map((_, k) => (k === 0 ? 0 : ms / steps)) };
+}
+/** The ghost's eye row with the eyes closed: the two gaps filled with a low half block, like lids. */
+export const CLOSED_EYES = GHOST[1][0].replace(/ (?=█)/, '▄').replace(/ $/, '▄');
+/**
+ * The brand header drawing in, for a screen whose lines start with it
+ * (setup): PHANTOM appears letter by letter, the rest of the screen follows
+ * row by row, then the ghost blinks once.
+ */
+export function brandIntro(lines, opts = {}) {
+    const { letterMs = 20, rowMs = 18, blinkMs = 90 } = opts;
+    const wordRows = lines.map((l, k) => [k, WORDMARK.findIndex((w) => l.includes(w))]).filter(([, r]) => r >= 0);
+    const eyeRow = lines.findIndex((l) => l.includes(GHOST[1][0]));
+    const headerEnd = Math.max(eyeRow, ...wordRows.map(([k]) => k)) + 2;
+    const book = { frames: [], delays: [] };
+    const push = (frame, wait) => (book.frames.push(frame), book.delays.push(book.frames.length === 1 ? 0 : wait));
+    // 1. The ghost, then PHANTOM letter by letter beside it.
+    const letterCount = 7;
+    for (let n = 0; n <= letterCount; n++) {
+        push(lines.map((l, k) => {
+            if (k >= headerEnd)
+                return '';
+            const hit = wordRows.find(([row]) => row === k);
+            if (!hit)
+                return l;
+            return l.replace(WORDMARK[hit[1]], lettersOf(hit[1], n));
+        }), letterMs);
+    }
+    // 2. The rest of the screen, a row at a time.
+    for (let k = headerEnd; k < lines.length; k++)
+        push(lines.map((l, j) => (j <= k ? l : '')), lines[k] ? rowMs : 0);
+    // 3. One blink.
+    if (eyeRow >= 0) {
+        push(lines.map((l, k) => (k === eyeRow ? l.replace(GHOST[1][0], CLOSED_EYES) : l)), blinkMs);
+        push(lines, blinkMs);
+    }
+    return book;
+}
+/** Row `row` of PHANTOM with its first `n` letters drawn and the rest left as spaces. */
+function lettersOf(row, n) {
+    const full = WORDMARK[row];
+    const cut = LETTER_ENDS[n];
+    return full.slice(0, cut).padEnd(full.length);
+}
+/** Where each letter of PHANTOM ends in a wordmark row (the rows share widths): 0 letters, 1 letter and so on. */
+const LETTER_ENDS = (() => {
+    const widths = [4, 4, 4, 4, 3, 4, 5];
+    const ends = [0];
+    widths.forEach((w, k) => ends.push(ends[k] + w + (k ? 1 : 0)));
+    return ends;
+})();
+/** Wait `ms` milliseconds. Tests pass their own so they don't wait. */
+const realSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+/**
+ * Plays a flipbook on a stream: writes the first frame, then moves the cursor
+ * back up and redraws each next one in place. Ends on the last frame with a
+ * newline. A key press (on a terminal) or `rows` too few to fit the block
+ * skips straight to the last frame.
+ */
+export async function play(write, book, opts = {}) {
+    const last = book.frames[book.frames.length - 1] ?? [];
+    // Taller than the window: moving the cursor up would run off the top, so print the result.
+    if (!book.frames.length || (opts.rows !== undefined && last.length >= opts.rows)) {
+        write(last.join('\n') + '\n');
+        return;
+    }
+    const sleep = opts.sleep ?? realSleep;
+    const stopSkip = opts.skipOnKey ? listenForKey() : null;
+    try {
+        write(book.frames[0].join('\n'));
+        for (let k = 1; k < book.frames.length; k++) {
+            if (stopSkip?.pressed())
+                break;
+            await sleep(book.delays[k]);
+            write(redraw(book.frames[k]));
+        }
+        if (stopSkip?.pressed())
+            write(redraw(last));
+        write('\n');
+    }
+    finally {
+        stopSkip?.stop();
+    }
+}
+/** The codes that move back to the block's first line and write `frame` over it, clearing each line first. */
+function redraw(frame) {
+    const up = frame.length > 1 ? `\x1b[${frame.length - 1}A` : '';
+    return `\r${up}` + frame.map((line) => `\x1b[2K${line}`).join('\n');
+}
+/** Watches the keyboard while an animation plays, so any key skips it. Leaves the terminal as it found it. */
+function listenForKey() {
+    const input = process.stdin;
+    if (!input.isTTY || typeof input.setRawMode !== 'function')
+        return null;
+    let hit = false;
+    const onData = () => void (hit = true);
+    const wasRaw = input.isRaw;
+    input.setRawMode(true);
+    input.on('data', onData);
+    input.resume();
+    return {
+        pressed: () => hit,
+        stop: () => {
+            input.off('data', onData);
+            input.setRawMode(wasRaw);
+            input.pause();
+        },
+    };
+}

package/dist/core/pick.mjs

@@ -0,0 +1,293 @@
+// Choosing with the keyboard: a list you move through with ↑ and ↓ (or j and
+// k) and pick with Enter, and a checklist you tick with Space. Drawn on
+// stderr in phantom's style, redrawn in place as you move, and folded into
+// one line (the question and your answer) once you choose. Only for a person
+// at a terminal: scripts, pipes and CI get the plain prompts or flags instead.
+import { emitKeypressEvents } from 'node:readline';
+import { colorOn, paint } from "./style.mjs";
+/** A hint cut to the room left on the line, so a row never wraps in a narrow window. */
+const fitHint = (hint, used, columns) => {
+    const room = (columns ?? process.stderr.columns ?? 100) - used - 1;
+    return hint.length <= room ? hint : room > 3 ? hint.slice(0, room - 1) + '…' : '';
+};
+/** Thrown by a picker when Ctrl+C is pressed: stop the whole command, wherever it is. */
+export class Cancelled extends Error {
+    constructor() {
+        super('Cancelled.');
+        this.name = 'Cancelled';
+    }
+}
+/**
+ * Thrown by a command started from the start menu when Esc is pressed on its
+ * first step, so the menu shows again instead of the command ending.
+ */
+export class BackToMenu extends Error {
+    constructor() {
+        super('Back to the menu.');
+        this.name = 'BackToMenu';
+    }
+}
+/** Which way a key moves the marker: -1 up, 1 down, 0 not at all. */
+function step(key) {
+    if (key === 'up' || key === 'k' || key === 'shift-tab')
+        return -1;
+    if (key === 'down' || key === 'j' || key === 'tab')
+        return 1;
+    return 0;
+}
+/** Whether this run can show a picker: a person at a terminal on both ends, and not CI. */
+export function canPick(env, stderrIsTTY, stdinIsTTY = Boolean(process.stdin.isTTY)) {
+    if (env.CI && env.CI !== 'false' && env.CI !== '0')
+        return false;
+    return Boolean(stderrIsTTY) && stdinIsTTY;
+}
+/**
+ * The keyboard, one key at a time, named the way pickers read them: `up`,
+ * `down`, `return`, `space`, `escape`, `ctrl-c`, or the letter itself.
+ */
+export function keyboard() {
+    const input = process.stdin;
+    emitKeypressEvents(input);
+    const wasRaw = input.isRaw;
+    input.setRawMode?.(true);
+    input.resume();
+    const waiting = [];
+    const queued = [];
+    const onKey = (text, key = {}) => {
+        // A printable character comes through as itself, capitals and all, so the text box gets "Dana", not "dana".
+        const printable = Boolean(text && text.length === 1 && text >= ' ' && !key.ctrl && (key.name === undefined || key.name.length === 1));
+        const name = key.ctrl && key.name === 'c' ? 'ctrl-c' : key.name === 'enter' ? 'return' : key.shift && key.name === 'tab' ? 'shift-tab' : printable ? text : (key.name ?? text ?? '');
+        const resolve = waiting.shift();
+        if (resolve)
+            resolve(name);
+        else
+            queued.push(name);
+    };
+    input.on('keypress', onKey);
+    return {
+        next: () => new Promise((resolve) => (queued.length ? resolve(queued.shift()) : waiting.push(resolve))),
+        close: () => {
+            input.off('keypress', onKey);
+            input.setRawMode?.(wasRaw);
+            input.pause();
+        },
+    };
+}
+/**
+ * Keys from a list, for tests: each `next()` returns the next name, and `end`
+ * once the list runs out (which pickers treat as Esc). Every picker in a run reads from the same list, as
+ * they would from one keyboard.
+ */
+export function scriptedKeys(names) {
+    const left = [...names];
+    // `end` when the list runs out: pickers read it as Esc; a wait that only listens for Esc ignores it.
+    const source = { next: async () => left.shift() ?? 'end', close: () => { } };
+    return () => source;
+}
+/** A block of lines that redraws itself in place: the first draw prints it, each later one moves up and writes over it. */
+function block(write) {
+    let height = 0;
+    return (lines) => {
+        const up = height > 1 ? `\x1b[${height - 1}A` : '';
+        // \x1b[J clears whatever the last draw left below, when the new one is shorter.
+        write((height ? `\r${up}\x1b[J` : '') + lines.join('\n'));
+        height = lines.length;
+    };
+}
+/** 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 hint under a picker: which keys do what. */
+const keysHint = (p, words) => `  ${p.dim(words)}`;
+/**
+ * Asks a question with a list of answers. ↑ and ↓ (or k and j, or Tab and
+ * Shift+Tab) move and Enter chooses. Esc or q returns null, which the caller
+ * reads as "go back a step"; Ctrl+C throws {@link Cancelled} to stop the
+ * whole command. `start` is where the marker begins.
+ */
+export async function choose(io, question, choices, start = 0) {
+    const p = paint(io.env, colorOn(io.env, true));
+    const draw = block(io.write);
+    const width = Math.max(...choices.map((c) => c.label.length)) + 3;
+    let at = Math.min(Math.max(0, start), choices.length - 1);
+    const frame = () => [
+        asked(p, question),
+        ...choices.map((c, k) => k === at
+            ? `  ${p.lime('❯')} ${p.bold(c.label.padEnd(width))}${p.dim(fitHint(c.hint ?? '', width + 4, io.columns))}`
+            : `    ${c.label.padEnd(width)}${p.dim(fitHint(c.hint ?? '', width + 4, io.columns))}`),
+        keysHint(p, `↑↓ or tab move · enter choose · esc ${io.esc ?? 'back'} · ctrl+c stop`),
+    ];
+    const keys = (io.keys ?? keyboard)();
+    io.write('\x1b[?25l');
+    try {
+        draw(frame());
+        for (;;) {
+            const key = await keys.next();
+            if (step(key))
+                at = (at + choices.length + step(key)) % choices.length;
+            else if (key === 'return') {
+                draw([asked(p, question, choices[at].label)]);
+                return choices[at].value;
+            }
+            else if (key === 'escape' || key === 'q' || key === 'end') {
+                draw([asked(p, question, io.esc === 'quit' ? 'quit' : 'back')]);
+                return null;
+            }
+            else if (key === 'ctrl-c') {
+                draw([asked(p, question, 'cancelled')]);
+                throw new Cancelled();
+            }
+            else
+                continue;
+            draw(frame());
+        }
+    }
+    finally {
+        io.write('\n\x1b[?25h');
+        keys.close();
+    }
+}
+/**
+ * A checklist: ↑ and ↓ (or Tab) move, Space ticks or unticks, `a` ticks all,
+ * Enter goes on with the ticked items (it waits while none is ticked). Esc
+ * or q returns null (go back); Ctrl+C throws {@link Cancelled}.
+ */
+export async function checklist(io, question, items) {
+    const p = paint(io.env, colorOn(io.env, true));
+    const draw = block(io.write);
+    const ticked = items.map((i) => i.checked !== false);
+    const width = Math.max(...items.map((i) => i.label.length)) + 3;
+    let at = 0;
+    let nudge = '';
+    const frame = () => [
+        asked(p, question),
+        ...items.map((item, k) => {
+            const box = ticked[k] ? p.lime('◉') : p.dim('◯');
+            const label = k === at ? p.bold(item.label.padEnd(width)) : item.label.padEnd(width);
+            return `  ${k === at ? p.lime('❯') : ' '} ${box} ${label}${p.dim(fitHint(item.hint ?? '', width + 6, io.columns))}`;
+        }),
+        nudge ? `  ${p.yellow(nudge)}` : keysHint(p, `↑↓ or tab move · space tick · a all · enter go on · esc ${io.esc ?? 'back'}`),
+    ];
+    const keys = (io.keys ?? keyboard)();
+    io.write('\x1b[?25l');
+    try {
+        draw(frame());
+        for (;;) {
+            const key = await keys.next();
+            nudge = '';
+            if (step(key))
+                at = (at + items.length + step(key)) % items.length;
+            else if (key === 'space')
+                ticked[at] = !ticked[at];
+            else if (key === 'a')
+                ticked.fill(!ticked.every(Boolean));
+            else if (key === 'return') {
+                if (!ticked.some(Boolean))
+                    nudge = 'Tick at least one, or press esc to go back.';
+                else {
+                    const chosen = items.filter((_, k) => ticked[k]);
+                    draw([asked(p, question, chosen.map((i) => i.label).join(', '))]);
+                    return chosen.map((i) => i.value);
+                }
+            }
+            else if (key === 'escape' || key === 'q' || key === 'end') {
+                draw([asked(p, question, io.esc === 'quit' ? 'quit' : 'back')]);
+                return null;
+            }
+            else if (key === 'ctrl-c') {
+                draw([asked(p, question, 'cancelled')]);
+                throw new Cancelled();
+            }
+            else
+                continue;
+            draw(frame());
+        }
+    }
+    finally {
+        io.write('\n\x1b[?25h');
+        keys.close();
+    }
+}
+/**
+ * Listens for Esc or Ctrl+C while something waits (sign-in waiting for
+ * approval), without taking over the screen. `pressed` settles with the key;
+ * other keys are ignored, and the end of a test's keys never settles it.
+ */
+export function cancelKeys(source) {
+    let closed = false;
+    const pressed = new Promise((resolve) => {
+        const listen = async () => {
+            while (!closed) {
+                const key = await source.next();
+                if (key === 'end')
+                    return;
+                if (key === 'escape' || key === 'q')
+                    return resolve('escape');
+                if (key === 'ctrl-c')
+                    return resolve('ctrl-c');
+            }
+        };
+        void listen();
+    });
+    return {
+        pressed,
+        close: () => {
+            closed = true;
+            source.close();
+        },
+    };
+}
+/**
+ * Asks for a short piece of text, such as a key's name or an amount: type it,
+ * Backspace to fix it, Enter to go on (it waits while `check` refuses the
+ * text, and shows why), Esc to go back (null), Ctrl+C to stop. Keys longer
+ * than one character that aren't named keys are typed as text, so a test can
+ * send "sam" as one key.
+ */
+export async function askText(io, question, opts = {}) {
+    const p = paint(io.env, colorOn(io.env, true));
+    const draw = block(io.write);
+    let text = '';
+    let problem = '';
+    const NAMED = new Set(['up', 'down', 'left', 'right', 'tab', 'shift-tab', 'space', 'return', 'escape', 'ctrl-c', 'backspace', 'delete', 'end']);
+    const frame = () => [
+        asked(p, question),
+        `  ${p.lime('❯')} ${text ? p.bold(text) : p.dim(opts.placeholder ?? '')}${p.lime('▏')}`,
+        problem ? `  ${p.yellow(problem)}` : keysHint(p, `type · enter go on · esc ${io.esc ?? 'back'}`),
+    ];
+    const keys = (io.keys ?? keyboard)();
+    io.write('\x1b[?25l');
+    try {
+        draw(frame());
+        for (;;) {
+            const key = await keys.next();
+            problem = '';
+            if (key === 'return') {
+                const why = opts.check?.(text.trim()) ?? (text.trim() ? null : 'Type something, or press esc to go back.');
+                if (!why) {
+                    draw([asked(p, question, text.trim())]);
+                    return text.trim();
+                }
+                problem = why;
+            }
+            else if (key === 'escape' || key === 'end') {
+                draw([asked(p, question, io.esc === 'quit' ? 'quit' : 'back')]);
+                return null;
+            }
+            else if (key === 'ctrl-c') {
+                draw([asked(p, question, 'cancelled')]);
+                throw new Cancelled();
+            }
+            else if (key === 'backspace' || key === 'delete')
+                text = text.slice(0, -1);
+            else if (key === 'space')
+                text += ' ';
+            else if (!NAMED.has(key))
+                text += key;
+            draw(frame());
+        }
+    }
+    finally {
+        io.write('\n\x1b[?25h');
+        keys.close();
+    }
+}

package/dist/core/style.mjs

@@ -0,0 +1,36 @@
+/**
+ * Whether to print color: only to a terminal, never with `NO_COLOR` set
+ * (https://no-color.org) or on a `dumb` terminal. `FORCE_COLOR` turns it on
+ * anywhere, and `FORCE_COLOR=0` turns it off.
+ */
+export function colorOn(env, isTTY) {
+    if (env.NO_COLOR)
+        return false;
+    if (env.FORCE_COLOR !== undefined)
+        return env.FORCE_COLOR !== '0';
+    return Boolean(isTTY) && env.TERM !== 'dumb';
+}
+const wrap = (open, close) => (s) => `\x1b[${open}m${s}\x1b[${close}m`;
+const plain = (s) => s;
+/**
+ * The styles for one screen. Lime and cyan use 24-bit color when the terminal says it
+ * has it (`COLORTERM=truecolor`), and the nearest of the 256 standard colors otherwise.
+ */
+export function paint(env, on) {
+    if (!on)
+        return { lime: plain, bold: plain, white: plain, pill: plain, dim: plain, cyan: plain, green: plain, red: plain, yellow: plain };
+    const truecolor = env.COLORTERM === 'truecolor' || env.COLORTERM === '24bit';
+    return {
+        lime: wrap(truecolor ? '38;2;62;230;168' : '38;5;79', '39'),
+        cyan: wrap(truecolor ? '38;2;0;209;255' : '38;5;45', '39'),
+        bold: wrap('1', '22'),
+        white: wrap('97', '39'),
+        pill: (s) => (truecolor ? `\x1b[48;2;62;230;168m\x1b[38;2;8;9;12m${s}\x1b[39m\x1b[49m` : `\x1b[48;5;79m\x1b[38;5;232m${s}\x1b[39m\x1b[49m`),
+        dim: wrap('2', '22'),
+        green: wrap('32', '39'),
+        red: wrap('31', '39'),
+        yellow: wrap('33', '39'),
+    };
+}
+/** `text` without color codes, to measure how wide it prints. */
+export const unstyled = (text) => text.replace(/\x1b\[[0-9;]*m/g, '');

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.3';
+export const VERSION = '1.2.4';

package/dist/keys/command.mjs

@@ -1,7 +1,11 @@
+import { unknownSub } from "../cli/start.mjs";
 import { createInterface } from 'node:readline/promises';
-import { die } from "../core/errors.mjs";
+import { spawnSync } from 'node:child_process';
+import { die, NO_KEY } from "../core/errors.mjs";
 import { getBalance } from "../core/request.mjs";
-import { out } from "../core/helpers.mjs";
+import { out, showsScreen } from "../core/helpers.mjs";
+import { colorOn, paint } from "../core/style.mjs";
+import { balanceScreen, keySavedScreen, logoutScreen, savedKeysScreen } from "../cli/screens.mjs";
 import { resolveApiKey, readNamedKey, saveNamedKey, removeNamedKey, listNamedKeys, saveApiKey, removeApiKey } from "./saved.mjs";
 /** `--table` output for `balance`. */
 export function tableBalance(d) {
@@ -27,9 +31,10 @@ export function tableKeys(d) {
         .join('\n');
 }
 /** `phantom balance`: the key's credit and expiry. Run by `run()`. */
-export async function balanceCommand({ io, apiKey, table, baseUrl }) {
+export async function balanceCommand(input) {
+    const { io, apiKey, baseUrl, env } = input;
     const result = await getBalance(apiKey, baseUrl);
-    out(result, table, tableBalance, io.stdout);
+    out(result, showsScreen(input), (d) => balanceScreen(d, { env, color: colorOn(env, io.stdoutIsTTY) }), io.stdout);
     return 0;
 }
 /** `phantom key list|save|show|rm`: keys saved by name. Run by `run()`. */
@@ -47,10 +52,10 @@ export async function keyCommand({ argv, env, io, subcommand, flags, table, base
                     return { ...k, active: false };
                 }
             }));
-            out({ keys: withBalance }, table, tableKeys, io.stdout);
+            out({ keys: withBalance }, table, (d) => savedKeysScreen(d.keys, { env, color: colorOn(env, io.stdoutIsTTY) }), io.stdout);
         }
         else {
-            out(list, table, tableKeys, io.stdout);
+            out(list, table, (d) => savedKeysScreen(d.keys, { env, color: colorOn(env, io.stdoutIsTTY) }), io.stdout);
         }
     }
     else if (subcommand === 'save') {
@@ -68,14 +73,22 @@ export async function keyCommand({ argv, env, io, subcommand, flags, table, base
         if (!key.startsWith('sk-phantom-'))
             die('That is not a Phantom AI key. Keys start with sk-phantom-');
         await getBalance(key, baseUrl);
-        out(saveNamedKey(env, name, key), table, (d) => `saved           ${d.name}`, io.stdout);
+        out(saveNamedKey(env, name, key), table, (d) => keySavedScreen(d.name, { env, color: colorOn(env, io.stdoutIsTTY) }), io.stdout);
     }
     else if (subcommand === 'show') {
         // Raw, for PHANTOM_API_KEY=$(phantom key show <name>). With no name, the
         // key phantom itself would use, which is what Claude Code's apiKeyHelper runs.
         const key = name ? readNamedKey(env, name) : resolveApiKey(env);
         if (!key)
-            die('No API key. Set PHANTOM_API_KEY or run: phantom login');
+            die(NO_KEY);
+        // --copy: to the clipboard instead of the screen, for pasting into an app's settings (Cursor's API key box).
+        if (flags['copy']) {
+            const copied = process.platform === 'darwin' ? spawnSync('pbcopy', { input: key }).status === 0 : false;
+            if (!copied)
+                die('Copying needs pbcopy, which is on every Mac. Elsewhere: phantom keys show | your clipboard tool.', 'copy_unavailable');
+            io.stderr(`  ${paint(env, colorOn(env, io.isTTY)).lime('✓')} Copied your key. Paste it where it's asked for; it works like a password.\n`);
+            return 0;
+        }
         io.stdout(key + '\n');
     }
     else if (subcommand === 'rm') {
@@ -84,7 +97,7 @@ export async function keyCommand({ argv, env, io, subcommand, flags, table, base
         out(removeNamedKey(env, name), table, (d) => `removed         ${d.removed}`, io.stdout);
     }
     else {
-        die(`Unknown key subcommand: ${subcommand}`);
+        die(unknownSub('key', String(subcommand), ['list', 'save', 'show', 'rm']), 'key_usage');
     }
     return 0;
 }
@@ -106,11 +119,22 @@ export async function loginCommand({ env, io, subcommand, table, baseUrl }) {
     // Check the key works before saving it.
     const balance = await getBalance(key, baseUrl);
     const saved = saveApiKey(env, key);
-    out({ ...saved, ...balance }, table, (d) => `saved           ${d.saved}\n${tableBalance(d)}`, io.stdout);
+    out({ ...saved, ...balance }, table, (d) => `\n  ${paint(env, colorOn(env, io.stdoutIsTTY)).lime('✓')} Key saved.\n${balanceScreen(d, { env, color: colorOn(env, io.stdoutIsTTY) })}`, io.stdout);
     return 0;
 }
-/** `phantom logout`: forgets the login key. Run by `run()`. */
-export async function logoutCommand({ env, io, table }) {
-    out(removeApiKey(env), table, (d) => `removed         ${d.removed}`, io.stdout);
+/**
+ * `phantom logout`: forgets the login key. `forgotWorkspace` says whether the
+ * workspace sign-in was forgotten too, so the screen doesn't say nothing changed. Run by `run()`.
+ */
+export async function logoutCommand({ env, io, table, flags }, forgotWorkspace = false) {
+    const result = removeApiKey(env);
+    // --all also forgets the keys saved by name; without it they stay, and the screen says so.
+    const named = listNamedKeys(env).keys.map((k) => k.name);
+    if (flags['all'])
+        for (const name of named)
+            removeNamedKey(env, name);
+    const kept = flags['all'] ? [] : named;
+    const removedNamed = flags['all'] ? named : [];
+    out({ ...result, removed_named: removedNamed, kept_named: kept }, table, (d) => logoutScreen(d.removed || forgotWorkspace || removedNamed.length > 0, { env, color: colorOn(env, io.stdoutIsTTY), kept, removedNamed }), io.stdout);
     return 0;
 }

package/dist/phantom.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 /**
- * phantom: prepaid AI inference for coding agents with Phantom AI.
+ * phantom: points your coding agents at Phantom AI.
  *
  * Keys, money and setup for any AI agent: a Phantom AI key, model routing,
  * and receipts that show which model answered. It runs as a CLI and through

package/dist/plan/command.mjs

@@ -1,5 +1,9 @@
+import { unknownSub } from "../cli/start.mjs";
+import { colorOn } from "../core/style.mjs";
+import { linkScreen, planScreen } from "../cli/screens.mjs";
 import { die } from "../core/errors.mjs";
-import { openUrl, out } from "../core/helpers.mjs";
+import { pickIo, showsScreen, openUrl, out } from "../core/helpers.mjs";
+import { choose } from "../core/pick.mjs";
 import { request } from "../core/request.mjs";
 import { savedManagement } from "../workspace/command.mjs";
 /** The plan of the key's workspace and its week (GET /plan). */
@@ -37,8 +41,6 @@ export function tablePlan(d) {
         lines.push(`period    ends ${p.renews_at}`);
     return lines.join('\n');
 }
-/** What `phantom plan` accepts after `plan`. */
-const USAGE = 'Use phantom plan, phantom plan pro, phantom plan max or phantom plan manage.';
 /**
  * `phantom plan`: the plan of the key's workspace and how much of the week is
  * used. `phantom plan pro|max` prints a Stripe Checkout link that puts the
@@ -48,26 +50,42 @@ const USAGE = 'Use phantom plan, phantom plan pro, phantom plan max or phantom p
  * login` saved, since a key can't manage billing. Run by `run()`.
  */
 export async function planCommand(input) {
-    const { io, apiKey, table, baseUrl, flags, subcommand } = input;
+    const { io, apiKey, baseUrl, flags, subcommand, env } = input;
+    const table = showsScreen(input);
+    const style = { env, color: colorOn(env, io.stdoutIsTTY), opened: !flags['no-browser'] };
     const open = (url) => {
         if (!flags['no-browser'])
             openUrl(url);
     };
     if (subcommand === undefined || subcommand === 'status') {
-        out(await getPlan(apiKey, baseUrl), table, tablePlan, io.stdout);
+        out(await getPlan(apiKey, baseUrl), table, (d) => planScreen(d, style), io.stdout);
     }
     else if (subcommand === 'pro' || subcommand === 'max') {
+        // At a terminal, say what the plan costs and covers, and ask, before sending anyone to pay.
+        const pick = pickIo(input);
+        if (pick) {
+            const offer = (await getPlan(apiKey, baseUrl)).prices?.[subcommand];
+            const what = offer ? `$${offer.usd_per_month} a month, paying for $${offer.week_limit_usd} of model cost a week, for every key in this workspace` : 'for every key in this workspace';
+            const go = await choose(pick, `Start ${subcommand === 'max' ? 'Max' : 'Pro'}?`, [
+                { label: 'Open Stripe to pay', hint: what, value: true },
+                { label: 'Cancel', hint: 'nothing is charged', value: false },
+            ]);
+            if (!go) {
+                io.stderr('  Nothing was charged.\n');
+                return 0;
+            }
+        }
         const result = await planCheckout(apiKey, subcommand, baseUrl);
-        out(result, table, (d) => `Open this link to pay: ${d.checkout_url}`, io.stdout);
+        out(result, table, (d) => linkScreen(`Start ${subcommand === 'max' ? 'Max' : 'Pro'} on Stripe`, d.checkout_url, ['Once it goes through:', 'phantom plan'], style), io.stdout);
         open(result.checkout_url);
     }
     else if (subcommand === 'manage') {
         const result = await planPortal(savedManagement(input) ?? apiKey, baseUrl);
-        out(result, table, (d) => `Open this link to manage billing: ${d.portal_url}`, io.stdout);
+        out(result, table, (d) => linkScreen('Manage billing on Stripe: card, switch plan, cancel', d.portal_url, null, style), io.stdout);
         open(result.portal_url);
     }
     else {
-        die(`Unknown plan command "${subcommand}". ${USAGE}`, 'plan_usage');
+        die(unknownSub('plan', String(subcommand), ['status', 'pro', 'max', 'manage']), 'plan_usage');
     }
     return 0;
 }