ravensight-playtest 0.1.0

package/src/cli.js

@@ -0,0 +1,335 @@
+import { Command, Option } from 'commander';
+import { CLI_VERSION } from './version.js';
+import { ui } from './ui/index.js';
+import { CliError, ExitCode } from './errors.js';
+import { ApiError } from './api/errors.js';
+
+/**
+ * The command line surface.
+ *
+ * Every command is loaded lazily, inside its action, for two reasons that both
+ * matter. Startup stays fast, because `npx ravensight-playtest check` should not
+ * pay to parse the whole runner: `src/run/index.js` reaches the model client,
+ * both drivers and the schema validator, and no other command needs any of
+ * them. And a build that is missing the runner (a partial install, or a tarball
+ * that lost a directory) fails with a sentence rather than a module resolution
+ * stack trace at import time.
+ */
+
+/** Where each runner backed command lives, for the message below. */
+const RUNNER_COMMANDS = {
+  run: 'src/run/index.js',
+  profile: 'src/run/index.js'
+};
+
+async function loadRunner(name, exportName) {
+  try {
+    const mod = await import('./run/index.js');
+    if (typeof mod[exportName] === 'function') return mod[exportName];
+  } catch {
+    // fall through to the message below
+  }
+  throw new CliError(
+    `The ${name} command is not available in this build.`,
+    1,
+    { hint: `It lives in ${RUNNER_COMMANDS[name]}, which this install does not have. Reinstall the package.` }
+  );
+}
+
+/**
+ * The run specific flags, for `--help`.
+ *
+ * `run` and `profile` use `allowUnknownOption()` so that everything commander
+ * does not recognise reaches `src/run/args.js`, which is the right place for
+ * flags about driving a game. The cost is that commander knows nothing about
+ * them and so prints none of them, which would leave the two most important
+ * commands documenting only the four shared flags. This block is the fix, and it
+ * is text rather than options so it cannot change what gets parsed.
+ *
+ * Kept in the same order as `VALUED` and `BOOLEAN` in src/run/args.js, which is
+ * the list it has to agree with.
+ */
+const RUNNER_HELP = `
+Run options (parsed by the runner, see src/run/args.js):
+  --personas <list>         comma separated persona slugs, default the pack's set
+  --driver <name>           playwright_web or godot_driver
+  --build-url <url>         the web build to play
+  --godot-project <dir>     the Godot project directory
+  --cli <command>           the command that starts a text build
+  --max-actions <n>         cap the actions one persona may take
+  --concurrency <n>         personas at once, default 2
+  --upload-video            upload session.webm as well as the reports
+  --upload-transcript       upload transcript.jsonl as well as the reports
+  --dry-upload              list every file and byte that would be sent, send nothing
+  --headed                  show the browser
+  --headless                hide it
+  --verbose                 print each turn
+
+Accepted and reported as not applied by this release:
+  --budget-usd, --quality, --offline-upload, --build-dir
+`;
+
+/** Flags every command shares. */
+function common(command) {
+  return command
+    .option('--api-url <url>', 'Ravensight API base URL (default from RAVENSIGHT_API_URL)')
+    .option('--repo <dir>', 'the repo to work in (default the current directory)')
+    .option('--json', 'machine readable output')
+    .option('-y, --yes', 'answer every confirmation with yes');
+}
+
+/**
+ * Wrap an action so its exit code survives commander, which discards whatever an
+ * action handler returns. The slot is per program instance rather than module
+ * scope, so two programs in one process (which is what the tests do) cannot read
+ * each other's result.
+ * @param {{code: number}} slot
+ * @param {Function} handler
+ */
+function capture(slot, handler) {
+  return async (...args) => {
+    const code = await handler(...args);
+    slot.code = typeof code === 'number' ? code : ExitCode.OK;
+  };
+}
+
+/** Normalize commander's options into the flag shape the command modules take. */
+function flagsFrom(options, extra = {}) {
+  const flags = {
+    apiUrl: options.apiUrl,
+    repoRoot: options.repo,
+    json: Boolean(options.json),
+    yes: Boolean(options.yes),
+    ...extra
+  };
+  if (flags.json) ui.setQuiet(true);
+  return flags;
+}
+
+const list = value => value.split(',').map(part => part.trim()).filter(Boolean);
+
+/**
+ * Build the program. Exported rather than executed so a test can parse an
+ * argument vector without spawning a process or exiting it.
+ * @returns {Command}
+ */
+export function buildProgram() {
+  const program = new Command();
+  const slot = { code: ExitCode.OK };
+  program.exitCodeSlot = slot;
+  program
+    .name('ravensight-playtest')
+    .description('AI personas play your game and file reports to Ravensight.')
+    .version(CLI_VERSION)
+    .showHelpAfterError()
+    .enablePositionalOptions();
+
+  common(program.command('login').description('log in to Ravensight with a device code'))
+    .option('--no-browser', 'do not try to open a browser')
+    .action(capture(slot, async options => {
+      const { login } = await import('./commands/login.js');
+      return login(flagsFrom(options, { noBrowser: options.browser === false }));
+    }));
+
+  common(program.command('logout').description('revoke this machine\'s token and forget it'))
+    .action(capture(slot, async options => {
+      const { logout } = await import('./commands/logout.js');
+      return logout(flagsFrom(options));
+    }));
+
+  common(program.command('check').description('check this machine, this repo and this account'))
+    .option('--game <gameId>', 'check against this game instead of the linked one')
+    .addOption(new Option('--modules <list>', 'price this module list').argParser(list))
+    .addOption(new Option('--personas <list>', 'price this persona list').argParser(list))
+    .option('--godot-path <path>', 'where Godot is, if it is not on the PATH')
+    .action(capture(slot, async options => {
+      const { check } = await import('./commands/check.js');
+      return check(flagsFrom(options, {
+        game: options.game,
+        modules: options.modules,
+        personas: options.personas,
+        godotPath: options.godotPath
+      }));
+    }));
+
+  common(program.command('init').description('link this repo to a Ravensight game'))
+    .option('--game <gameId>', 'the game to link')
+    .option('--force', 'relink a repo that is already linked')
+    .action(capture(slot, async options => {
+      const { init } = await import('./commands/init.js');
+      return init(flagsFrom(options, { game: options.game, force: Boolean(options.force) }));
+    }));
+
+  common(program.command('brief').description('write or read the expectations brief'))
+    .option('--show', 'print the current brief and stop')
+    .option('--open', 'open the brief form in the dashboard')
+    .option('--draft', 'save as a draft even when it looks complete')
+    .option('--from <file>', 'read the fields from a JSON file instead of asking')
+    .option('--game <gameId>', 'the game, when this repo is not linked')
+    .addOption(new Option('--modules <list>', 'price this module list').argParser(list))
+    .addOption(new Option('--personas <list>', 'price this persona list').argParser(list))
+    .action(capture(slot, async options => {
+      const { brief } = await import('./commands/brief.js');
+      return brief(flagsFrom(options, {
+        show: Boolean(options.show),
+        open: Boolean(options.open),
+        draft: Boolean(options.draft),
+        from: options.from,
+        game: options.game,
+        modules: options.modules,
+        personas: options.personas
+      }));
+    }));
+
+  common(program.command('upload').description('finish the uploads a job still owes'))
+    .argument('<jobId>')
+    .option('--game <gameId>', 'the game, when the job journal is missing')
+    .option('--dry-upload', 'list what would be sent and send nothing')
+    .option('--video', 'include the session video')
+    .option('--transcript', 'include the transcript')
+    .action(capture(slot, async (jobId, options) => {
+      const { upload } = await import('./commands/upload.js');
+      return upload(jobId, flagsFrom(options, {
+        game: options.game,
+        dryRun: Boolean(options.dryUpload),
+        video: options.video,
+        transcript: options.transcript
+      }));
+    }));
+
+  common(program.command('resume').description('carry on with a job this repo started'))
+    .argument('[jobId]')
+    .option('--game <gameId>', 'the game, when the job journal is missing')
+    .option('--status', 'report and stop, without restarting anything')
+    .option('--restart-interrupted', 'replay an interrupted run instead of finalising it from its transcript')
+    .action(capture(slot, async (jobId, options) => {
+      const { resume } = await import('./commands/resume.js');
+      return resume(jobId, flagsFrom(options, {
+        game: options.game,
+        status: Boolean(options.status),
+        // Left undefined rather than false when it was not typed, because the
+        // runner merges these over its own argv parse and flags win there.
+        restartInterrupted: options.restartInterrupted ? true : undefined
+      }));
+    }));
+
+  common(program.command('review').description('open the post job review form'))
+    .argument('[jobId]')
+    .option('--game <gameId>', 'the game, when this repo is not linked')
+    .action(capture(slot, async (jobId, options) => {
+      const { review } = await import('./commands/open.js');
+      return review(jobId, flagsFrom(options, { game: options.game }));
+    }));
+
+  common(program.command('open').description('open a job or the playtest dashboard'))
+    .argument('[jobId]')
+    .option('--game <gameId>', 'the game, when this repo is not linked')
+    .action(capture(slot, async (jobId, options) => {
+      const { open } = await import('./commands/open.js');
+      return open(jobId, flagsFrom(options, { game: options.game }));
+    }));
+
+  common(program.command('profile').description('build the game profile and capability report'))
+    .option('--game <gameId>', 'the game, when this repo is not linked')
+    .allowUnknownOption()
+    // Unknown options' values land in command.args; without this commander
+    // counts them as excess positional arguments and refuses the command.
+    .allowExcessArguments()
+    .addHelpText('after', RUNNER_HELP)
+    .action(capture(slot, async (options, command) => {
+      const profile = await loadRunner('profile', 'profileCommand');
+      return profile(flagsFrom(options, { game: options.game, argv: command.args }));
+    }));
+
+  common(program.command('run').description('run a playtest'))
+    .option('--game <gameId>', 'the game, when this repo is not linked')
+    .allowUnknownOption()
+    // Unknown options' values land in command.args; without this commander
+    // counts them as excess positional arguments and refuses the command.
+    .allowExcessArguments()
+    .addHelpText('after', RUNNER_HELP)
+    .action(capture(slot, async (options, command) => {
+      const run = await loadRunner('run', 'runCommand');
+      return run(flagsFrom(options, { game: options.game, argv: command.args }));
+    }));
+
+  return program;
+}
+
+/**
+ * Parse and dispatch, answering an exit code rather than calling `process.exit`.
+ *
+ * An `ApiError` is reported by its message and its validation pointers, which is
+ * what the server wrote them for: a developer who sees
+ * `/build_notes/controls: required` can fix it, and a developer who sees
+ * `400 Bad Request` cannot.
+ *
+ * @param {string[]} argv
+ * @returns {Promise<number>}
+ */
+export async function main(argv = process.argv, options = {}) {
+  const program = buildProgram();
+  program.exitOverride();
+  // Commander writes its own help and usage errors straight to the process
+  // streams. Routing them through `options.write` lets a test drive the whole
+  // program without printing a page of help into the test log.
+  if (options.write) {
+    program.configureOutput({ writeOut: options.write, writeErr: options.write });
+  }
+  try {
+    await program.parseAsync(argv);
+    return program.exitCodeSlot.code;
+  } catch (error) {
+    // commander throws for --help and --version, which are successes.
+    if (error && error.code === 'commander.helpDisplayed') return ExitCode.OK;
+    if (error && error.code === 'commander.version') return ExitCode.OK;
+    if (error && error.code === 'commander.help') return ExitCode.OK;
+    if (error && typeof error.exitCode === 'number' && String(error.code || '').startsWith('commander.')) {
+      return error.exitCode;
+    }
+    return report(error);
+  }
+}
+
+/**
+ * Turn a thrown thing into a printed message and an exit code.
+ * @param {unknown} error
+ * @returns {number}
+ */
+export function report(error) {
+  if (error instanceof CliError) {
+    ui.error(error.message);
+    if (error.hint) ui.info(error.hint);
+    return error.exitCode;
+  }
+  if (error instanceof ApiError) {
+    ui.error(error.message);
+    const details = error.formatDetails();
+    if (details) ui.info(details);
+
+    // An ingest key on a playtest route is 403 `ingest_key_not_allowed`, which
+    // reads like a permissions problem and is not one: it is the wrong kind of
+    // credential entirely, and no amount of granting roles will fix it.
+    if (error.code === 'ingest_key_not_allowed') {
+      ui.info('That is a gt_live_ ingest key, which game clients use to send events.');
+      ui.info('This CLI needs a gt_cli_ token: run ravensight-playtest login.');
+      return ExitCode.AUTH;
+    }
+    if (error.status === 401 || error.status === 403) {
+      ui.info('Run ravensight-playtest login, or check the token scopes.');
+      return ExitCode.AUTH;
+    }
+    // A 404 under /api/v1/games/<gameId>/ is the server's way of saying "not
+    // yours, or not there", deliberately indistinguishable so an outsider
+    // cannot probe for a game's existence. That means the message alone can
+    // never tell a developer which of the two it was, so name both.
+    if (error.status === 404 && /\/api\/v1\/games\//.test(error.path || '')) {
+      ui.info('That game, job or run is not visible to this token.');
+      ui.info('Run ravensight-playtest check to confirm the game is linked, or log in again.');
+      return ExitCode.FAILURE;
+    }
+    return ExitCode.FAILURE;
+  }
+  ui.error(error && error.stack ? error.stack : String(error));
+  return ExitCode.FAILURE;
+}

