ravensight-playtest 0.1.0

package/src/commands/check.js

@@ -0,0 +1,318 @@
+import { createClient } from '../api/client.js';
+import { ApiError } from '../api/errors.js';
+import { resolveApiUrl, paths } from '../paths.js';
+import { resolveToken, looksLikeIngestKey } from '../auth/session.js';
+import { backendName } from '../auth/keychain.js';
+import { loadConfig } from '../config.js';
+import { packs } from '../packs/index.js';
+import { detectFfmpeg, freeBytes, recommendConcurrency } from '../detect.js';
+import { inspectGodot } from '../godot.js';
+import { CLI_VERSION, compareVersions } from '../version.js';
+import { ui } from '../ui/index.js';
+import { ExitCode } from '../errors.js';
+
+export const NODE_MIN_MAJOR = 22;
+const DISK_WARN_BYTES = 2 * 1024 * 1024 * 1024;
+
+const row = (name, status, detail, fix = null) => ({ name, status, detail, fix });
+
+/** "1 persona", "3 personas". A doctor that cannot count reads like a draft. */
+const plural = (count, noun) => `${count} ${noun}${count === 1 ? '' : 's'}`;
+
+/**
+ * Every environment check, as data.
+ *
+ * Returns rows rather than printing, so `--json` and the human table are the
+ * same check run two ways, and so the whole thing is testable against an
+ * in process server with no terminal involved.
+ *
+ * Status meanings are load bearing. `fail` is "this command cannot work", and
+ * it is what sets exit code 3. `warn` is "something optional is missing", and
+ * CI must not fail on it: ffmpeg and Godot are genuinely optional, and a run
+ * that never touches them should not be blocked because they are absent.
+ *
+ * @param {Object} [flags]
+ * @param {string} [flags.apiUrl]
+ * @param {string} [flags.game]
+ * @param {string[]} [flags.modules]
+ * @param {string[]} [flags.personas]
+ * @param {string} [flags.repoRoot]
+ * @param {Object} [deps]
+ * @returns {Promise<{rows: Array, ok: boolean}>}
+ */
+export async function runChecks(flags = {}, deps = {}) {
+  const apiUrl = flags.apiUrl || resolveApiUrl();
+  const rows = [];
+
+  /* ------------------------------------------------------------- runtime */
+
+  const nodeMajor = Number(process.versions.node.split('.')[0]);
+  rows.push(row(
+    'node',
+    nodeMajor >= NODE_MIN_MAJOR ? 'ok' : 'fail',
+    `v${process.versions.node}`,
+    `install Node ${NODE_MIN_MAJOR} or newer`
+  ));
+
+  /* ----------------------------------------------------------- the server */
+
+  const api = deps.api || createClient({ apiUrl, token: null });
+  let version = null;
+  try {
+    version = await api.cli.version();
+    rows.push(row('api reachable', 'ok', `${apiUrl} (schema ${version.schema_version})`));
+  } catch (error) {
+    rows.push(row(
+      'api reachable',
+      'fail',
+      error instanceof ApiError ? error.message : String(error && error.message),
+      `check RAVENSIGHT_API_URL, currently ${apiUrl}`
+    ));
+  }
+
+  if (version) {
+    const tooOld = compareVersions(CLI_VERSION, version.min_supported) < 0;
+    const behind = compareVersions(CLI_VERSION, version.latest) < 0;
+    rows.push(row(
+      'cli version',
+      tooOld ? 'fail' : behind ? 'warn' : 'ok',
+      `${CLI_VERSION} (server wants at least ${version.min_supported}, latest ${version.latest})`,
+      tooOld || behind ? 'npm install -g ravensight-playtest@latest' : null
+    ));
+  }
+
+  /* ------------------------------------------------------- the credential */
+
+  const { token, source, host } = await resolveToken({ apiUrl });
+  // `source` is where the token actually came from; `backend` is where this
+  // machine would put one. They differ when a token was written to the file
+  // while the keychain was unavailable, and the row reports the real one rather
+  // than the one that sounds better.
+  const backend = await (deps.backendName || backendName)();
+  const storeDetail = () => {
+    if (source === 'env') return 'RAVENSIGHT_TOKEN from the environment';
+    if (source === 'file') return `${paths.credentialsFile()} (a 0600 file, not a keychain)`;
+    if (source === 'keychain') return 'OS keychain';
+    return backend === 'keychain'
+      ? 'OS keychain, with nothing in it for this host yet'
+      : `${paths.credentialsFile()} (no OS keychain found)`;
+  };
+  rows.push(row(
+    'credential store',
+    'ok',
+    storeDetail(),
+    source === 'file' || (source === null && backend === 'file')
+      ? 'install libsecret for a real keychain on Linux'
+      : null
+  ));
+
+  if (looksLikeIngestKey(token)) {
+    rows.push(row(
+      'token valid',
+      'fail',
+      'that is an ingest key, not a CLI token',
+      'run login, or set RAVENSIGHT_TOKEN to a gt_cli_ token'
+    ));
+  } else if (!token) {
+    rows.push(row('token valid', 'fail', `not logged in to ${host}`, 'ravensight-playtest login'));
+  }
+
+  let whoami = null;
+  if (token && !looksLikeIngestKey(token)) {
+    const authed = deps.authedApi || createClient({ apiUrl, token });
+    try {
+      whoami = await authed.cli.whoami();
+      rows.push(row(
+        'token valid',
+        'ok',
+        `${whoami.user.email || whoami.user.name || whoami.user.id}, scopes ${whoami.scopes.join(' ')}`
+      ));
+    } catch (error) {
+      const message = error instanceof ApiError ? error.message : String(error && error.message);
+      rows.push(row('token valid', 'fail', message, 'ravensight-playtest login'));
+    }
+
+    /* ------------------------------------------------------------ the game */
+
+    const config = flags.config === undefined
+      ? await loadConfig({ repoRoot: flags.repoRoot })
+      : flags.config;
+    const gameId = flags.game || (config && config.game_id) || null;
+
+    if (!gameId) {
+      rows.push(row(
+        'game linked',
+        'warn',
+        'this directory is not linked to a game',
+        'ravensight-playtest init --game <gameId>'
+      ));
+    } else if (whoami) {
+      const visible = (whoami.games || []).some(game => game.gameId === gameId);
+      rows.push(row(
+        'game visible',
+        visible ? 'ok' : 'fail',
+        visible ? gameId : `${gameId} is not visible to this token`,
+        visible ? null : 'approve this game for the token, or run login again'
+      ));
+
+      /* -------------------------------------------------- balance vs price */
+
+      if (visible) {
+        const modules = flags.modules || (config && config.modules) || ['game_profile', 'persona_playtest'];
+        const personas = flags.personas || (config && config.personas) || [];
+        try {
+          const estimate = await authed.jobs.estimate(gameId, { modules, personas });
+          if (estimate.balance_cents === null || estimate.balance_cents === undefined) {
+            rows.push(row(
+              'balance',
+              'warn',
+              `estimate ${ui.money(estimate.estimate_cents)}, balance hidden by your role`,
+              'ask an owner or admin to check the balance'
+            ));
+          } else {
+            rows.push(row(
+              'balance',
+              estimate.ok ? 'ok' : 'fail',
+              `estimate ${ui.money(estimate.estimate_cents)}, available ${ui.money(estimate.balance_cents)}`,
+              estimate.ok ? null : `top up at ${estimate.topup_url}`
+            ));
+          }
+          // Not a failure and not hidden by role: a job this size is still
+          // allowed, it may just outrun its wall clock, which is worth seeing
+          // here rather than only after `run` has already asked for a price.
+          if (estimate.wall_warning) {
+            rows.push(row('persona wall clock', 'warn', estimate.wall_warning));
+          }
+        } catch (error) {
+          rows.push(row(
+            'balance',
+            'warn',
+            error instanceof ApiError ? error.message : String(error && error.message)
+          ));
+        }
+
+        /* ------------------------------------------------------ pack cache */
+
+        try {
+          const pack = await packs.get({ api: authed, gameId, modules });
+          const manifest = (await authed.packs.manifest()).body;
+          const verified = packs.verifyAgainstManifest(manifest, pack.bundle);
+          rows.push(row(
+            'content pack',
+            verified.ok ? 'ok' : 'fail',
+            verified.ok
+              ? `${plural(pack.bundle.personas.length, 'persona')}, ${plural(verified.checked, 'component')} verified${pack.stale ? ' (cached)' : ''}`
+              : `these components do not match the manifest: ${verified.mismatched.join(', ')}`,
+            verified.ok ? null : `delete ${paths.packCacheDir(apiUrl)} and run check again`
+          ));
+        } catch (error) {
+          rows.push(row(
+            'content pack',
+            'fail',
+            error instanceof ApiError ? error.message : String(error && error.message),
+            'the CLI cannot run without personas and schemas'
+          ));
+        }
+      }
+    }
+  }
+
+  /* --------------------------------------------------------- the machine */
+
+  const repoRoot = flags.repoRoot || process.cwd();
+  const free = await freeBytes(repoRoot);
+  rows.push(row(
+    'disk',
+    free === null ? 'warn' : free >= DISK_WARN_BYTES ? 'ok' : 'warn',
+    free === null ? 'could not read free space' : `${ui.bytes(free)} free in ${repoRoot}`,
+    'screenshots and a video take 50 to 300 MB per run'
+  ));
+
+  const machine = recommendConcurrency(deps.machine);
+  rows.push(row(
+    'cpu and memory',
+    'ok',
+    `${machine.cpus} logical cpus, ${machine.freeMemGb} GB free, use concurrency ${machine.recommended}`
+  ));
+
+  const ffmpeg = await (deps.detectFfmpeg || detectFfmpeg)();
+  rows.push(row(
+    'ffmpeg (optional)',
+    ffmpeg.path ? 'ok' : 'warn',
+    ffmpeg.path ? `${ffmpeg.path}: ${ffmpeg.version}` : 'not found',
+    'needed only to re-encode a session video before upload'
+  ));
+
+  const godot = await (deps.inspectGodot || inspectGodot)(
+    { repoRoot, godotPath: flags.godotPath },
+    deps
+  );
+  rows.push(row(
+    'godot (optional)',
+    godot.binary.path ? 'ok' : 'warn',
+    godot.binary.path
+      ? `${godot.binary.path}${godot.binary.version ? `: ${godot.binary.version}` : ''}`
+      // The detector's own message says WHY: nothing found at all, versus a
+      // --godot-path that exists but is not a Godot 4.2+ binary. Those two want
+      // different fixes, and "not found" would hide the second.
+      : godot.binary.reason || 'not found',
+    'needed only for a godot_driver run; set RAVENSIGHT_GODOT to point at it'
+  ));
+  if (godot.isProject) {
+    // Only reported for a Godot repo: telling a web game's developer that their
+    // project.godot does not pin a version would be noise about a file they do
+    // not have. But for a Godot repo the row always appears, including when a
+    // version could not be read: "not checked" and "checked and fine" must not
+    // look the same.
+    const unknownDetail = {
+      both: 'could not read the engine version from project.godot, and no Godot binary was found',
+      project: 'could not read the engine version from project.godot',
+      binary: `project asks for ${godot.projectVersion}, and no Godot binary was found to compare`
+    };
+    rows.push(row(
+      'godot project',
+      godot.matches === false || godot.unknown ? 'warn' : 'ok',
+      godot.matches === false
+        ? `project asks for ${godot.projectVersion}, found ${godot.binary.version}`
+        : godot.unknown
+          ? unknownDetail[godot.unknown]
+          : `project.godot asks for ${godot.projectVersion}, and that is what was found`,
+      godot.matches === false
+        ? 'install the matching Godot, or set RAVENSIGHT_GODOT to it'
+        : godot.unknown
+          ? 'only matters for a godot_driver run'
+          : null
+    ));
+  }
+
+  return { rows, ok: rows.every(entry => entry.status !== 'fail') };
+}
+
+/**
+ * `ravensight-playtest check`
+ * @param {Object} [flags]
+ * @param {Object} [deps]
+ * @returns {Promise<number>} exit code, 3 when anything failed
+ */
+export async function check(flags = {}, deps = {}) {
+  const { rows, ok } = await runChecks(flags, deps);
+
+  if (flags.json) {
+    ui.json({ ok, checks: rows });
+    return ok ? ExitCode.OK : ExitCode.ENVIRONMENT;
+  }
+
+  ui.table(rows, [
+    { key: 'status', label: '' },
+    { key: 'name', label: 'CHECK' },
+    { key: 'detail', label: 'DETAIL' }
+  ]);
+  ui.blank();
+  for (const entry of rows) {
+    if (entry.status !== 'ok' && entry.fix) ui.info(`${entry.name}: ${entry.fix}`);
+  }
+  ui.blank();
+  if (ok) ui.ok('Ready.');
+  else ui.error('Some checks failed. Fix the ones above and run check again.');
+  return ok ? ExitCode.OK : ExitCode.ENVIRONMENT;
+}

