@apex-actions/cli 0.67.0

package/dist/cli/variable/main.js

@@ -0,0 +1,83 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { batchExitCode, listVariables, setEverywhere } from '../../src/application/manage-secrets.js';
+import { readToEnd } from '../../src/infrastructure/secret-input.js';
+import { api, collect, deleteAction, printResults, targetsFrom, usage, validName } from '../secret/shared.js';
+/**
+ * `apex variable`: the same routes as `apex secret`, for values that are not
+ * secret. A variable is readable back — `list` prints it — so `--value` on the
+ * command line is allowed here, and is the ordinary way to set one.
+ */
+const setCommand = new Command('set')
+    .description('Set a variable on one or more repositories, from --value or stdin')
+    .argument('<name>', 'variable name, as a workflow reads it: vars.NAME')
+    .option('--value <value>', 'the value (not secret, so a flag is allowed); otherwise read from stdin')
+    .option('--repo <owner/repo>', 'repository to set it on (repeatable)', collect, [])
+    .option('--org', 'the organisation scope (the operator organisation only)')
+    .action(async (name, opts) => {
+    if (!validName(name))
+        return;
+    const targets = targetsFrom(opts);
+    if (!targets)
+        return;
+    let value = opts.value;
+    if (value === undefined) {
+        if (process.stdin.isTTY === true) {
+            usage('pass --value, or pipe the value on stdin');
+            return;
+        }
+        value = await readToEnd(process.stdin);
+    }
+    if (value === '') {
+        usage('the value is empty; nothing was set');
+        return;
+    }
+    const client = api();
+    if (!client)
+        return;
+    const results = await setEverywhere(client, 'variable', targets, name, value);
+    printResults(name, results);
+    process.exitCode = batchExitCode(results);
+});
+const listCommand = new Command('list')
+    .description("A repository's variables, names and values")
+    .option('--repo <owner/repo>', 'repository', collect, [])
+    .option('--org', 'the organisation scope (the operator organisation only)')
+    .option('--json', 'machine-readable output')
+    .action(async (opts) => {
+    const targets = targetsFrom(opts, true);
+    if (!targets?.[0])
+        return;
+    const client = api();
+    if (!client)
+        return;
+    const outcome = await listVariables(client, targets[0]);
+    if (outcome.kind === 'refused') {
+        console.error(chalk.red(outcome.detail));
+        process.exitCode = 1;
+        return;
+    }
+    if (opts.json === true) {
+        console.log(JSON.stringify({ variables: outcome.variables }, null, 2));
+        return;
+    }
+    if (outcome.variables.length === 0) {
+        console.log(chalk.yellow('No variables are set here.'));
+        return;
+    }
+    console.log(chalk.bold(['NAME'.padEnd(32), 'VALUE'].join('  ')));
+    for (const v of outcome.variables)
+        console.log([v.name.padEnd(32), v.value].join('  '));
+});
+const deleteCommand = new Command('delete')
+    .description('Delete a variable from one or more repositories')
+    .argument('<name>', 'variable name')
+    .option('--repo <owner/repo>', 'repository (repeatable)', collect, [])
+    .option('--org', 'the organisation scope (the operator organisation only)')
+    .option('-y, --yes', 'do not ask; required when not on a terminal')
+    .action(deleteAction('variable'));
+export default new Command('variable')
+    .description("Variables: set a repository's non-secret configuration from the terminal")
+    .addCommand(setCommand)
+    .addCommand(listCommand)
+    .addCommand(deleteCommand);

package/dist/cli/whoami/main.js

