@3minapi/cli 0.0.0-stage → 0.22.0

package/dist/commands/auth.js

@@ -0,0 +1,573 @@
+import { statSync } from 'node:fs';
+import path from 'node:path';
+import { deleteHostToken, isHostToken, resolveHostToken, saveHostToken } from "../core/credentials.js";
+import { BIN, ENV, ExitCode, HOST_TOKEN_PREFIX, LOCAL_SERVER_TOKEN_FILE, MONTH_MS, StopError, UsageError, builtinResultsName, isReservedWorkerName } from "../core/domain/index.js";
+import { readAllStdin, readSecret } from "../core/prompt.js";
+import { readRunner, runnerMode } from "../core/host/runner-lock.js";
+import { readDashboard } from "../modules/dashboard/lock.js";
+import { looseMode } from "../core/secure-fs.js";
+import { defaultProjectRoot } from "../core/project.js";
+import { clearStop, openSession, recordStop, rememberQuota, stopHint } from "../core/host/session.js";
+import { hostUsage } from "../core/host/usage.js";
+import { formatBytes, formatCount, stripControl } from "../core/text.js";
+import { describeAt, formatLocal, formatThroughput, maxTasksPerMinute, relative } from "../core/time.js";
+import { HOST_META, cacheHostIdentity, hostChangedWarning } from "../modules/workers/builtin/host-identity.js";
+import { ResultStore, resultsDbBytes, resultsDbPath } from "../modules/workers/results/store.js";
+import { workerFiles } from "../modules/workers/workers.js";
+import { parseSettings } from "../modules/workers/repeat-scheduler.js";
+import { ApiError } from "../core/api.js";
+import { client, noticeUpdate, workersPath } from "./common.js";
+import { readLatest, updateInfo } from "../core/update-notice.js";
+function nextAfterLogin(ctx, config) {
+    const root = config.projectRoot;
+    if (!root) {
+        return `Next: ${BIN} init   ${ctx.out.out.dim(`(creates ${defaultProjectRoot(ctx.home)})`)}`;
+    }
+    let hasWorkers = false;
+    try {
+        hasWorkers = workerFiles(workersPath(root, config)).size > 0;
+    }
+    catch {
+    }
+    return hasWorkers ? `Next: ${BIN} start` : `Next: ${BIN} worker new <name>`;
+}
+export const login = {
+    name: 'login',
+    summary: 'Save the host token issued on the 3Min API dashboard',
+    usage: '[--with-token]',
+    description: 'Prompts for the host token (tm_host_...). Use --with-token to read it from stdin instead,\n' +
+        'e.g. in CI: echo "$TOKEN" | 3minapi login --with-token\n' +
+        'The token is checked with the server (one API call) before it is saved.',
+    options: {
+        'with-token': { type: 'boolean', description: 'Read the token from stdin' }
+    },
+    args: { min: 0, max: 0 },
+    async run(ctx) {
+        const { out, env, values } = ctx;
+        let token;
+        if (values['with-token']) {
+            if (ctx.stdin.isTTY) {
+                throw new UsageError(`--with-token reads the token from stdin. Pipe it in: echo "$TOKEN" | ${BIN} login --with-token`);
+            }
+            token = (await readAllStdin(ctx.stdin)).trim();
+        }
+        else {
+            token = (await readSecret(ctx.stdin, out, `Paste your host token (${HOST_TOKEN_PREFIX}...): `)).trim();
+        }
+        if (!isHostToken(token)) {
+            throw new UsageError(`that is not a host token (expected ${HOST_TOKEN_PREFIX} followed by 48 hex characters)`);
+        }
+        const session = openSession(ctx);
+        try {
+            let host;
+            try {
+                host = await client(ctx, session, token).getHost();
+            }
+            catch (err) {
+                if (err instanceof StopError) {
+                    session.logger.warn('login rejected', { reason: err.reason });
+                    throw new StopError(err.reason, `${err.message}\n${stopHint(err.reason)}`, err.resetAt);
+                }
+                throw err;
+            }
+            const file = saveHostToken(ctx.dirs.config, token, ctx.now());
+            clearStop(session);
+            const previous = cacheHostIdentity(session.db, token, host.host, ctx.now());
+            rememberQuota(session, host.quota, ctx.now());
+            session.logger.info('logged in', { host_id: host.host.id, host_name: host.host.name });
+            if (previous !== null) {
+                out.warn(hostChangedWarning(previous, host.host));
+                session.logger.warn('host changed', { previous_host_id: previous, host_id: host.host.id });
+            }
+            if (env[ENV.token]) {
+                out.warn(`${ENV.token} is set and takes precedence over the saved token.`);
+            }
+            const projectRoot = session.config.projectRoot;
+            out.result({
+                host: host.host,
+                workers: host.workers,
+                quota: host.quota,
+                credentials: file,
+                previousHostId: previous,
+                projectRoot
+            }, [
+                `${out.out.green('logged in')}  ${stripControl(host.host.name)}`,
+                `token saved to ${file}`,
+                quotaLine(out, host, ctx.now()),
+                '',
+                nextAfterLogin(ctx, session.config)
+            ].join('\n'));
+            return ExitCode.Ok;
+        }
+        finally {
+            session.close();
+        }
+    }
+};
+export const logout = {
+    name: 'logout',
+    summary: 'Remove the saved host token from this machine',
+    usage: '',
+    description: 'Only deletes the token saved on this machine. To revoke it, delete the token on the dashboard.',
+    options: {},
+    args: { min: 0, max: 0 },
+    async run({ dirs, env, out }) {
+        const removed = deleteHostToken(dirs.config);
+        if (env[ENV.token]) {
+            out.warn(`${ENV.token} is still set — unset it to stop using that token.`);
+        }
+        out.result({ removed }, removed ? 'Logged out.' : 'No saved token. Already logged out.');
+        return ExitCode.Ok;
+    }
+};
+export const status = {
+    name: 'status',
+    summary: "Show this host: whether 'start' is running, its workers, and remaining quota",
+    usage: '',
+    description: 'Checks the token with the server, which counts as one API call. Also shows how much disk this\n' +
+        'host uses (task history, saved results, logs), and how it fetches tasks: live (connection state)\n' +
+        'or poll (interval, and at most concurrency x polls per minute). If the server cannot be reached (network), shows\n' +
+        'what this PC knows — including the quota from the last server response — and exits with 1.',
+    options: {},
+    args: { min: 0, max: 0 },
+    async run(ctx) {
+        const { out } = ctx;
+        const token = resolveHostToken(ctx.dirs.config, ctx.env);
+        if (!token) {
+            const board = readDashboard(ctx.dirs.data);
+            out.result({ loggedIn: false, dashboard: dashboardJson(board) }, [
+                `Not logged in. Run '${BIN} login'.`,
+                ...(board.state === 'stopped'
+                    ? []
+                    : [row('dashboard', dashboardText(out, board, ctx.now()))])
+            ].join('\n'));
+            return ExitCode.Failure;
+        }
+        warnLooseToken(out, token);
+        const session = openSession(ctx);
+        try {
+            const overrides = overridesIn(ctx, token);
+            let host;
+            try {
+                host = await client(ctx, session, token.token).getHost();
+            }
+            catch (err) {
+                if (err instanceof StopError) {
+                    recordStop(session, err, ctx.now());
+                    throw new StopError(err.reason, `${err.message}\n${stopHint(err.reason)}`, err.resetAt);
+                }
+                if (!(err instanceof ApiError) || err.status !== null || ctx.signal.aborted)
+                    throw err;
+                offlineStatus(ctx, session, token, overrides, err);
+                return ExitCode.Failure;
+            }
+            clearStop(session);
+            const previousHost = cacheHostIdentity(session.db, token.token, host.host, ctx.now());
+            rememberQuota(session, host.quota, ctx.now());
+            if (previousHost !== null)
+                out.warn(hostChangedWarning(previousHost, host.host));
+            const now = ctx.now();
+            const runner = readRunner(ctx.dirs.data);
+            const board = readDashboard(ctx.dirs.data);
+            const update = noticeUpdate(ctx, session, runner.state === 'running');
+            const compareDir = runner.state === 'running' && runner.info.workersDir
+                ? runner.info.workersDir
+                : projectWorkersDir(session.config);
+            const local = compareDir === null ? null : workerNamesIn(compareDir);
+            const registered = new Set(host.workers.map((w) => w.name));
+            const unregistered = local?.filter((n) => !registered.has(n) && !isReservedWorkerName(n)) ?? [];
+            const localSet = new Set(local ?? []);
+            const builtin = builtinResultsName(host.host.id);
+            const serverOnly = local === null
+                ? []
+                : host.workers.map((w) => w.name).filter((n) => !localSet.has(n) && n !== builtin);
+            const lastEnd = runner.state === 'stopped' ? readEnd(session) : null;
+            const shell = session.config.values;
+            const running = runner.state === 'running' ? runner.info : null;
+            const apiUrl = running?.apiUrl ?? shell.apiUrl;
+            const urlMismatch = running?.apiUrl !== undefined && running.apiUrl !== shell.apiUrl;
+            const mode = running ? runnerMode(running) : shell.receiveMode;
+            const intervalMs = running?.intervalMs ?? shell.pollIntervalMs;
+            const effectiveMs = mode === 'poll' ? Math.max(intervalMs, host.poll.min_interval_ms) : null;
+            const concurrency = running?.concurrency ?? shell.concurrency;
+            const liveState = running && mode === 'live' ? readLiveState(session.db) : null;
+            const results = savedResults(session.config.projectRoot);
+            const usage = hostUsage(session.db, ctx.dirs.logs);
+            const repeats = readRepeats(session.db, session.config.projectRoot);
+            const data = {
+                loggedIn: true,
+                token: { source: token.source, location: token.location },
+                apiUrl: shell.apiUrl,
+                mode,
+                pollIntervalMs: mode === 'poll' ? shell.pollIntervalMs : null,
+                effectivePollIntervalMs: effectiveMs,
+                concurrency,
+                maxTasksPerMinute: effectiveMs === null ? null : maxTasksPerMinute(concurrency, effectiveMs),
+                liveState,
+                host: host.host,
+                workers: host.workers,
+                quota: host.quota,
+                poll: host.poll,
+                localWorkers: local,
+                unregisteredWorkers: unregistered,
+                serverOnlyWorkers: serverOnly,
+                running: runner.state === 'running',
+                runner: runner.state === 'running' ? runner.info : null,
+                repeats,
+                dashboard: dashboardJson(board),
+                lastEnd: lastEnd && { ...lastEnd, endedAt: new Date(lastEnd.endedAt).toISOString() },
+                results,
+                usage: usageJson(usage, session.config.projectRoot, results),
+                overrides,
+                update
+            };
+            const workers = host.workers.map((w) => w.name);
+            out.result(data, [
+                row('host', `${stripControl(host.host.name)} ${out.out.dim(`(${stripControl(host.host.id)})`)}`),
+                row('token', token.source === 'env' ? `from ${token.location}` : `saved in ${token.location}`),
+                ...overrideRows(out, overrides),
+                row('remote', `${apiUrl}${urlMismatch ? out.out.dim(' (runner)') : ''}`),
+                ...(urlMismatch
+                    ? [
+                        row('', `${out.out.yellow('warn')} this shell uses ${shell.apiUrl} — host, workers and quota here come from that server`)
+                    ]
+                    : []),
+                row('workers', workers.length === 0
+                    ? 'none registered yet'
+                    : `${workers.length} (${workers.join(', ')})`),
+                ...(unregistered.length > 0
+                    ? [
+                        row('', `${out.out.yellow('not registered')} ${unregistered.join(', ')} ${out.out.dim(runner.state !== 'running'
+                            ? `· the next '${BIN} start' tries to register them`
+                            : runner.info.reload
+                                ? `· '${BIN} reload' to register`
+                                : `· restart '${BIN} start' to register`)}`)
+                    ]
+                    : []),
+                ...serverOnly.map((n) => row('', `${out.out.yellow('server only')} ${n} ${out.out.dim(`· no file in ${compareDir} — '${BIN} worker delete ${n}' removes it from 3Min API`)}`)),
+                quotaLine(out, host, now),
+                effectiveMs === null
+                    ? row('mode', liveText(out, running !== null, liveState, concurrency, now))
+                    : row('poll', `every ${secs(effectiveMs)}${running ? '' : ' when started'}, ${formatThroughput(concurrency, effectiveMs)} ${out.out.dim(`(server minimum ${secs(host.poll.min_interval_ms)}) · about ${formatCount(Math.round(MONTH_MS / effectiveMs))} calls per month` +
+                        (running && running.intervalMs !== shell.pollIntervalMs
+                            ? ` · runner setting; this shell has ${secs(shell.pollIntervalMs)}`
+                            : ''))}`),
+                row('runner', runnerText(out, runner, now, lastEnd)),
+                ...repeatRows(out, repeats, concurrency, runner.state === 'running'),
+                row('dashboard', dashboardText(out, board, now)),
+                ...storageRows(out, usage, results),
+                ...(running && running.port !== null
+                    ? [row('listen', serveText(out, running.port, running.public, ctx.dirs.config))]
+                    : [])
+            ].join('\n'));
+            return ExitCode.Ok;
+        }
+        finally {
+            session.close();
+        }
+    }
+};
+function overridesIn(ctx, token) {
+    const home = ctx.env[ENV.home];
+    return {
+        home: home && path.isAbsolute(home) ? home : null,
+        token: token.source === 'env'
+    };
+}
+function overrideRows(out, o) {
+    const rows = [];
+    if (o.home !== null) {
+        rows.push(row('', `${out.out.yellow('note')} ${ENV.home} is set — not this PC's default host folder (for development and tests)`));
+    }
+    if (o.token) {
+        rows.push(row('', `${out.out.yellow('note')} ${ENV.token} is set — not the token saved by '${BIN} login' (for development, CI and tests)`));
+    }
+    return rows;
+}
+function usageJson(usage, root, results) {
+    return {
+        controlDb: usage.controlDb,
+        dataDb: root && results
+            ? { file: resultsDbPath(root), bytes: results.dbBytes, results: results.count }
+            : null,
+        logs: usage.logs
+    };
+}
+function storageRows(out, usage, results) {
+    const rows = [];
+    if (usage.controlDb) {
+        const { tasks, unfinished, bytes } = usage.controlDb;
+        rows.push(row('history', `${formatCount(tasks)} task(s)${unfinished > 0 ? `, ${formatCount(unfinished)} not finished` : ''} · control.db ${formatBytes(bytes)} ${out.out.dim(`('${BIN} tasks prune')`)}`));
+    }
+    if (results) {
+        rows.push(row('results', `${formatCount(results.count)} saved · data.db ${formatBytes(results.dbBytes)} ${out.out.dim(`('${BIN} worker results' · never deleted automatically — '${BIN} worker results prune')`)}`));
+    }
+    rows.push(row('logs', `${formatCount(usage.logs.files)} file(s) · ${formatBytes(usage.logs.bytes)} ${out.out.dim(`('${BIN} logs')`)}`));
+    return rows;
+}
+function offlineStatus(ctx, session, token, overrides, err) {
+    const { out } = ctx;
+    const now = ctx.now();
+    const runner = readRunner(ctx.dirs.data);
+    const board = readDashboard(ctx.dirs.data);
+    let cached = null;
+    let last = null;
+    try {
+        const id = session.db.getMeta(HOST_META.id);
+        const name = session.db.getMeta(HOST_META.name);
+        cached = id && name ? { id, name } : null;
+        last = session.db.getQuota();
+    }
+    catch {
+    }
+    const results = savedResults(session.config.projectRoot);
+    const usage = hostUsage(session.db, ctx.dirs.logs);
+    const repeats = readRepeats(session.db, session.config.projectRoot);
+    const running = runner.state === 'running' ? runner.info : null;
+    const shell = session.config.values;
+    const mode = running ? runnerMode(running) : shell.receiveMode;
+    const concurrency = running?.concurrency ?? shell.concurrency;
+    const liveState = running && mode === 'live' ? readLiveState(session.db) : null;
+    const intervalMs = mode === 'poll' ? (running?.intervalMs ?? shell.pollIntervalMs) : null;
+    out.warn(`cannot reach 3Min API (${err.message}) — showing what this PC knows.`);
+    out.result({
+        loggedIn: true,
+        offline: true,
+        error: err.message,
+        token: { source: token.source, location: token.location },
+        apiUrl: session.config.values.apiUrl,
+        host: cached,
+        lastQuota: last && { ...last.quota, at: new Date(last.at).toISOString() },
+        mode,
+        pollIntervalMs: intervalMs,
+        liveState,
+        running: runner.state === 'running',
+        runner: runner.state === 'running' ? runner.info : null,
+        repeats,
+        dashboard: dashboardJson(board),
+        results,
+        usage: usageJson(usage, session.config.projectRoot, results),
+        overrides,
+        update: updateInfo(ctx.version, readLatest(session.db), runner.state === 'running')
+    }, [
+        row('host', cached
+            ? `${cached.name} ${out.out.dim(`(${cached.id}) · last known`)}`
+            : out.out.dim('unknown')),
+        row('token', token.source === 'env' ? `from ${token.location}` : `saved in ${token.location}`),
+        ...overrideRows(out, overrides),
+        row('remote', `${session.config.values.apiUrl} ${out.out.yellow('(not reachable)')}`),
+        last
+            ? row('quota', `${formatCount(last.quota.used)} / ${formatCount(last.quota.limit)} calls used ${out.out.dim(`· last checked ${formatLocal(last.at)} (${relative(last.at, now)}) · resets ${describeAt(last.quota.reset_at, now, { local: true })}`)}`)
+            : row('quota', out.out.dim('unknown — no server response saved yet')),
+        intervalMs === null
+            ? row('mode', liveText(out, running !== null, liveState, concurrency, now))
+            : row('poll', `every ${secs(intervalMs)}${running ? '' : ' when started'} ${out.out.dim('(setting — the server minimum is not known offline)')}`),
+        row('runner', runnerText(out, runner, now, null)),
+        ...repeatRows(out, repeats, (runner.state === 'running' ? runner.info.concurrency : undefined) ??
+            session.config.values.concurrency, runner.state === 'running'),
+        row('dashboard', dashboardText(out, board, now)),
+        ...storageRows(out, usage, results)
+    ].join('\n'));
+}
+function readRepeats(db, root) {
+    let rows;
+    try {
+        rows = db.repeatTasks();
+    }
+    catch {
+        return [];
+    }
+    const saved = savedRuns(root, rows.map((r) => r.task_id));
+    return rows.flatMap((row) => {
+        const settings = parseSettings(row.repeat);
+        if (!settings)
+            return [];
+        return [
+            {
+                task_id: row.task_id,
+                worker: row.worker,
+                runs: row.runs ?? 0,
+                failed: row.failed ?? 0,
+                max_runs: settings.max_runs ?? null,
+                interval_seconds: settings.interval_seconds,
+                next_at: row.next_at == null ? null : new Date(row.next_at).toISOString(),
+                results: saved === null ? null : (saved.get(row.task_id)?.runs ?? 0)
+            }
+        ];
+    });
+}
+function savedRuns(root, ids) {
+    if (!root || ids.length === 0 || resultsDbBytes(root) === null)
+        return null;
+    try {
+        const store = ResultStore.openReadOnly(root);
+        if (!store)
+            return new Map();
+        try {
+            return store.runCounts(ids);
+        }
+        finally {
+            store.close();
+        }
+    }
+    catch {
+        return null;
+    }
+}
+function repeatRows(out, repeats, concurrency, running) {
+    if (repeats.length === 0)
+        return [];
+    return [
+        row('repeating', `${repeats.length} ${out.out.dim(`· runs share the ${concurrency} slot(s) with single tasks`)}`),
+        ...repeats.map((r) => {
+            const failed = r.failed > 0 ? `, ${r.failed} failed` : '';
+            const next = !running || r.next_at === null
+                ? `resumes on '${BIN} start'`
+                : `next ${formatLocal(Date.parse(r.next_at))}`;
+            return row('', `${r.worker}  ${r.task_id.length > 13 ? r.task_id.slice(-12) : r.task_id}  ` +
+                `${r.runs}/${r.max_runs ?? '∞'}${failed} ${out.out.dim(`· every ${r.interval_seconds}s · ${next}` +
+                    (r.results === null ? '' : ` · ${formatCount(r.results)} result row(s) saved`))}`);
+        })
+    ];
+}
+function quotaLine(out, host, now) {
+    const { used, limit, reset_at } = host.quota;
+    const when = describeAt(reset_at, now, { local: true });
+    const usage = `${formatCount(used)} / ${formatCount(limit)} calls used`;
+    return row('quota', `${usage} ${out.out.dim(`· resets ${when}`)}`);
+}
+function runnerText(out, runner, now, lastEnd) {
+    if (runner.state === 'starting')
+        return 'starting';
+    if (runner.state === 'stopped' && lastEnd) {
+        const deleted = lastEnd.deletedWorkers;
+        const why = deleted.length > 0
+            ? `${deleted.join(', ')} ${deleted.length === 1 ? 'was' : 'were'} deleted on the server`
+            : 'no worker could be registered';
+        return (`not running ${out.out.dim(`· ended ${formatLocal(lastEnd.endedAt)} with no active workers (${why})`)}\n` +
+            row('', out.out.dim(`'${BIN} start' registers the workers whose files are still there`)));
+    }
+    if (runner.state === 'stopped')
+        return `not running ${out.out.dim(`· '${BIN} start' to run`)}`;
+    const { pid, startedAt, detached } = runner.info;
+    const where = detached ? 'in the background' : 'in a terminal';
+    return `running ${where} (pid ${pid}) ${out.out.dim(`· since ${formatLocal(startedAt)} (${relative(startedAt, now)})`)}`;
+}
+function elapsed(since, now) {
+    const ago = relative(Math.min(since, now), now);
+    return ago.endsWith(' ago') ? ago.slice(0, -' ago'.length) : 'less than a minute';
+}
+function readLiveState(db) {
+    try {
+        return db.getLiveState();
+    }
+    catch {
+        return null;
+    }
+}
+function liveText(out, running, state, concurrency, now) {
+    const what = `live, up to ${concurrency} at a time ${out.out.dim('· fetches when 3Min API signals; idle ≈ 0 calls')}`;
+    if (!running)
+        return `${what} ${out.out.dim('(when started)')}`;
+    if (state === null || state.since === null)
+        return `${what}\n${row('', 'connecting…')}`;
+    const since = Math.min(Date.parse(state.since), now);
+    const reconnects = state.reconnects > 0
+        ? ` · ${state.reconnects} reconnect${state.reconnects === 1 ? '' : 's'}`
+        : '';
+    if (state.connected) {
+        return `${what}\n${row('', `${out.out.green('connected')} ${out.out.dim(`since ${formatLocal(since)} (${relative(since, now)})${reconnects}`)}`)}`;
+    }
+    const lines = [
+        `${out.out.yellow('disconnected')} for ${elapsed(since, now)} ${out.out.dim(`— no tasks are fetched until it reconnects${reconnects}`)}`,
+        ...(state.lastError ? [out.out.dim(state.lastError)] : []),
+        ...(state.everConnected
+            ? []
+            : [
+                `never connected this run — on a company network, run '${BIN} doctor' or restart with '${BIN} start --mode poll'`
+            ])
+    ];
+    return [what, ...lines.map((l) => row('', l))].join('\n');
+}
+function dashboardJson(board) {
+    return {
+        running: board.state === 'running',
+        info: board.state === 'running' ? board.info : null
+    };
+}
+function dashboardText(out, board, now) {
+    if (board.state === 'starting')
+        return 'starting';
+    if (board.state === 'stopped')
+        return `not running ${out.out.dim(`· '${BIN} dashboard' to open`)}`;
+    const { pid, startedAt, detached, lan, origins } = board.info;
+    const where = detached ? 'in the background' : 'in a terminal';
+    const scope = lan ? ` · ${out.out.yellow('LAN (plain HTTP)')}` : '';
+    const address = origins.length > 0 ? ` · ${origins[lan && origins.length > 1 ? 1 : 0]}` : '';
+    return (`running ${where} (pid ${pid})${scope}${address} ${out.out.dim(`· since ${formatLocal(startedAt)} (${relative(startedAt, now)})`)}\n` +
+        row('', out.out.dim(`'${BIN} dashboard url' for the link · '${BIN} dashboard stop' to stop`)));
+}
+function serveText(out, port, isPublic, configDir) {
+    if (isPublic === undefined)
+        return `port ${port}`;
+    if (isPublic)
+        return `port ${port} on all interfaces ${out.out.dim('(public workers, signed requests only)')}`;
+    return `http://127.0.0.1:${port} ${out.out.dim(`(token in ${path.join(configDir, LOCAL_SERVER_TOKEN_FILE)})`)}`;
+}
+function secs(ms) {
+    return ms % 1000 === 0 ? `${ms / 1000}s` : `${ms} ms`;
+}
+function projectWorkersDir(config) {
+    return config.projectRoot ? workersPath(config.projectRoot, config) : null;
+}
+function workerNamesIn(dir) {
+    if (!statSync(dir, { throwIfNoEntry: false })?.isDirectory())
+        return null;
+    try {
+        return [...workerFiles(dir).keys()];
+    }
+    catch {
+        return null;
+    }
+}
+function savedResults(root) {
+    if (!root)
+        return null;
+    const dbBytes = resultsDbBytes(root);
+    if (dbBytes === null)
+        return null;
+    try {
+        const store = ResultStore.openReadOnly(root);
+        if (!store)
+            return { count: 0, bytes: 0, dbBytes };
+        try {
+            return { ...store.usage(), dbBytes };
+        }
+        finally {
+            store.close();
+        }
+    }
+    catch {
+        return null;
+    }
+}
+function readEnd(session) {
+    try {
+        return session.db.getEnd();
+    }
+    catch {
+        return null;
+    }
+}
+const STATUS_LABEL_WIDTH = 11;
+function row(label, value) {
+    return `${label.padEnd(STATUS_LABEL_WIDTH)}${value}`;
+}
+function warnLooseToken(out, token) {
+    if (token.source !== 'file')
+        return;
+    const mode = looseMode(token.location);
+    if (mode !== null) {
+        out.warn(`${token.location} is readable by other users (mode ${mode.toString(8)}). Run: chmod 600 "${token.location}"`);
+    }
+}