package/src/commands/brief.js

@@ -0,0 +1,303 @@
+import { createInterface } from 'node:readline/promises';
+import { createContext } from '../api/index.js';
+import { ApiError } from '../api/errors.js';
+import { resolveGameId } from '../config.js';
+import { withAuthHandling } from '../auth/session.js';
+import { readJson } from '../fsutil.js';
+import { briefLink, openInBrowser } from '../dashboard.js';
+import { ui } from '../ui/index.js';
+import { CliError, ExitCode } from '../errors.js';
+
+/** The goals the server's expectations-brief schema accepts, in its own order. */
+export const GOALS = Object.freeze([
+  'find_bugs',
+  'onboarding',
+  'balance',
+  'level_flow',
+  'narrative',
+  'accessibility',
+  'performance'
+]);
+
+const DEFAULT_MODULES = ['game_profile', 'persona_playtest'];
+
+/**
+ * The four things a quick brief needs, which are exactly the four the server
+ * calls a complete brief: at least one goal, what success looks like, how the
+ * game is controlled, and where a persona starts.
+ *
+ * Duplicated from the server's `completenessFor` on purpose, so the CLI can
+ * tell a developer what is missing without a round trip. The server still
+ * decides: `POST /brief/check` records its own verdict, and `PUT /brief` with
+ * `status: 'complete'` validates against the schema.
+ *
+ * @param {Object} fields
+ * @returns {{complete: boolean, missing: string[]}}
+ */
+export function completenessFor(fields = {}) {
+  const buildNotes = (fields && fields.build_notes) || {};
+  const missing = [];
+  const filled = value => typeof value === 'string' && value.trim().length > 0;
+  if (!Array.isArray(fields.goals) || fields.goals.length < 1) missing.push('/goals');
+  if (!filled(fields.success_criteria)) missing.push('/success_criteria');
+  if (!filled(buildNotes.controls)) missing.push('/build_notes/controls');
+  if (!filled(buildNotes.how_to_start)) missing.push('/build_notes/how_to_start');
+  return { complete: missing.length === 0, missing };
+}
+
+/**
+ * Parse a goals answer: a comma separated list of names or numbers from the
+ * menu, in priority order. The order is the priority, which is one fewer
+ * question than asking for a number per goal and is what a developer means when
+ * they list them.
+ * @param {string} answer
+ * @returns {Array<{goal: string, priority: number}>}
+ */
+export function parseGoals(answer) {
+  const wanted = String(answer || '')
+    .split(',')
+    .map(part => part.trim().toLowerCase())
+    .filter(Boolean);
+  const goals = [];
+  for (const entry of wanted) {
+    const byIndex = Number.isInteger(Number(entry)) ? GOALS[Number(entry) - 1] : undefined;
+    const name = byIndex || (GOALS.includes(entry) ? entry : undefined);
+    if (!name || goals.some(goal => goal.goal === name)) continue;
+    goals.push({ goal: name, priority: Math.min(goals.length + 1, 5) });
+  }
+  return goals;
+}
+
+/** Print a brief the way a person reads one. */
+function showBrief(brief, rendered) {
+  ui.info(`Brief version ${brief.version}, ${brief.status}`);
+  const completeness = brief.completeness || completenessFor(brief.fields);
+  if (!completeness.complete) {
+    ui.warn(`Still missing: ${completeness.missing.join(', ')}`);
+  }
+  ui.blank();
+  ui.info(rendered || '');
+}
+
+/**
+ * A question asker over a pair of streams.
+ *
+ * One readline interface for the whole form, not one per question: Node's
+ * readline consumes everything already buffered on its input when it reads the
+ * first line, so a second interface over the same stdin loses whatever the
+ * first one buffered. That is also why `askQuickBrief` takes an `ask` function
+ * rather than building the interface itself, which is what makes the form
+ * testable without a terminal.
+ *
+ * @param {{input?: object, output?: object}} [io]
+ * @returns {{ask: (question: string) => Promise<string>, close: () => void}}
+ */
+export function createPrompter(io = {}) {
+  const rl = createInterface({
+    input: io.input || process.stdin,
+    output: io.output || process.stdout
+  });
+  return {
+    ask: question => rl.question(question),
+    close: () => rl.close()
+  };
+}
+
+/**
+ * Ask the four quick brief questions, seeded with whatever is already there so
+ * an edit is an edit and not a retype. An empty answer keeps the current value.
+ *
+ * @param {Object} current - the existing `fields`, or {}
+ * @param {{ask?: Function, input?: object, output?: object}} [io]
+ * @returns {Promise<Object>} the new `fields`
+ */
+export async function askQuickBrief(current = {}, io = {}) {
+  const prompter = io.ask ? { ask: io.ask, close: () => {} } : createPrompter(io);
+  const keep = (answer, existing) => (String(answer || '').trim() ? String(answer).trim() : existing);
+
+  try {
+    ui.info('Goals, most important first. Pick from:');
+    GOALS.forEach((goal, index) => ui.info(`  ${index + 1}. ${goal}`));
+    const currentGoals = Array.isArray(current.goals) ? current.goals : [];
+    const goalsAnswer = await prompter.ask(
+      `Goals${currentGoals.length ? ` [${currentGoals.map(g => g.goal).join(',')}]` : ''}: `
+    );
+    const goals = String(goalsAnswer || '').trim() ? parseGoals(goalsAnswer) : currentGoals;
+
+    const success = keep(
+      await prompter.ask(`What does success look like?${current.success_criteria ? ' [keep]' : ''} `),
+      current.success_criteria || ''
+    );
+
+    const buildNotes = current.build_notes || {};
+    const controls = keep(
+      await prompter.ask(`How is it controlled?${buildNotes.controls ? ' [keep]' : ''} `),
+      buildNotes.controls || ''
+    );
+    const howToStart = keep(
+      await prompter.ask(`Where does a player start?${buildNotes.how_to_start ? ' [keep]' : ''} `),
+      buildNotes.how_to_start || ''
+    );
+
+    return {
+      ...current,
+      goals,
+      success_criteria: success,
+      build_notes: { ...buildNotes, controls, how_to_start: howToStart }
+    };
+  } finally {
+    prompter.close();
+  }
+}
+
+/**
+ * Save a brief, handling a stale parent version.
+ *
+ * Brief versions are immutable and every save writes n+1 against the version it
+ * was based on. A 409 `stale_version` means somebody else (usually the same
+ * developer, in the dashboard) saved in between. The answer carries
+ * `current_version`, so the fix is to say what happened and retry against that
+ * version rather than to silently overwrite their edit.
+ *
+ * @param {Object} options
+ * @returns {Promise<Object>} `{ brief, rendered }`
+ */
+export async function saveBrief({ api, gameId, fields, status, parentVersion, onStale }) {
+  try {
+    return await api.brief.put(gameId, { fields, status, parentVersion });
+  } catch (error) {
+    if (!(error instanceof ApiError) || error.code !== 'stale_version') throw error;
+    const current = error.body && error.body.current_version;
+    if (onStale) {
+      const retry = await onStale(current);
+      if (!retry) throw new CliError('The brief changed while you were editing it.', 1, {
+        hint: 'Run brief again to start from the current version.'
+      });
+    }
+    return api.brief.put(gameId, { fields, status, parentVersion: current });
+  }
+}
+
+/**
+ * `ravensight-playtest brief`
+ *
+ * Show, edit or open the expectations brief. Editing is the default, because a
+ * job on a game with no complete brief is refused with 409 `brief_required` and
+ * this is the command that fixes that.
+ *
+ * @param {Object} [flags]
+ * @param {Object} [deps]
+ * @returns {Promise<number>}
+ */
+export async function brief(flags = {}, deps = {}) {
+  const context = deps.context || await createContext({
+    apiUrl: flags.apiUrl,
+    repoRoot: flags.repoRoot,
+    requireAuth: true
+  });
+  return withAuthHandling(context, () => editBrief(context, flags, deps));
+}
+
+async function editBrief(context, flags, deps) {
+  const gameId = resolveGameId(flags, context.config);
+  const api = context.api;
+
+  const current = await api.brief.get(gameId);
+
+  if (flags.open) {
+    const link = briefLink(gameId, context.apiUrl);
+    ui.info(link);
+    await openInBrowser(link, deps);
+    return ExitCode.OK;
+  }
+
+  if (flags.show) {
+    if (!current.brief) {
+      if (flags.json) ui.json({ brief: null });
+      else ui.info('No brief yet. Run brief with no flags to write one.');
+      return ExitCode.OK;
+    }
+    if (flags.json) ui.json(current);
+    else showBrief(current.brief, current.rendered);
+    return ExitCode.OK;
+  }
+
+  const existingFields = current.brief ? current.brief.fields : {};
+  const parentVersion = current.brief ? current.brief.version : null;
+
+  let fields;
+  if (flags.from) {
+    const loaded = await readJson(flags.from, null);
+    if (!loaded || typeof loaded !== 'object') {
+      throw new CliError(`${flags.from} does not contain a brief fields object.`);
+    }
+    fields = loaded.fields && typeof loaded.fields === 'object' ? loaded.fields : loaded;
+  } else {
+    fields = await askQuickBrief(existingFields, deps);
+  }
+
+  const local = completenessFor(fields);
+  const status = flags.draft ? 'draft' : local.complete ? 'complete' : 'draft';
+
+  const saved = await saveBrief({
+    api,
+    gameId,
+    fields,
+    status,
+    parentVersion,
+    onStale: async version => {
+      ui.warn(`The brief moved to version ${version} while you were editing.`);
+      return ui.confirm('Save on top of that version?', { yes: flags.yes });
+    }
+  });
+
+  // Tell the server what the CLI thinks completeness is. The server keeps its
+  // own verdict; this is the signal spec 18 uses to see where developers get
+  // stuck filling the form in.
+  try {
+    await api.brief.check(gameId, completenessFor(saved.brief.fields));
+  } catch {
+    // A refused check does not undo a saved brief, and the brief is the point.
+  }
+
+  const estimateModules = flags.modules || (context.config && context.config.modules) || DEFAULT_MODULES;
+  const estimatePersonas = flags.personas || (context.config && context.config.personas) || [];
+  let estimate = null;
+  try {
+    estimate = await api.brief.estimate(gameId, { modules: estimateModules, personas: estimatePersonas });
+  } catch (error) {
+    if (!(error instanceof ApiError)) throw error;
+  }
+
+  if (flags.json) {
+    ui.json({ ...saved, estimate });
+    return ExitCode.OK;
+  }
+
+  ui.ok(`Saved brief version ${saved.brief.version} (${saved.brief.status}).`);
+  const after = saved.brief.completeness || completenessFor(saved.brief.fields);
+  if (!after.complete) {
+    ui.warn(`Still missing: ${after.missing.join(', ')}`);
+    ui.info('A persona playtest job needs a complete brief, so fill those in before you run one.');
+  }
+
+  if (estimate) {
+    ui.blank();
+    ui.info(`A ${estimateModules.join(' plus ')} job would cost ${ui.money(estimate.estimate_cents)}.`);
+    if (estimate.wall_warning) ui.warn(estimate.wall_warning);
+    ui.table(estimate.breakdown, [
+      { key: 'unit', label: 'UNIT' },
+      { key: 'count', label: 'COUNT', align: 'right' },
+      { key: 'unit_cents', label: 'CENTS EACH', align: 'right' }
+    ]);
+    if (estimate.balance_cents === null || estimate.balance_cents === undefined) {
+      ui.info('Your role cannot see the balance, so ask an owner whether it covers that.');
+    } else if (estimate.ok) {
+      ui.ok(`Available balance ${ui.money(estimate.balance_cents)}, which covers it.`);
+    } else {
+      ui.warn(`Available balance ${ui.money(estimate.balance_cents)}, which does not cover it.`);
+      ui.info(`Top up at ${estimate.topup_url}`);
+    }
+  }
+  return ExitCode.OK;
+}