@@ -0,0 +1,63 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { whoami } from '../../src/application/authenticate.js';
+import { describeSource } from '../../src/domain/credentials.js';
+import { credentialsPath } from '../../src/infrastructure/credentials.js';
+import { HttpControlPlane, NotConfiguredError } from '../../src/infrastructure/control-plane-http.js';
+const credentialLine = (credential) => {
+    if (credential === undefined)
+        return 'unknown';
+    if (credential.kind !== 'token')
+        return credential.kind === 'machine' ? 'the machine token (operator)' : 'a signed-in session';
+    const source = credential.source === 'login' ? 'minted by apex login' : credential.source === 'dashboard' ? 'minted on the dashboard' : 'a token';
+    return `token, ${source}${credential.expiresAt === undefined ? '' : `, expires ${credential.expiresAt}`}`;
+};
+/**
+ * `apex whoami`: who the control plane thinks this CLI is, and which
+ * credential got it there. The answer is the server's (`GET /api/v1/me`), not
+ * a guess from the local file; the credential itself is never printed.
+ */
+export default new Command('whoami')
+    .description('Who the CLI is acting as, with which credential, and where it found it')
+    .option('--json', 'machine-readable output')
+    .action(async (opts) => {
+    let client;
+    try {
+        client = new HttpControlPlane();
+    }
+    catch (err) {
+        console.error(chalk.red(err instanceof NotConfiguredError ? err.message : String(err)));
+        process.exitCode = 2;
+        return;
+    }
+    const outcome = await whoami(client);
+    if (outcome.kind === 'refused') {
+        console.error(chalk.red(outcome.detail));
+        process.exitCode = 1;
+        return;
+    }
+    const { identity, source } = outcome;
+    const login = identity.actor.kind === 'user' ? identity.actor.login : undefined;
+    const foundIn = source === 'login' ? `${describeSource(source)} (${credentialsPath()})` : describeSource(source);
+    if (opts.json === true) {
+        console.log(JSON.stringify({
+            actor: identity.actor.kind,
+            ...(login === undefined ? {} : { login }),
+            // Rebuilt field by field: whatever else the server sends, only these three are repeated.
+            credential: identity.credential === undefined
+                ? null
+                : {
+                    kind: identity.credential.kind,
+                    ...(identity.credential.source === undefined ? {} : { source: identity.credential.source }),
+                    ...(identity.credential.expiresAt === undefined ? {} : { expiresAt: identity.credential.expiresAt }),
+                },
+            foundIn: source,
+            apiUrl: client.baseUrl,
+        }, null, 2));
+        return;
+    }
+    console.log(`${'acting as'.padEnd(14)}${login ?? 'the machine principal'}`);
+    console.log(`${'credential'.padEnd(14)}${credentialLine(identity.credential)}`);
+    console.log(`${'found in'.padEnd(14)}${foundIn}`);
+    console.log(`${'control plane'.padEnd(14)}${client.baseUrl}`);
+});

package/dist/cli/why/main.js