package/dist/commands/common.js

@@ -0,0 +1,48 @@
+import { statSync } from 'node:fs';
+import path from 'node:path';
+import { ApiClient, userAgent } from "../core/api.js";
+import { resolveHostToken } from "../core/credentials.js";
+import { BIN, CliError, ConfigError, PROJECT_CONFIG_FILE } from "../core/domain/index.js";
+import { initHint } from "../core/project.js";
+import { claimUpdateNotice, readLatest, rememberLatest, updateInfo, updateNoticeLine } from "../core/update-notice.js";
+export function client(ctx, session, token) {
+    return new ApiClient({
+        apiUrl: session.config.values.apiUrl,
+        token,
+        userAgent: userAgent(ctx.version, ctx.platform),
+        signal: ctx.signal,
+        onServerCli: (cli) => rememberLatest(session.db, cli, ctx.now(), (m, a) => session.logger.debug(m, a))
+    });
+}
+export function noticeUpdate(ctx, session, running) {
+    const log = (m, a) => session.logger.debug(m, a);
+    const info = updateInfo(ctx.version, readLatest(session.db, log), running);
+    if (claimUpdateNotice(session.db, info, ctx.now(), ctx.env, log)) {
+        ctx.out.warn(updateNoticeLine(info));
+    }
+    return info;
+}
+export function requireToken(ctx) {
+    const token = resolveHostToken(ctx.dirs.config, ctx.env);
+    if (!token)
+        throw new CliError(`Not logged in. Run '${BIN} login' first.`);
+    return token;
+}
+export function requireProject(config) {
+    if (!config.projectRoot) {
+        throw new ConfigError(`this host has no project (no ${PROJECT_CONFIG_FILE} recorded or found in this folder or above). ` +
+            initHint());
+    }
+    return config.projectRoot;
+}
+export function workersPath(root, config) {
+    return path.resolve(root, config.values.workersDir);
+}
+export function requireWorkersDir(config) {
+    const root = requireProject(config);
+    const dir = workersPath(root, config);
+    if (!statSync(dir, { throwIfNoEntry: false })?.isDirectory()) {
+        throw new CliError(`workers folder ${dir} does not exist. Run '${BIN} init' to create it.`);
+    }
+    return { root, dir };
+}