package/src/commands/fakeCore.js

@@ -0,0 +1,379 @@
+/**
+ * A stand-in for cli-core, shaped exactly like `src/run/deps.js` normalises the
+ * real `src/api/index.js` barrel into.
+ *
+ * Shared between the `run`, `profile` and `resume` tests, because all three go
+ * through the same context, the same pack and the same job routes, and three
+ * copies of this would drift.
+ *
+ * **It enforces the server's run state machine.** `RUN_TRANSITIONS` here is a
+ * copy of the server's table (`PlaytestRun.js`, re-exported by cli-core's
+ * `src/states.js`), and a hop that is not in it throws the 409
+ * `invalid_transition` the real server would. A fake that accepts every
+ * transition makes an illegal one invisible, which is how a CLI ships a state
+ * machine the server refuses.
+ */
+
+const SKILL = ['---', 'name: persona-playtest', 'prompt_version: persona-playtest@0.1.0', '---', '# Persona Playtest'].join('\n');
+const PROFILE_SKILL = ['---', 'name: game-profile', 'prompt_version: game-profile@0.1.0', '---', '# Game Profile'].join('\n');
+
+/** The server's table, verbatim. */
+export const RUN_TRANSITIONS = Object.freeze({
+  queued: ['launching', 'canceled', 'skipped', 'failed', 'interrupted'],
+  launching: ['playing', 'failed', 'canceled', 'interrupted'],
+  playing: ['reporting', 'failed', 'canceled', 'budget_exceeded', 'interrupted'],
+  reporting: ['uploading', 'failed', 'interrupted'],
+  uploading: ['succeeded', 'failed', 'interrupted'],
+  interrupted: ['launching', 'playing', 'reporting', 'uploading', 'failed', 'canceled'],
+  succeeded: [],
+  failed: [],
+  canceled: [],
+  budget_exceeded: [],
+  skipped: []
+});
+
+export const RUN_TERMINAL_STATES = Object.freeze(['succeeded', 'failed', 'canceled', 'budget_exceeded', 'skipped']);
+
+/** Shaped like cli-core's `ApiError`: `status`, `code`, `body`. */
+export class FakeApiError extends Error {
+  constructor({ status, code, message, body = {} }) {
+    super(message);
+    this.name = 'ApiError';
+    this.status = status;
+    this.code = code;
+    this.body = body;
+  }
+}
+
+/** Enough of the report schema for the runner's validator to be real. */
+export const REPORT_SCHEMA = {
+  type: 'object',
+  required: ['schema_version', 'run_id', 'job_id', 'findings', 'sentiment', 'would_continue', 'usage', 'quit_reason', 'actions_taken'],
+  properties: {
+    schema_version: { const: '1.0' },
+    run_id: { type: 'string' },
+    job_id: { type: 'string' },
+    persona: { type: 'string' },
+    driver: { type: 'string' },
+    target: { type: 'string' },
+    prompt_version: { type: 'string' },
+    started_at: { type: 'string' },
+    ended_at: { type: 'string' },
+    actions_taken: { type: 'integer' },
+    quit_reason: { type: 'string' },
+    quit_detail: { type: 'string' },
+    findings: { type: 'array' },
+    sentiment: { type: 'object' },
+    would_continue: { type: 'boolean' },
+    usage: { type: 'object' }
+  }
+};
+
+export const CAPABILITY_SCHEMA = {
+  type: 'object',
+  required: ['schema_version', 'job_id', 'game', 'eligibility', 'warnings'],
+  properties: {
+    schema_version: { const: '1.0' },
+    job_id: { type: 'string' },
+    generated_at: { type: 'string' },
+    game: { type: 'object' },
+    source: { type: 'object' },
+    logic_split: { type: 'object' },
+    telemetry: { type: 'object' },
+    builds: { type: 'object' },
+    eligibility: { type: 'array' },
+    estimates: { type: 'array' },
+    asks_for_customer: { type: 'array' },
+    warnings: { type: 'array' }
+  }
+};
+
+/**
+ * @param {Object} [overrides]
+ * @returns {Object} a pack bundle, the shape `packs.get()` answers
+ */
+export function fakePack(overrides = {}) {
+  return {
+    pack_version: '1.0.0',
+    personas: [
+      { slug: 'curious-kid', name: 'Curious Kid', patience_actions: 25, model_tier_hint: 'tier_fast', body: 'clicks everything' },
+      { slug: 'grumpy-veteran', name: 'Grumpy Veteran', patience_actions: 30, model_tier_hint: 'tier_frontier', body: 'has seen it all' },
+      { slug: 'speedrunner', name: 'Speedrunner', patience_actions: 40, model_tier_hint: 'tier_standard', body: 'goes fast' }
+    ],
+    skills: [
+      { module: 'persona_playtest', name: 'persona-playtest', content: SKILL },
+      { module: 'game_profile', name: 'game-profile', content: PROFILE_SKILL }
+    ],
+    schemas: [
+      { name: 'playtest-report', content: REPORT_SCHEMA },
+      { name: 'capability-report', content: CAPABILITY_SCHEMA }
+    ],
+    // Mirrors the server's clientRouting() shape (src/services/routingService.js):
+    // step names and the per-run action ceiling, plus the persona ceiling and
+    // the wall-clock figures run.js's local persona check and price prompt read.
+    routing: {
+      max_actions: 150,
+      steps: {},
+      max_personas: 100,
+      wall_warning_personas: 8,
+      job_wall_seconds_max: 5400,
+      wall_seconds_max_per_run: 900
+    },
+    code_brief: null,
+    engine: 'web',
+    intent_notes: [],
+    ...overrides
+  };
+}
+
+/**
+ * @param {Object} [fields]
+ * @returns {Object} a brief record, the shape `api.brief.get` answers
+ */
+export function fakeBrief(fields = {}) {
+  return {
+    brief_id: 'br_1',
+    version: 3,
+    status: 'complete',
+    parent_version: 2,
+    fields: {
+      goals: [{ text: 'a new player reaches level 2', priority: 1 }],
+      success_criteria: 'a new player reaches level 2\nnobody gets stuck in the menu',
+      build_notes: { controls: 'arrows and space', how_to_start: 'press start' },
+      known_issues: ['the pause menu has no art yet'],
+      design_intent_notes: ['the fog is intentional'],
+      ...fields
+    }
+  };
+}
+
+/**
+ * @param {string} runId
+ * @param {Object} [overrides]
+ * @returns {string} a report.json body a model would have written
+ */
+export function fakeReportJson(runId, overrides = {}) {
+  return JSON.stringify({
+    schema_version: '1.0',
+    run_id: runId,
+    job_id: 'pt_job_1',
+    prompt_version: 'persona-playtest@0.1.0',
+    findings: [],
+    sentiment: { fun: 3, clarity: 3, frustration: 3 },
+    would_continue: true,
+    usage: { by_model: [], total_usd: 0 },
+    quit_reason: 'persona_quit',
+    actions_taken: 0,
+    ...overrides
+  });
+}
+
+/** A report.md carrying the four sections the server lints for. */
+export const REPORT_MD = [
+  '# Playtest',
+  '',
+  '## What worked',
+  'The start button worked.',
+  '',
+  '## Top issues',
+  'None.',
+  '',
+  "## What this run didn't cover",
+  'Anything past the title screen.',
+  '',
+  '## Suggested next step',
+  'Run the speedrunner next.',
+  ''
+].join('\n');
+
+/**
+ * @param {Object} [options]
+ * @returns {Object} deps, with a `calls` log and a `runStates` map
+ */
+export function fakeCore({
+  estimate = {},
+  register = {},
+  runs = null,
+  config = null,
+  publish = true,
+  aggregateFinishes = false,
+  brief = fakeBrief(),
+  pack = fakePack()
+} = {}) {
+  const calls = [];
+  const record = (name, payload) => calls.push({ name, ...payload });
+  const defaultRuns = [
+    { run_id: 'pt_run_a', module: 'persona_playtest', persona: 'curious-kid', playtest_token: 'tok_a', budget_usd: 0.6 },
+    { run_id: 'pt_run_b', module: 'persona_playtest', persona: 'grumpy-veteran', playtest_token: 'tok_b', budget_usd: 0.6 },
+    { run_id: 'pt_run_agg', module: 'aggregate_report', persona: null, playtest_token: 'tok_agg', budget_usd: 0.3 }
+  ];
+  const plan = runs || defaultRuns;
+
+  /** Every run's current state, so the table can be enforced. */
+  const runStates = new Map(plan.map(entry => [entry.run_id, entry.state || 'queued']));
+
+  const move = (runId, to) => {
+    const from = runStates.get(runId) || 'queued';
+    if (!(RUN_TRANSITIONS[from] || []).includes(to)) {
+      throw new FakeApiError({
+        status: 409,
+        code: 'invalid_transition',
+        message: `A run cannot go from ${from} to ${to}.`,
+        body: { from, to }
+      });
+    }
+    runStates.set(runId, to);
+    return to;
+  };
+
+  const api = {
+    apiUrl: 'https://api.test',
+    token: 'gt_cli_test',
+    cliVersion: '0.1.0',
+    runStates,
+    brief: {
+      async get(gameId) {
+        record('brief', { gameId });
+        return brief ? { brief, rendered: '# brief' } : { brief: null };
+      }
+    },
+    jobs: {
+      async estimate(gameId, body) {
+        record('estimate', { gameId, body });
+        return {
+          estimate_cents: 200,
+          breakdown: [{ unit: 'playtest_run', count: 2, unit_cents: 100 }],
+          balance_cents: 1000,
+          ok: true,
+          topup_url: 'https://pay.test',
+          ...estimate
+        };
+      },
+      async register(gameId, body, options) {
+        record('register', { gameId, body, options });
+        if (register.throws) throw register.throws;
+        return {
+          job_id: 'pt_job_1',
+          replayed: false,
+          price: { price_cents: 200, breakdown: [] },
+          links: { dashboard: 'https://dash.test/pt_job_1' },
+          runs: plan,
+          ...register
+        };
+      },
+      async uploads(gameId, jobId, body) {
+        record('uploads', { jobId, body });
+        return { urls: body.files.map(file => ({ path: file.path, put_url: 'https://s3.test/x', tagging: null })) };
+      },
+      async aggregateComplete(gameId, jobId, body) {
+        record('aggregateComplete', { jobId, body });
+        return aggregateFinishes
+          ? { aggregate: {}, run: { run_id: 'pt_run_agg', state: 'succeeded' } }
+          : { aggregate: {} };
+      },
+      async capabilityReport(gameId, jobId, body) {
+        record('capabilityReport', { jobId, body });
+        return { capability_report: { accepted: true } };
+      },
+      async finish(gameId, jobId, body) {
+        record('finish', { jobId, body });
+        return { job: { state: 'succeeded' }, refunded_cents: 0, already_settled: false };
+      }
+    },
+    runs: {
+      async heartbeat(gameId, jobId, runId, options) {
+        record('heartbeat', { runId, options });
+        return { run: { usage: { total_usd: 0.11 } }, cancel_requested: false };
+      },
+      async transition(gameId, jobId, runId, state, options) {
+        record('transition', { runId, state, options });
+        move(runId, state);
+        return { run: { run_id: runId, state }, cancel_requested: false };
+      },
+      async complete(gameId, jobId, runId, body) {
+        record('complete', { runId, body });
+        const from = runStates.get(runId) || 'queued';
+        if (RUN_TERMINAL_STATES.includes(from)) {
+          throw new FakeApiError({ status: 409, code: 'run_already_complete', message: 'That run has already finished.', body: { state: from } });
+        }
+        runStates.set(runId, body.state);
+        return { run: { run_id: runId, state: body.state }, dropped_findings: 0, report_lint: [] };
+      },
+      async list(gameId, jobId) {
+        record('list', { jobId });
+        return { runs: plan.map(entry => ({ ...entry, state: runStates.get(entry.run_id), actions_taken: 0 })) };
+      }
+    }
+  };
+
+  const deps = {
+    calls,
+    api,
+    runStates,
+    async createContext(options) {
+      record('createContext', { options });
+      return { api, apiUrl: api.apiUrl, token: api.token, config, repoRoot: options.repoRoot };
+    },
+    resolveGameId: (flags, loaded) => flags.game || (loaded && loaded.game_id) || 'g_1',
+    cliVersion: '0.1.0',
+    brief: {
+      async get({ api: client, gameId }) {
+        const answer = await client.brief.get(gameId);
+        return (answer && answer.brief) || null;
+      }
+    },
+    packs: {
+      async get(options) {
+        record('packs', { options });
+        return pack;
+      }
+    },
+    async finalizeRun(dir, options) {
+      record('finalizeRun', { dir, options });
+      // The real one uploads and then calls `complete`, so the fake moves the
+      // run the same way: a `finalizeRun` on an already terminal run is a 409
+      // there too.
+      return api.runs.complete(null, options.jobId, options.runId, options.body);
+    },
+    async uploadRunDir(dir, options) {
+      record('uploadRunDir', { dir, options });
+      return { uploaded: [] };
+    }
+  };
+  if (publish) {
+    deps.publishJobFiles = async payload => {
+      record('publishJobFiles', { payload });
+      return Object.fromEntries(payload.files.map(name => [name, { size: 10, sha256: 'a'.repeat(64) }]));
+    };
+  }
+  return deps;
+}
+
+/**
+ * A driver that answers instantly and records nothing the tests need.
+ * @returns {Object}
+ */
+export function fakeDriver() {
+  let step = 0;
+  return {
+    async launch() {},
+    async observe() {
+      step += 1;
+      return { step, text: 'the title screen of a small game about bunnies', url: 'http://game.test/', elapsedMs: 1 };
+    },
+    async act() {
+      return { ok: true, changed: true };
+    },
+    async screenshot(name) {
+      return { path: `/tmp/${name}.png`, relativePath: `screenshots/01-${name}.png` };
+    },
+    async consoleErrors() {
+      return [];
+    },
+    async stop() {
+      return { videoPath: null };
+    }
+  };
+}
+
+export default fakeCore;