@@ -0,0 +1,106 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { explainWhy } from '../../src/application/explain-runs.js';
+import { HttpControlPlane, NotConfiguredError } from '../../src/infrastructure/control-plane-http.js';
+import { jobMarker, retryNote, verdictLine, worthShowing } from '../../src/domain/provenance.js';
+import { parseRepository, unknownRunMessage } from '../../src/domain/runs.js';
+const printRun = (e) => {
+    const { run, repository, trigger } = e;
+    console.log(chalk.bold(`Run #${run.runNumber} · ${run.workflowName}`) + chalk.dim(` · ${repository.owner}/${repository.name}`));
+    const by = trigger.actor === undefined ? '' : ` by ${trigger.actor}`;
+    console.log(`  ${trigger.event} on ${trigger.ref} at ${trigger.sha.slice(0, 7)}${by}`);
+    if (e.verdict?.reason !== undefined)
+        console.log(`  ${e.verdict.reason}`);
+    if (trigger.deliveryId !== undefined)
+        console.log(chalk.dim(`  delivery ${trigger.deliveryId}`));
+    console.log(chalk.bold('\nJobs'));
+    for (const job of e.jobs) {
+        const where = job.instanceType === undefined ? '' : chalk.dim(` (${job.instanceType})`);
+        console.log(`  ${jobMarker(job)} ${job.name.padEnd(24)} ${job.reason}${where}`);
+        // A job that was retried says so on its own line, including when it went on
+        // to succeed — that is the case worth seeing, not the failure.
+        const retry = retryNote(job);
+        if (retry !== undefined)
+            console.log(chalk.dim(`    ↻ ${retry}`));
+    }
+    // What the same webhook decided about everything else. This is the half
+    // that answers "…and why didn't the other one run?", which is the question
+    // people actually arrive with.
+    const others = e.siblings.filter(worthShowing);
+    if (others.length > 0) {
+        console.log(chalk.bold('\nAlso decided by this delivery'));
+        for (const t of others)
+            console.log(`  ${t.workflowPath}\n    ${chalk.yellow(verdictLine(t))}`);
+    }
+};
+const printDelivery = (e) => {
+    const { delivery } = e;
+    const action = delivery.action === undefined ? '' : `.${delivery.action}`;
+    console.log(chalk.bold(`Delivery ${delivery.deliveryId}`) + chalk.dim(` · ${delivery.event}${action} · ${delivery.status}`));
+    console.log(`  ${e.summary}`);
+    if (e.verdicts.length > 0) {
+        console.log(chalk.bold('\nWorkflows considered'));
+        for (const t of e.verdicts) {
+            const line = t.outcome === 'planned' ? chalk.green(verdictLine(t)) : chalk.yellow(verdictLine(t));
+            console.log(`  ${t.workflowPath}\n    ${line}`);
+        }
+    }
+};
+const handler = async (run, options) => {
+    const repository = options.repo === undefined ? undefined : parseRepository(options.repo);
+    if (options.repo !== undefined && repository === undefined) {
+        console.error(chalk.red(`--repo must be owner/repo, got ${options.repo}`));
+        process.exitCode = 2;
+        return;
+    }
+    let api;
+    try {
+        api = new HttpControlPlane();
+    }
+    catch (err) {
+        console.error(chalk.red(err instanceof NotConfiguredError ? err.message : String(err)));
+        process.exitCode = 2;
+        return;
+    }
+    let outcome;
+    try {
+        outcome = await explainWhy(api, { run: run ?? 'latest', repository, delivery: options.delivery });
+    }
+    catch (err) {
+        console.error(chalk.red(err instanceof Error ? err.message : String(err)));
+        process.exitCode = 2;
+        return;
+    }
+    switch (outcome.kind) {
+        case 'no-runs':
+            console.error(chalk.yellow('no runs found'));
+            process.exitCode = 2;
+            return;
+        case 'unknown-run':
+            console.error(chalk.red(unknownRunMessage(outcome.selector)));
+            process.exitCode = 2;
+            return;
+        case 'unknown-delivery':
+            console.error(chalk.red(`no delivery ${outcome.selector} is stored`));
+            process.exitCode = 2;
+            return;
+        case 'run':
+            if (options.json === true)
+                console.log(JSON.stringify(outcome.explanation, null, 2));
+            else
+                printRun(outcome.explanation);
+            return;
+        case 'delivery':
+            if (options.json === true)
+                console.log(JSON.stringify(outcome.explanation, null, 2));
+            else
+                printDelivery(outcome.explanation);
+    }
+};
+export default new Command('why')
+    .description('Explain why a run happened — or, with --delivery, why a webhook produced no run at all')
+    .argument('[run]', 'run id, #number, or "latest"', 'latest')
+    .option('--repo <owner/repo>', 'limit the run search to one repository')
+    .option('--delivery <id>', 'explain a webhook delivery instead of a run')
+    .option('--json', 'print the explanation as JSON')
+    .action(handler);

package/dist/src/application/authenticate.js

@@ -0,0 +1,56 @@
+import { authorizeUrl } from '../domain/credentials.js';
+export const login = async (deps) => {
+    const pair = deps.pkce();
+    const listener = await deps.listen(pair.state);
+    try {
+        const url = authorizeUrl(deps.webBase, { port: listener.port, state: pair.state, codeChallenge: pair.challenge, name: deps.name });
+        deps.announce(url);
+        deps.openBrowser?.(url);
+        const callback = await listener.wait();
+        if (callback.kind !== 'code')
+            return callback;
+        let minted;
+        try {
+            minted = await deps.exchange.redeem(callback.code, pair.verifier);
+        }
+        catch (err) {
+            return { kind: 'refused', detail: err instanceof Error ? err.message : String(err) };
+        }
+        await deps.store.save({ token: minted.token, login: minted.login, apiUrl: deps.apiUrl, expiresAt: minted.expiresAt });
+        return { kind: 'logged-in', login: minted.login, expiresAt: minted.expiresAt, location: deps.store.location };
+    }
+    finally {
+        await listener.close();
+    }
+};
+/**
+ * Revoke the saved token at the control plane that minted it, then forget it
+ * (control-plane ADR-0064: a token may revoke itself and nothing else). The file
+ * goes either way — keeping a credential because the network was down would be
+ * the wrong failure — and a revocation that did not happen is reported as such,
+ * never implied.
+ */
+export const logout = async (store, revoke) => {
+    const saved = store.read();
+    let revoked = { failed: 'no readable saved token' };
+    if (saved !== undefined) {
+        try {
+            await revoke(saved);
+            revoked = true;
+        }
+        catch (err) {
+            revoked = { failed: err instanceof Error ? err.message : String(err) };
+        }
+    }
+    if (!(await store.remove()))
+        return { kind: 'nothing', location: store.location };
+    return { kind: 'removed', location: store.location, revoked };
+};
+export const whoami = async (api) => {
+    try {
+        return { kind: 'identified', identity: await api.whoami(), source: api.credentialSource };
+    }
+    catch (err) {
+        return { kind: 'refused', detail: err instanceof Error ? err.message : String(err) };
+    }
+};

