ravensight-playtest 0.1.0

package/src/commands/resume.js

@@ -0,0 +1,156 @@
+import { createContext } from '../api/index.js';
+import { ApiError } from '../api/errors.js';
+import { listStates, readState } from '../state/index.js';
+import { isRunTerminal } from '../states.js';
+import { withAuthHandling } from '../auth/session.js';
+import { pending } from '../upload/queue.js';
+import { jobLink } from '../dashboard.js';
+import { ui } from '../ui/index.js';
+import { CliError, ExitCode } from '../errors.js';
+
+/**
+ * Load the runner's resume entry point, if this build has one.
+ *
+ * cli-core owns `resume` and the journal; the persona loop that actually
+ * restarts a run belongs to `src/run/`. A dynamic import keeps the two
+ * independent: on a tree where the runner has not landed, `resume` still
+ * reports and still drains uploads, and says plainly that it cannot restart
+ * anything.
+ *
+ * @returns {Promise<{resumeJob: Function}|null>}
+ */
+export async function loadRunner() {
+  try {
+    const mod = await import('../run/index.js');
+    return typeof mod.resumeJob === 'function' ? mod : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * `ravensight-playtest resume [jobId]`
+ *
+ * With no job id, list what this repo has journals for. With one, reconcile the
+ * journal against the server and hand off to the runner.
+ *
+ * The server is the authority on what the job and its runs actually are: the
+ * journal says what this machine last saw, which after a kill is by definition
+ * out of date. A run the server considers terminal is never restarted, which is
+ * what stops a resume from paying for work that was already delivered.
+ *
+ * @param {string|undefined} jobId
+ * @param {Object} [flags]
+ * @param {Object} [deps]
+ * @returns {Promise<number>}
+ */
+export async function resume(jobId, flags = {}, deps = {}) {
+  const context = deps.context || await createContext({
+    apiUrl: flags.apiUrl,
+    repoRoot: flags.repoRoot,
+    requireAuth: true
+  });
+  return withAuthHandling(context, () => resumeWith(context, jobId, flags, deps));
+}
+
+async function resumeWith(context, jobId, flags, deps) {
+  const repoRoot = context.repoRoot;
+
+  if (!jobId) {
+    const states = await listStates({ repoRoot });
+    if (flags.json) {
+      ui.json({ jobs: states.map(({ job_id: id, game_id: game, updated_at: at }) => ({ job_id: id, game_id: game, updated_at: at })) });
+      return ExitCode.OK;
+    }
+    if (states.length === 0) {
+      ui.info('No jobs to resume in this repo.');
+      return ExitCode.OK;
+    }
+    ui.info('Jobs this repo has a journal for:');
+    ui.table(states, [
+      { key: 'job_id', label: 'JOB' },
+      { key: 'game_id', label: 'GAME' },
+      { key: 'updated_at', label: 'LAST TOUCHED' }
+    ]);
+    ui.blank();
+    ui.info('ravensight-playtest resume <jobId>');
+    return ExitCode.OK;
+  }
+
+  const state = await readState(jobId, { repoRoot });
+  if (!state) {
+    throw new CliError(
+      `No journal for ${jobId} in this repo.`,
+      1,
+      { hint: 'Run resume with no job id to see what is here.' }
+    );
+  }
+  const gameId = flags.game || state.game_id;
+  if (!gameId) throw new CliError(`The journal for ${jobId} does not say which game it belongs to.`);
+
+  let job;
+  try {
+    ({ job } = await context.api.jobs.get(gameId, jobId));
+  } catch (error) {
+    if (error instanceof ApiError && error.status === 404) {
+      throw new CliError(
+        `The server does not have ${jobId} for ${gameId}.`,
+        1,
+        { hint: 'It may have been deleted. The local journal can be removed.' }
+      );
+    }
+    throw error;
+  }
+
+  const { runs } = await context.api.runs.list(gameId, jobId);
+  const finished = runs.filter(run => isRunTerminal(run.state));
+  const unfinished = runs.filter(run => !finished.includes(run));
+  const owed = await pending(jobId, { repoRoot });
+
+  if (flags.json) {
+    ui.json({
+      job,
+      runs,
+      finished: finished.map(run => run.run_id),
+      unfinished: unfinished.map(run => run.run_id),
+      pending_uploads: owed,
+      runner_available: Boolean(await loadRunner())
+    });
+    return ExitCode.OK;
+  }
+
+  ui.info(`Job ${jobId} on ${gameId} is ${job.state}.`);
+  ui.table(runs, [
+    { key: 'run_id', label: 'RUN' },
+    { key: 'persona', label: 'PERSONA' },
+    { key: 'state', label: 'STATE' },
+    { key: 'actions_taken', label: 'ACTIONS', align: 'right' }
+  ]);
+  ui.blank();
+  ui.info(`${finished.length} runs finished, ${unfinished.length} to go.`);
+  if (owed.length > 0) ui.info(`${owed.length} files still to upload.`);
+
+  if (flags.status) {
+    ui.info(jobLink(gameId, jobId, context.apiUrl));
+    return ExitCode.OK;
+  }
+
+  const runner = deps.runner === undefined ? await loadRunner() : deps.runner;
+  if (!runner) {
+    ui.warn('This build has no run module, so there is nothing to restart.');
+    ui.info('Uploads can still be drained: ravensight-playtest upload ' + jobId);
+    return ExitCode.OK;
+  }
+
+  return runner.resumeJob({
+    api: context.api,
+    gameId,
+    jobId,
+    job,
+    runs,
+    state,
+    repoRoot,
+    flags
+  });
+}
+