ravensight-playtest 0.1.0

package/src/commands/init.js

@@ -0,0 +1,120 @@
+import { appendFile, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { createContext } from '../api/index.js';
+import { defaultConfig, loadConfig, saveConfig } from '../config.js';
+import { withAuthHandling } from '../auth/session.js';
+import { paths } from '../paths.js';
+import { ui } from '../ui/index.js';
+import { CliError, ExitCode } from '../errors.js';
+
+const GITIGNORE_LINE = '.ravensight/jobs/';
+
+/**
+ * Add `.ravensight/jobs/` to the repo's .gitignore if it has one and does not
+ * already ignore it.
+ *
+ * Job directories hold screenshots and a video, which nobody wants in their
+ * history. Only appended when a .gitignore already exists: creating one in
+ * somebody else's repo is a bigger decision than this command is making.
+ *
+ * @param {string} repoRoot
+ * @returns {Promise<'added'|'present'|'absent'>}
+ */
+export async function ensureGitignore(repoRoot) {
+  const file = join(repoRoot, '.gitignore');
+  let text;
+  try {
+    text = await readFile(file, 'utf8');
+  } catch (error) {
+    if (error.code === 'ENOENT') return 'absent';
+    throw error;
+  }
+  if (text.split('\n').some(line => line.trim() === GITIGNORE_LINE)) return 'present';
+  await appendFile(file, `${text.endsWith('\n') ? '' : '\n'}${GITIGNORE_LINE}\n`);
+  return 'added';
+}
+
+/**
+ * `ravensight-playtest init --game <gameId>`
+ *
+ * Link this repo to a Ravensight game.
+ *
+ * The game is checked against `whoami` before anything is written, because the
+ * alternative is a config that looks right and fails on the first job with a
+ * 404 that reads like the game does not exist. The token's own game list is the
+ * authority: an unapproved game is invisible to it, by design.
+ *
+ * @param {{game?: string, apiUrl?: string, repoRoot?: string, force?: boolean, json?: boolean}} flags
+ * @param {Object} [deps]
+ * @returns {Promise<number>}
+ */
+export async function init(flags = {}, deps = {}) {
+  const repoRoot = flags.repoRoot || process.cwd();
+  const context = deps.context || await createContext({
+    apiUrl: flags.apiUrl,
+    repoRoot,
+    requireAuth: true
+  });
+  // Every API call in this command goes through the one 401 handler, so a
+  // refused credential is cleared and explained here the same way it is
+  // everywhere else.
+  return withAuthHandling(context, () => linkRepo(context, flags, repoRoot));
+}
+
+async function linkRepo(context, flags, repoRoot) {
+  const whoami = await context.api.cli.whoami();
+
+  const games = whoami.games || [];
+  let gameId = flags.game;
+
+  if (!gameId) {
+    if (games.length === 1) {
+      gameId = games[0].gameId;
+      ui.info(`Only one game is visible to this token, so using ${gameId}.`);
+    } else {
+      ui.info('Pass --game with one of these:');
+      ui.table(games, [
+        { key: 'gameId', label: 'GAME ID' },
+        { key: 'name', label: 'NAME' }
+      ]);
+      throw new CliError('No game id given.', 1, { hint: 'ravensight-playtest init --game <gameId>' });
+    }
+  }
+
+  if (!games.some(game => game.gameId === gameId)) {
+    throw new CliError(
+      `${gameId} is not a game this token can see.`,
+      1,
+      { hint: 'Approve it during login, or run login again and pick it.' }
+    );
+  }
+
+  const existing = await loadConfig({ repoRoot });
+  if (existing && existing.game_id && existing.game_id !== gameId && !flags.force) {
+    throw new CliError(
+      `This repo is already linked to ${existing.game_id}.`,
+      1,
+      { hint: 'Pass --force to relink it.' }
+    );
+  }
+
+  const config = await saveConfig(
+    { ...(existing || {}), ...defaultConfig(gameId), api_url: context.apiUrl },
+    { repoRoot }
+  );
+  const gitignore = await ensureGitignore(repoRoot);
+
+  if (flags.json) {
+    ui.json({ ok: true, config_file: paths.configFile({ repoRoot }), config, gitignore });
+    return ExitCode.OK;
+  }
+
+  const name = (games.find(game => game.gameId === gameId) || {}).name || gameId;
+  ui.ok(`Linked this repo to ${name} (${gameId}).`);
+  ui.info(`Wrote ${paths.configFile({ repoRoot })}`);
+  if (gitignore === 'added') ui.info(`Added ${GITIGNORE_LINE} to .gitignore`);
+  if (gitignore === 'absent') ui.warn(`No .gitignore here. Add ${GITIGNORE_LINE} to whatever ignores build output.`);
+  ui.blank();
+  ui.info('Next: ravensight-playtest brief');
+  return ExitCode.OK;
+}

package/src/commands/login.js

@@ -0,0 +1,90 @@
+import { createClient } from '../api/client.js';
+import { resolveApiUrl, apiHost } from '../paths.js';
+import { setStoredToken, backendName } from '../auth/keychain.js';
+import { pollForToken } from '../auth/deviceCode.js';
+import { CLI_VERSION, CLIENT_NAME } from '../version.js';
+import { ui } from '../ui/index.js';
+import { openInBrowser } from '../dashboard.js';
+import { ExitCode } from '../errors.js';
+
+/**
+ * `ravensight-playtest login`
+ *
+ * The device code flow, whole: start one, show the user code, wait for the
+ * approval, store the token.
+ *
+ * No Anthropic key is involved at any point, and none is ever stored: model
+ * calls go through the Ravensight proxy under this same token, so the developer
+ * machine holds one credential and it is revocable from the dashboard.
+ *
+ * @param {{apiUrl?: string, json?: boolean, noBrowser?: boolean}} [flags]
+ * @param {Object} [deps] - test seams
+ * @returns {Promise<number>} exit code
+ */
+export async function login(flags = {}, deps = {}) {
+  const apiUrl = flags.apiUrl || resolveApiUrl();
+  const host = apiHost(apiUrl);
+  const api = deps.api || createClient({ apiUrl, ...(deps.clientOptions || {}) });
+
+  const started = await api.cli.deviceCode({ client: CLIENT_NAME, clientVersion: CLI_VERSION });
+
+  if (flags.json) {
+    ui.json({
+      user_code: started.user_code,
+      verification_uri: started.verification_uri,
+      expires_in: started.expires_in
+    });
+  } else {
+    ui.blank();
+    ui.info(`Open ${started.verification_uri}`);
+    ui.info(`and enter the code: ${started.user_code}`);
+    ui.blank();
+    if (!flags.noBrowser) await openInBrowser(started.verification_uri, deps);
+  }
+
+  const spin = flags.json ? null : ui.spinner('Waiting for approval');
+  let minted;
+  try {
+    minted = await pollForToken({
+      api,
+      deviceCode: started.device_code,
+      intervalSeconds: started.interval,
+      expiresInSeconds: started.expires_in,
+      sleep: deps.sleep,
+      now: deps.now
+    });
+  } finally {
+    if (spin) spin.stop();
+  }
+
+  const { backend } = await setStoredToken(host, minted.token);
+
+  if (flags.json) {
+    ui.json({ ok: true, host, backend, scopes: minted.scopes, games: minted.games });
+    return ExitCode.OK;
+  }
+
+  ui.ok(`Logged in to ${host}.`);
+  ui.info(`Token stored in the ${backend === 'keychain' ? 'OS keychain' : 'credentials file'}.`);
+  if (backend === 'file') {
+    ui.warn('No OS keychain was available, so the token is in a 0600 file under your home directory.');
+  }
+  if (minted.games && minted.games.length > 0) {
+    ui.blank();
+    ui.info('Games this token can see:');
+    ui.table(minted.games, [
+      { key: 'gameId', label: 'GAME ID' },
+      { key: 'name', label: 'NAME' }
+    ]);
+  } else {
+    ui.info('This token is scoped to every game you can see.');
+  }
+  ui.blank();
+  ui.info('Next: ravensight-playtest init --game <gameId>');
+  return ExitCode.OK;
+}
+
+/** What `check` reports about the credential store, without doing a login. */
+export async function credentialBackend() {
+  return backendName();
+}

package/src/commands/logout.js

@@ -0,0 +1,70 @@
+import { createClient } from '../api/client.js';
+import { resolveApiUrl } from '../paths.js';
+import { resolveToken } from '../auth/session.js';
+import { deleteStoredToken } from '../auth/keychain.js';
+import { ApiError } from '../api/errors.js';
+import { ui } from '../ui/index.js';
+import { ExitCode } from '../errors.js';
+
+/**
+ * `ravensight-playtest logout`
+ *
+ * Revoke the token server side, then forget it locally, in that order. A local
+ * delete that ran first would leave a live credential on the server with
+ * nothing left to revoke it with.
+ *
+ * A 401 on the revoke is a success, not a failure: the token is already gone.
+ * Any other refusal still clears the local copy and says so, because the
+ * alternative is a developer stuck holding a credential they asked to be rid of.
+ *
+ * A token that came from `RAVENSIGHT_TOKEN` is not revoked: an env var is the
+ * caller's to manage, and revoking a shared CI secret because someone ran
+ * logout locally would break every other job using it.
+ *
+ * @param {{apiUrl?: string, json?: boolean}} [flags]
+ * @param {Object} [deps]
+ * @returns {Promise<number>}
+ */
+export async function logout(flags = {}, deps = {}) {
+  const apiUrl = flags.apiUrl || resolveApiUrl();
+  const { token, source, host } = await resolveToken({ apiUrl });
+
+  if (!token) {
+    if (flags.json) ui.json({ ok: true, host, revoked: false, cleared: false });
+    else ui.info(`Not logged in to ${host}.`);
+    return ExitCode.OK;
+  }
+
+  if (source === 'env') {
+    if (flags.json) ui.json({ ok: true, host, revoked: false, cleared: false, source });
+    else {
+      ui.warn('That credential comes from RAVENSIGHT_TOKEN, so logout leaves it alone.');
+      ui.info('Unset the variable, or revoke the token from the dashboard settings page.');
+    }
+    return ExitCode.OK;
+  }
+
+  const api = deps.api || createClient({ apiUrl, token });
+  let revoked = false;
+  let detail = null;
+  try {
+    await api.cli.revoke();
+    revoked = true;
+  } catch (error) {
+    if (error instanceof ApiError && error.status === 401) revoked = true;
+    else detail = error instanceof ApiError ? error.message : String(error && error.message);
+  }
+
+  const cleared = await deleteStoredToken(host);
+
+  if (flags.json) {
+    ui.json({ ok: true, host, revoked, cleared, detail });
+    return ExitCode.OK;
+  }
+  if (revoked) ui.ok(`Logged out of ${host}.`);
+  else {
+    ui.warn(`Cleared the local token, but the server did not confirm the revoke: ${detail}`);
+    ui.info('Revoke it from the dashboard settings page to be sure.');
+  }
+  return ExitCode.OK;
+}

package/src/commands/open.js

@@ -0,0 +1,125 @@
+import { createContext } from '../api/index.js';
+import { resolveGameId } from '../config.js';
+import { withAuthHandling } from '../auth/session.js';
+import { readState } from '../state/index.js';
+import { gameLink, jobLink, reviewLink, openInBrowser } from '../dashboard.js';
+import { ui } from '../ui/index.js';
+import { ExitCode } from '../errors.js';
+
+/**
+ * Resolve the game id for a link command: the flag, the job's own journal (so
+ * `open <jobId>` works from any directory that ran it), then the repo config.
+ * @param {string|undefined} jobId
+ * @param {Object} flags
+ * @param {Object} context
+ * @returns {Promise<string>}
+ */
+async function gameFor(jobId, flags, context) {
+  if (flags.game) return flags.game;
+  if (jobId) {
+    const state = await readState(jobId, { repoRoot: context.repoRoot });
+    if (state && state.game_id) return state.game_id;
+  }
+  return resolveGameId(flags, context.config);
+}
+
+/**
+ * `ravensight-playtest open [jobId]`
+ *
+ * The dashboard page for a job, or for the game's playtest surface.
+ *
+ * The URL is always printed as well as opened. A headless box cannot open
+ * anything and a printed link costs nothing, so there is no case where this
+ * command leaves someone with no way to get there.
+ *
+ * No credential is needed: this builds a URL, it does not read anything.
+ *
+ * @param {string|undefined} jobId
+ * @param {Object} [flags]
+ * @param {Object} [deps]
+ * @returns {Promise<number>}
+ */
+export async function open(jobId, flags = {}, deps = {}) {
+  const context = deps.context || await createContext({
+    apiUrl: flags.apiUrl,
+    repoRoot: flags.repoRoot
+  });
+  const gameId = await gameFor(jobId, flags, context);
+  const link = jobId ? jobLink(gameId, jobId, context.apiUrl) : gameLink(gameId, context.apiUrl);
+
+  if (flags.json) {
+    ui.json({ url: link });
+    return ExitCode.OK;
+  }
+  ui.info(link);
+  await openInBrowser(link, deps);
+  return ExitCode.OK;
+}
+
+/**
+ * `ravensight-playtest review <jobId>`
+ *
+ * Open the post job review form, and say what is waiting to be reviewed.
+ *
+ * The review is not a formality: the marks it collects are what
+ * `finding precision` is measured from, and a job's `review_pending` flag stays
+ * true until this reviewer files one. So this command reads the job first and
+ * prints the finding counts, which is the context somebody needs before they
+ * start marking.
+ *
+ * @param {string|undefined} jobId
+ * @param {Object} [flags]
+ * @param {Object} [deps]
+ * @returns {Promise<number>}
+ */
+export async function review(jobId, flags = {}, deps = {}) {
+  const context = deps.context || await createContext({
+    apiUrl: flags.apiUrl,
+    repoRoot: flags.repoRoot,
+    requireAuth: true
+  });
+  return withAuthHandling(context, () => reviewWith(context, jobId, flags, deps));
+}
+
+async function reviewWith(context, jobId, flags, deps) {
+  const gameId = await gameFor(jobId, flags, context);
+
+  if (!jobId) {
+    const summary = await context.api.jobs.summary(gameId);
+    const waiting = summary.review_pending || {};
+    if (flags.json) {
+      ui.json({ summary });
+      return ExitCode.OK;
+    }
+    if (waiting.job_id) {
+      ui.info(`${waiting.count} jobs are waiting for your review, starting with ${waiting.job_id}.`);
+      ui.info(reviewLink(gameId, waiting.job_id, context.apiUrl));
+    } else {
+      ui.info('Nothing is waiting for your review.');
+    }
+    return ExitCode.OK;
+  }
+
+  const { job } = await context.api.jobs.get(gameId, jobId);
+  const link = reviewLink(gameId, jobId, context.apiUrl);
+
+  if (flags.json) {
+    ui.json({ job, url: link });
+    return ExitCode.OK;
+  }
+
+  ui.info(`Job ${jobId} is ${job.state}, with ${job.findings_count} findings.`);
+  if (job.severity_counts) {
+    ui.table([job.severity_counts], [
+      { key: 'blocker', label: 'BLOCKER', align: 'right' },
+      { key: 'major', label: 'MAJOR', align: 'right' },
+      { key: 'minor', label: 'MINOR', align: 'right' },
+      { key: 'cosmetic', label: 'COSMETIC', align: 'right' },
+      { key: 'praise', label: 'PRAISE', align: 'right' }
+    ]);
+  }
+  ui.blank();
+  ui.info(link);
+  await openInBrowser(link, deps);
+  return ExitCode.OK;
+}

package/src/commands/profile.js

@@ -0,0 +1,262 @@
+import { randomUUID } from 'node:crypto';
+import { mkdir } from 'node:fs/promises';
+import { optionsFrom } from '../run/args.js';
+import { getDeps } from '../run/deps.js';
+import EXIT from '../run/exit.js';
+import { createHeartbeat } from '../run/heartbeat.js';
+import { createModelClient, ModelUnavailableError, ProxyError } from '../run/model.js';
+import { jobDir } from '../run/paths.js';
+import { runGameProfile, writeCapabilityReport } from '../run/profile.js';
+import * as stateFile from '../run/state.js';
+import { createUsageLedger, writeUsageFile } from '../run/usage.js';
+import { formatCents, resolveSetup } from './run.js';
+
+/**
+ * `ravensight-playtest profile`: read the repository, answer what this product
+ * can and cannot do for this game, and post the capability report.
+ *
+ * A profile job is `modules: ['game_profile']` and nothing else, which matters
+ * twice: it is the one job shape that does not need a complete expectations
+ * brief (profiling is what produces the facts a brief gets written against),
+ * and it buys exactly one run, whose module is `game_profile`, which is the run
+ * the `game_profile.*` steps are allowed to spend from.
+ *
+ * The source never leaves the machine. The capability report carries
+ * repo-relative paths, the commit and the dirty flag, and nothing else from the
+ * repository unless the developer opts in per upload category.
+ */
+
+/**
+ * @param {Object} flags what cli-core's commander program hands over
+ * @param {Object} [injected] test seam
+ * @returns {Promise<number>} process exit code
+ */
+export async function profileCommand(flags = {}, injected = {}) {
+  const deps = injected.deps || (await getDeps());
+  const log = injected.log || (deps.ui && deps.ui.info ? message => deps.ui.info(message) : message => console.log(message));
+  try {
+    return await profile(flags, injected, deps, log);
+  } catch (error) {
+    const code = exitCodeFor(error);
+    if (code === EXIT.FAILED) throw error;
+    log(String(error && error.message ? error.message : error));
+    return code;
+  }
+}
+
+/**
+ * @param {Object} flags
+ * @param {Object} injected
+ * @param {Object} deps
+ * @param {(message: string) => void} log
+ * @returns {Promise<number>}
+ */
+async function profile(flags, injected, deps, log) {
+  const { options, unknown } = optionsFrom(flags);
+  if (unknown.length > 0) {
+    log(`I do not know these options: ${unknown.join(', ')}.`);
+    return EXIT.ENVIRONMENT;
+  }
+
+  const setup = await resolveSetup(deps, options, log);
+  if (setup.code !== undefined) return setup.code;
+  const { context, api, gameId, apiUrl, repoRoot, cliVersion } = setup;
+
+  const modules = ['game_profile'];
+  const pack = await deps.packs.get({ api, gameId, modules });
+  // A profile job is the one shape that does not need a brief, so a missing one
+  // is not an error here. It is still read when there is one: a brief that
+  // already states the audience and the core loop is context the profile should
+  // not have to guess at.
+  const brief = await deps.brief.get({ api, gameId }).catch(() => null);
+  const skill = (pack.skills || []).find(entry => entry.module === 'game_profile');
+  if (!skill) {
+    log('The content pack has no game-profile skill. Run "ravensight-playtest check" and try again.');
+    return EXIT.ENVIRONMENT;
+  }
+
+  const estimate = await api.jobs.estimate(gameId, { modules, personas: [] });
+  log(`Profiling this repository: ${formatCents(estimate.estimate_cents)}. Balance: ${formatCents(estimate.balance_cents)}.`);
+  if (estimate.ok === false) {
+    log(`That is more than the balance covers. Top up at ${estimate.topup_url || 'ravensight.io'} and try again.`);
+    return EXIT.ENVIRONMENT;
+  }
+  // A profile job carries no personas, so this never fires today, but the
+  // estimate is answered by the same route as `run` and should read the same
+  // way if that ever changes.
+  if (estimate.wall_warning) log(estimate.wall_warning);
+  const confirm = injected.confirm || (deps.ui && deps.ui.confirm);
+  if (!options.yes && confirm) {
+    const go = await confirm(`Profile this repository for ${formatCents(estimate.estimate_cents)}?`, { yes: options.yes });
+    if (!go) {
+      log('Nothing was charged.');
+      return EXIT.CANCELED;
+    }
+  }
+
+  const idempotencyKey = options.idempotencyKey || randomUUID();
+  const registered = await api.jobs.register(gameId, {
+    modules,
+    personas: [],
+    driver: options.driver || (context.config && context.config.driver) || 'playwright_web',
+    cli_version: cliVersion,
+    confirm_price_cents: estimate.estimate_cents,
+    build: { kind: 'repo', ref: repoRoot },
+    repo: { commit: (context.config && context.config.commit) || '', dirty: Boolean(context.config && context.config.dirty) },
+    pack_versions: { pack: pack.pack_version }
+  }, { idempotencyKey });
+
+  const jobId = registered.job_id;
+  const profileRun = (registered.runs || []).find(entry => entry.module === 'game_profile');
+  if (!profileRun) {
+    log('The server registered the job without a game_profile run, so there is nothing to spend a model turn from.');
+    return EXIT.FAILED;
+  }
+
+  const directory = jobDir(repoRoot, jobId);
+  await mkdir(directory, { recursive: true });
+  const journal = stateFile.newState({
+    jobId,
+    gameId,
+    idempotencyKey,
+    cliVersion,
+    packVersion: pack.pack_version,
+    modules,
+    driver: 'none',
+    target: repoRoot,
+    priceCents: registered.price && registered.price.price_cents
+  });
+  journal.runs[profileRun.run_id] = stateFile.newRunEntry({ runId: profileRun.run_id, module: 'game_profile', persona: null });
+  await stateFile.save(repoRoot, journal);
+
+  const createClient = injected.createClient || createModelClient;
+  const client = createClient({ apiUrl, token: injected.modelToken || api.token });
+  const ledger = createUsageLedger();
+  const heartbeat = createHeartbeat({
+    api,
+    gameId,
+    jobId,
+    runId: profileRun.run_id,
+    onCancel: () => log('the job was cancelled; stopping.'),
+    onUsage: usage => ledger.recordServerUsage(usage),
+    onError: () => {}
+  });
+
+  try {
+    await api.runs.transition(gameId, jobId, profileRun.run_id, 'launching', { reason: '' });
+    await api.runs.transition(gameId, jobId, profileRun.run_id, 'playing', { reason: '' });
+    heartbeat.start();
+
+    const { report, turns } = await runGameProfile({
+      client,
+      jobId,
+      runId: profileRun.run_id,
+      repoRoot,
+      skill: skill.content,
+      schemas: pack.schemas || [],
+      codeBrief: pack.code_brief || null,
+      brief,
+      engine: pack.engine || null,
+      commit: (context.config && context.config.commit) || null,
+      dirty: Boolean(context.config && context.config.dirty),
+      ledger,
+      log,
+      onProgress: progress => {
+        if (options.verbose) log(`  ${progress.tool} ${progress.target || ''}`);
+      }
+    });
+
+    // One last beat before the ledger is written: it is what carries the
+    // authoritative spend back, and prices are server side only.
+    await heartbeat.beat();
+    heartbeat.stop();
+    await api.runs.transition(gameId, jobId, profileRun.run_id, 'reporting', { reason: '' });
+    const target = await writeCapabilityReport(directory, report);
+    await writeUsageFile(directory, ledger);
+
+    const accepted = await api.jobs.capabilityReport(gameId, jobId, { report });
+    // `uploading` first. The server's table only allows `succeeded` from
+    // `uploading`, so completing straight out of `reporting` is a 409
+    // `invalid_transition`: the capability report has just been sent, which is
+    // this module's upload, so the state is true as well as required.
+    await api.runs.transition(gameId, jobId, profileRun.run_id, 'uploading', { reason: '' });
+    await api.runs.complete(gameId, jobId, profileRun.run_id, {
+      state: 'succeeded',
+      actions_taken: turns,
+      quit_reason: 'goal_reached'
+    });
+    await api.jobs.finish(gameId, jobId, {});
+    journal.finished = true;
+    journal.runs[profileRun.run_id].completed = true;
+    journal.runs[profileRun.run_id].state = 'succeeded';
+    await stateFile.save(repoRoot, journal);
+
+    log(`capability report: ${target}`);
+    summarise(report, log);
+    if (accepted && accepted.capability_report && accepted.capability_report.accepted === false) {
+      log('The server stored the report but has not accepted it yet. Confirm or correct it in the dashboard before running personas.');
+    }
+    return EXIT.OK;
+  } catch (error) {
+    heartbeat.stop();
+    const code = exitCodeFor(error);
+    await safeFail({ api, gameId, jobId, runId: profileRun.run_id, error, log });
+    log(`profile failed: ${String(error && error.message)}`);
+    return code;
+  }
+}
+
+/**
+ * Mark the run failed and settle the job, so a profile that dies does not leave
+ * a charged job open and does not wait for the 24 hour stall sweep to give the
+ * money back.
+ */
+async function safeFail({ api, gameId, jobId, runId, error, log }) {
+  try {
+    await api.runs.complete(gameId, jobId, runId, {
+      state: 'failed',
+      reason: String(error && error.message).slice(0, 400),
+      quit_reason: 'error'
+    });
+  } catch (completeError) {
+    log(`the run could not be marked failed: ${String(completeError && completeError.message)}`);
+  }
+  try {
+    await api.jobs.finish(gameId, jobId, { reason: 'profile failed' });
+  } catch (finishError) {
+    log(`the job could not be settled now; the hourly sweep will settle it: ${String(finishError && finishError.message)}`);
+  }
+}
+
+/**
+ * The part a developer reads: what is eligible, what is missing, and what the
+ * profile wants from them.
+ */
+function summarise(report, log) {
+  const eligible = (report.eligibility || []).filter(row => row.eligible);
+  const blocked = (report.eligibility || []).filter(row => !row.eligible);
+  log(`engine: ${report.game && report.game.engine ? report.game.engine : 'unknown'}`);
+  log(`eligible: ${eligible.length > 0 ? eligible.map(row => `${row.module}/${row.driver}`).join(', ') : 'nothing yet'}`);
+  for (const row of blocked) log(`  not eligible: ${row.module}/${row.driver}: ${row.reason || 'no reason given'}`);
+  for (const ask of report.asks_for_customer || []) log(`  asks: ${typeof ask === 'string' ? ask : ask.question || JSON.stringify(ask)}`);
+  for (const warning of report.warnings || []) log(`  warning: ${typeof warning === 'string' ? warning : warning.message || JSON.stringify(warning)}`);
+}
+
+/**
+ * @param {any} error
+ * @returns {number}
+ */
+export function exitCodeFor(error) {
+  if (error instanceof ModelUnavailableError) return EXIT.MODEL;
+  if (error instanceof ProxyError) {
+    if (error.isBudget) return EXIT.BUDGET;
+    if (error.isClosed) return EXIT.CANCELED;
+    if (error.isAuth) return EXIT.AUTH;
+    // The kill switch, or a server with no platform key: a model-access
+    // failure, which is what 5 means.
+    if (error.status === 503) return EXIT.MODEL;
+  }
+  return EXIT.FAILED;
+}
+
+export default profileCommand;