package/dist/src/application/dispatch-workflow.js

@@ -0,0 +1,23 @@
+// application layer — see ../../../../docs/conventions.md §1
+import { parseInputs, parseRepository } from '../domain/runs.js';
+/**
+ * Trigger a `workflow_dispatch`. Everything the API can refuse — an unknown
+ * repository, a disabled workflow, a workflow that does not declare dispatch,
+ * a required input left out — is refused *by the API*, and reported here with
+ * the reason it gave. The CLI does not second-guess it.
+ */
+export const dispatchWorkflow = async (api, request) => {
+    const repository = parseRepository(request.repository);
+    if (!repository)
+        return { kind: 'bad-repository', given: request.repository };
+    const { inputs, invalid } = parseInputs(request.inputs);
+    if (invalid.length > 0)
+        return { kind: 'bad-inputs', invalid };
+    try {
+        const { deliveryId } = await api.dispatch(repository.owner, repository.repo, request.workflow, request.ref, inputs);
+        return { kind: 'dispatched', deliveryId };
+    }
+    catch (err) {
+        return { kind: 'refused', detail: err instanceof Error ? err.message : String(err) };
+    }
+};

package/dist/src/application/explain-runs.js

@@ -0,0 +1,40 @@
+import { resolveRunId } from './resolve-run.js';
+/**
+ * Explain a run, or a delivery.
+ *
+ * A delivery is addressed directly rather than resolved through the run list,
+ * because the interesting deliveries are precisely the ones with no run to
+ * find them by.
+ */
+export const explainWhy = async (api, request) => {
+    if (request.delivery !== undefined) {
+        const explanation = await api.explainDelivery(request.delivery);
+        return explanation === undefined ? { kind: 'unknown-delivery', selector: request.delivery } : { kind: 'delivery', explanation };
+    }
+    const resolved = await resolveRunId(api, request);
+    if (resolved.kind !== 'run')
+        return resolved;
+    const explanation = await api.explainRun(resolved.id);
+    return explanation === undefined ? { kind: 'unknown-run', selector: request.run } : { kind: 'run', explanation };
+};
+/**
+ * Build the local invocation for a past run, and put the event payload where
+ * that invocation expects to find it.
+ *
+ * Writing the file is part of the recipe rather than a separate step a reader
+ * has to infer: the command names `apex-event.json`, so a command that
+ * prints without writing it is a command that does not work.
+ */
+export const reproduceRun = async (api, files, request) => {
+    const resolved = await resolveRunId(api, request);
+    if (resolved.kind !== 'run')
+        return resolved;
+    const recipe = await api.reproduction(resolved.id, request.job);
+    if (recipe === undefined)
+        return { kind: 'unknown-run', selector: request.run };
+    if (request.write && recipe.payload !== undefined) {
+        await files.write(recipe.payloadFile, `${JSON.stringify(recipe.payload, null, 2)}\n`);
+        return { kind: 'recipe', recipe, wrote: recipe.payloadFile };
+    }
+    return { kind: 'recipe', recipe };
+};

package/dist/src/application/index.js

@@ -0,0 +1,2 @@
+export {};
+// application layer — see ../../../../docs/conventions.md §1

package/dist/src/application/inspect-runs.js

@@ -0,0 +1,29 @@
+import { resolveRunId } from './resolve-run.js';
+export const inspectTiming = async (api, request) => {
+    const selected = await resolve(api, request);
+    if (selected.kind !== 'run')
+        return selected;
+    const timing = await api.runTiming(selected.id);
+    return timing === undefined ? { kind: 'unknown-run', selector: request.run } : { kind: 'timing', timing };
+};
+/**
+ * A run's tests, or — with `flaky` — a repository's unreliable ones.
+ *
+ * The flake list is a property of a repository rather than of a run, so it
+ * needs `--repo` and says so rather than guessing from the newest run: a list
+ * of the wrong repository's flaky tests is worse than a refusal.
+ */
+export const inspectTests = async (api, request) => {
+    if (request.flaky) {
+        if (request.repository === undefined)
+            return { kind: 'needs-repo' };
+        const tests = await api.flakyTests(request.repository.owner, request.repository.repo);
+        return { kind: 'flaky', tests, repository: `${request.repository.owner}/${request.repository.repo}` };
+    }
+    const selected = await resolve(api, request);
+    if (selected.kind !== 'run')
+        return selected;
+    const tests = await api.runTests(selected.id);
+    return tests === undefined ? { kind: 'unknown-run', selector: request.run } : { kind: 'tests', tests };
+};
+const resolve = async (api, request) => resolveRunId(api, request);

package/dist/src/application/manage-actions.js

@@ -0,0 +1,26 @@
+const attempt = async (fn) => {
+    try {
+        return { kind: 'ok', value: await fn() };
+    }
+    catch (err) {
+        return { kind: 'refused', message: err instanceof Error ? err.message : String(err) };
+    }
+};
+/**
+ * Read what a repository pulls in.
+ *
+ * No classification and no judgement: `pinning` and the findings are the
+ * control plane's answers, and a second implementation here would be a second
+ * answer to a question that must have one.
+ */
+export const listActions = async (api, repository) => await attempt(() => api.actionInventory(repository));
+export const readPolicy = async (api, owner) => await attempt(() => api.actionPolicy(owner));
+export const writePolicy = async (api, owner, policy) => await attempt(() => api.setActionPolicy(owner, policy));
+/**
+ * Preview or open the pin proposal.
+ *
+ * `apply` is passed through rather than inferred: opening a pull request in
+ * somebody's repository is not a thing a CLI should decide on the operator's
+ * behalf from the shape of the output they asked for.
+ */
+export const proposePins = async (api, repository, apply) => await attempt(() => api.pinActions(repository, apply));

package/dist/src/application/manage-approvals.js

@@ -0,0 +1,24 @@
+// application layer — see ../../../../docs/conventions.md §1
+const refused = (err) => ({ kind: 'refused', detail: err instanceof Error ? err.message : String(err) });
+export const listWaitingRuns = async (api) => {
+    try {
+        const { runs } = await api.listWaitingRuns();
+        // Oldest first: the queue is a to-do list, and the run somebody has been
+        // waiting longest for is the one to look at.
+        return { kind: 'listed', runs: [...runs].sort((a, b) => Date.parse(a.createdAt) - Date.parse(b.createdAt)) };
+    }
+    catch (err) {
+        return refused(err);
+    }
+};
+export const decideRun = async (api, runId, decision, comment) => {
+    try {
+        const decided = await api.decideRun(runId, decision, comment);
+        return decided === undefined ? { kind: 'not-found' } : { kind: 'decided', decision: decided };
+    }
+    catch (err) {
+        return refused(err);
+    }
+};
+/** One waiting run on one line: what it is, and where it came from. */
+export const waitingSummary = (r) => `${r.repository} #${r.runNumber} ${r.workflowName} (${r.event} ${r.sha.slice(0, 7)})`;

package/dist/src/application/manage-artifacts.js

@@ -0,0 +1,79 @@
+// application layer — see ../../../../docs/conventions.md §1
+/**
+ * `target` is either a run id or `owner/repo`. They are told apart by shape
+ * rather than by a flag: a run id is a uuid and a repository has a slash, and
+ * making the operator say which is which would be asking them to describe
+ * something they just pasted.
+ */
+export const listArtifacts = async (api, target) => {
+    try {
+        const repository = splitRepository(target);
+        const body = repository ? await api.listRepoArtifacts(repository.owner, repository.repo) : await api.listRunArtifacts(target);
+        // Newest first: what a person is looking for is almost always what a run
+        // just produced, and the oldest is what expiry takes next.
+        const artifacts = [...body.artifacts].sort((a, b) => Date.parse(b.createdAt) - Date.parse(a.createdAt));
+        return { kind: 'listed', artifacts, totalSizeBytes: body.totalSizeBytes };
+    }
+    catch (err) {
+        return { kind: 'refused', detail: err instanceof Error ? err.message : String(err) };
+    }
+};
+/**
+ * Find one artifact of a run by name and hand back its bytes.
+ *
+ * A name is what a person has — it is what the workflow file says — and it is
+ * unique within a run, so no id is needed. With no name and exactly one
+ * artifact the answer is unambiguous; with several it is not, and guessing
+ * would silently download the wrong one.
+ */
+export const downloadArtifact = async (api, runId, name) => {
+    try {
+        const { artifacts } = await api.listRunArtifacts(runId);
+        const matches = name === undefined ? artifacts : artifacts.filter((a) => a.name === name);
+        if (matches.length === 0)
+            return { kind: 'not-found', name: name ?? '(any)' };
+        if (matches.length > 1)
+            return { kind: 'ambiguous', names: matches.map((a) => a.name) };
+        const artifact = matches[0];
+        const body = await api.downloadArtifact(runId, artifact.id);
+        if (!body)
+            return { kind: 'not-found', name: artifact.name };
+        return { kind: 'downloaded', artifact, body };
+    }
+    catch (err) {
+        return { kind: 'refused', detail: err instanceof Error ? err.message : String(err) };
+    }
+};
+export const deleteArtifact = async (api, runId, id) => {
+    const numeric = Number(id);
+    if (!Number.isSafeInteger(numeric) || numeric <= 0)
+        return { kind: 'bad-id', given: id };
+    try {
+        return (await api.deleteArtifact(runId, numeric)) ? { kind: 'deleted' } : { kind: 'not-found', id: numeric };
+    }
+    catch (err) {
+        return { kind: 'refused', detail: err instanceof Error ? err.message : String(err) };
+    }
+};
+/** `owner/repo` → its halves; `undefined` for anything else, which is then a run id. */
+export const splitRepository = (slug) => {
+    const [owner, repo, ...rest] = slug.split('/');
+    if (owner === undefined || repo === undefined || rest.length > 0 || owner === '' || repo === '')
+        return undefined;
+    return { owner, repo };
+};
+/**
+ * How long until `iso`, for an operator scanning a column. Days are the unit
+ * that matters for retention; anything under a day is "today", because an
+ * artifact that expires in seven hours and one that expires in nine are the
+ * same problem.
+ */
+export const untilExpiry = (iso, now = Date.now()) => {
+    const ms = Date.parse(iso) - now;
+    if (Number.isNaN(ms))
+        return '?';
+    if (ms <= 0)
+        return 'expired';
+    const days = Math.floor(ms / 86_400_000);
+    return days === 0 ? 'today' : `${days}d`;
+};

package/dist/src/application/manage-caches.js

@@ -0,0 +1,41 @@
+// application layer — see ../../../../docs/conventions.md §1
+export const listCaches = async (api, owner, repo) => {
+    try {
+        const body = await api.listCaches(owner, repo);
+        // Least recently used last: the next thing eviction takes is the last line.
+        const caches = [...body.caches].sort((a, b) => Date.parse(b.lastAccessedAt) - Date.parse(a.lastAccessedAt));
+        return { kind: 'listed', caches, totalSizeBytes: body.totalSizeBytes };
+    }
+    catch (err) {
+        return { kind: 'refused', detail: err instanceof Error ? err.message : String(err) };
+    }
+};
+export const deleteCache = async (api, owner, repo, id) => {
+    const numeric = Number(id);
+    if (!Number.isSafeInteger(numeric) || numeric <= 0)
+        return { kind: 'bad-id', given: id };
+    try {
+        return (await api.deleteCache(owner, repo, numeric)) ? { kind: 'deleted' } : { kind: 'not-found', id: numeric };
+    }
+    catch (err) {
+        return { kind: 'refused', detail: err instanceof Error ? err.message : String(err) };
+    }
+};
+/** `owner/repo` → its halves. Anything else is a usage error, not a 404. */
+export const splitRepository = (slug) => {
+    const [owner, repo, ...rest] = slug.split('/');
+    if (owner === undefined || repo === undefined || rest.length > 0 || owner === '' || repo === '')
+        return undefined;
+    return { owner, repo };
+};
+/** Bytes as an operator reads them. Whole units below a thousand; never scientific notation. */
+export const humanBytes = (bytes) => {
+    const units = ['B', 'KB', 'MB', 'GB', 'TB'];
+    let value = bytes;
+    let unit = 0;
+    while (value >= 1024 && unit < units.length - 1) {
+        value /= 1024;
+        unit += 1;
+    }
+    return `${unit === 0 ? value : value.toFixed(1)} ${units[unit]}`;
+};