@skrr-ai/cli 0.1.119 → 0.1.120

package/dist/lib/completion-index.d.ts

@@ -13,9 +13,21 @@ export type CompletionIndex = {
 };
 export type CompletionKind = 'project' | 'space' | 'status' | 'task';
 export type CompletionIndexLoader = () => Promise<CompletionIndex>;
-export declare function completionIndexPath(cacheDir: string): string;
+export type CompletionCacheScope = {
+    namespace: string;
+    credentialDigest: string;
+};
+/** Bind references to the command's resolved context, never a stored login. */
+export declare function createCompletionCacheScope(context: {
+    configRoot: string;
+    profile: string;
+    baseURL: string;
+    workspaceId?: string;
+    token?: string | null;
+}): CompletionCacheScope | null;
+export declare function completionIndexPath(cacheDir: string, scope: CompletionCacheScope): string;
 /** Read corruption as a cache miss: a completion request should never fail a shell line. */
-export declare function readCompletionIndex(cacheDir: string): Promise<CompletionIndex | null>;
+export declare function readCompletionIndex(cacheDir: string, scope: CompletionCacheScope | null): Promise<CompletionIndex | null>;
 /**
  * Build from the three lightweight list endpoints.  The cache deliberately
  * stores identifiers/ref values, not titles or descriptions, both because a
@@ -27,5 +39,5 @@ export declare function loadCompletionIndex(): Promise<CompletionIndex>;
  * Refresh is best-effort by contract.  A healthy cached index remains usable
  * during an outage; a first-use outage simply produces no dynamic candidates.
  */
-export declare function refreshCompletionIndex(cacheDir: string, loader?: CompletionIndexLoader): Promise<CompletionIndex | null>;
-export declare function completionCandidates(cacheDir: string, kind: CompletionKind, query?: string, loader?: CompletionIndexLoader): Promise<string[]>;
+export declare function refreshCompletionIndex(cacheDir: string, scope: CompletionCacheScope | null, loader?: CompletionIndexLoader): Promise<CompletionIndex | null>;
+export declare function completionCandidates(cacheDir: string, scope: CompletionCacheScope | null, kind: CompletionKind, query?: string, loader?: CompletionIndexLoader): Promise<string[]>;

package/dist/lib/completion-index.js

@@ -33,6 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCompletionCacheScope = createCompletionCacheScope;
 exports.completionIndexPath = completionIndexPath;
 exports.readCompletionIndex = readCompletionIndex;
 exports.loadCompletionIndex = loadCompletionIndex;
@@ -40,8 +41,32 @@ exports.refreshCompletionIndex = refreshCompletionIndex;
 exports.completionCandidates = completionCandidates;
 const fs = __importStar(require("node:fs/promises"));
 const path = __importStar(require("node:path"));
-const INDEX_FILE = 'index.json';
+const node_crypto_1 = require("node:crypto");
 const INDEX_VERSION = 1;
+const CACHE_VERSION = 2;
+/** Bind references to the command's resolved context, never a stored login. */
+function createCompletionCacheScope(context) {
+    if (!context.token)
+        return null;
+    try {
+        const hash = (value) => (0, node_crypto_1.createHash)('sha256').update(value).digest('hex');
+        // The adapter appends API paths to the full request base. Preserve deployment
+        // prefixes, queries and fragments; normalize its trailing-slash handling.
+        const requestBase = new URL(context.baseURL.replace(/\/+$/, '')).href;
+        return {
+            namespace: hash(JSON.stringify([
+                path.resolve(context.configRoot), context.profile,
+                requestBase, context.workspaceId || '',
+            ])),
+            // A different actor or rotated credential invalidates the existing file.
+            // Keep the filename stable so refreshes do not accumulate token-keyed files.
+            credentialDigest: hash(`completion-cache-v2\0${context.token}`),
+        };
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Delay loading transport modules until a refresh is actually needed.  The
  * shell's common cached path stays tiny, and cache-only unit tests do not need
@@ -65,8 +90,8 @@ function values(rows, ...keys) {
 function unique(entries) {
     return [...new Set(entries.map((entry) => entry.trim()).filter(Boolean))].sort((a, b) => a.localeCompare(b));
 }
-function completionIndexPath(cacheDir) {
-    return path.join(cacheDir, 'completion', INDEX_FILE);
+function completionIndexPath(cacheDir, scope) {
+    return path.join(cacheDir, 'completion', 'v2', `${scope.namespace}.json`);
 }
 function isCompletionIndex(value) {
     const index = value;
@@ -76,10 +101,14 @@ function isCompletionIndex(value) {
         ['projects', 'spaces', 'statuses', 'tasks'].every((key) => Array.isArray(index[key])));
 }
 /** Read corruption as a cache miss: a completion request should never fail a shell line. */
-async function readCompletionIndex(cacheDir) {
+async function readCompletionIndex(cacheDir, scope) {
+    if (!scope)
+        return null;
     try {
-        const parsed = JSON.parse(await fs.readFile(completionIndexPath(cacheDir), 'utf8'));
-        return isCompletionIndex(parsed) ? parsed : null;
+        const parsed = JSON.parse(await fs.readFile(completionIndexPath(cacheDir, scope), 'utf8'));
+        return parsed?.version === CACHE_VERSION && parsed.namespace === scope.namespace &&
+            parsed.credentialDigest === scope.credentialDigest && isCompletionIndex(parsed.index)
+            ? parsed.index : null;
     }
     catch {
         return null;
@@ -123,13 +152,14 @@ async function loadCompletionIndex() {
         tasks: unique(values(tasks, 'identifier')),
     };
 }
-async function writeCompletionIndex(cacheDir, index) {
-    const file = completionIndexPath(cacheDir);
+async function writeCompletionIndex(cacheDir, scope, index) {
+    const file = completionIndexPath(cacheDir, scope);
     const directory = path.dirname(file);
     await fs.mkdir(directory, { recursive: true, mode: 0o700 });
     const temporary = `${file}.${process.pid}.${Date.now()}.tmp`;
     try {
-        await fs.writeFile(temporary, `${JSON.stringify(index)}\n`, { encoding: 'utf8', mode: 0o600 });
+        const record = { version: CACHE_VERSION, ...scope, index };
+        await fs.writeFile(temporary, `${JSON.stringify(record)}\n`, { encoding: 'utf8', mode: 0o600 });
         await fs.rename(temporary, file);
     }
     finally {
@@ -140,20 +170,26 @@ async function writeCompletionIndex(cacheDir, index) {
  * Refresh is best-effort by contract.  A healthy cached index remains usable
  * during an outage; a first-use outage simply produces no dynamic candidates.
  */
-async function refreshCompletionIndex(cacheDir, loader = loadCompletionIndex) {
+async function refreshCompletionIndex(cacheDir, scope, loader = loadCompletionIndex) {
+    // Static command/flag completion still works before login. Workspace lists
+    // need an explicit current credential, including for doctor and --bare.
+    if (!scope)
+        return null;
     try {
         const index = await loader();
-        await writeCompletionIndex(cacheDir, index);
+        await writeCompletionIndex(cacheDir, scope, index);
         return index;
     }
     catch {
         return null;
     }
 }
-async function completionCandidates(cacheDir, kind, query = '', loader = loadCompletionIndex) {
-    let index = await readCompletionIndex(cacheDir);
+async function completionCandidates(cacheDir, scope, kind, query = '', loader = loadCompletionIndex) {
+    if (!scope)
+        return [];
+    let index = await readCompletionIndex(cacheDir, scope);
     if (!index)
-        index = await refreshCompletionIndex(cacheDir, loader);
+        index = await refreshCompletionIndex(cacheDir, scope, loader);
     if (!index)
         return [];
     const needle = query.trim().toLocaleLowerCase();

package/dist/lib/config.js

@@ -56,6 +56,7 @@ const os = __importStar(require("node:os"));
 const path = __importStar(require("node:path"));
 const keychain_1 = require("./keychain");
 const auth_core_1 = require("@skrr-ai/auth-core");
+const auth_diagnostics_1 = require("./auth-diagnostics");
 const cli_id_1 = require("./cli-id");
 const device_id_1 = require("./device-id");
 const publicEndpoints_generated_1 = require("./publicEndpoints.generated");
@@ -205,8 +206,13 @@ function envOverlayValue(key) {
     const renamed = process.env[renamedName]?.trim();
     if (legacy && renamed && legacy !== renamed && !warnedEnvPrefixConflict) {
         warnedEnvPrefixConflict = true;
+        const display = (value) => {
+            if (key === 'token' || key === 'refreshToken')
+                return '[redacted]';
+            return (0, auth_diagnostics_1.safeServerOrigin)(value) ?? '[invalid URL]';
+        };
         process.stderr.write(`warning: ${legacyName} and ${renamedName} are both set and disagree. ` +
-            `Using ${legacyName}=${legacy}.\n`);
+            `Using ${legacyName}=${display(legacy)}.\n`);
     }
     return legacy && legacy.length > 0 ? legacy : renamed && renamed.length > 0 ? renamed : undefined;
 }

package/dist/lib/daemon-maintenance-command.d.ts

@@ -0,0 +1,22 @@
+import { BaseCommand } from '../base-command';
+import { type MaintenanceRun } from './daemon-maintenance';
+/**
+ * The part of `skrr daemon maintenance *` every command shares: how a finished run
+ * is printed, and how the command exits.
+ *
+ * With `--json` exactly one document goes to stdout, through `printJsonResult` so it
+ * carries `ok` first like every other command's result, and nothing else does:
+ * progress is always stderr. Without it a person gets the lines the run produced,
+ * results on stdout and refusals on stderr. The exit code is the run's, and it is
+ * the one thing a script gates on: 0 ready (or done), 1 refused, 2 still pending at
+ * the timeout, 3 unknown.
+ */
+export declare abstract class DaemonMaintenanceCommand extends BaseCommand {
+    /**
+     * A progress line. stderr, always, so `--json` stdout stays one document. A method,
+     * not an arrow property: a test builds a command with `Object.create(prototype)`,
+     * which never runs a constructor, and a property would be missing there.
+     */
+    protected progressLine(line: string): void;
+    protected conclude(run: MaintenanceRun, json: boolean | undefined): void;
+}

package/dist/lib/daemon-maintenance-command.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DaemonMaintenanceCommand = void 0;
+const base_command_1 = require("../base-command");
+/**
+ * The part of `skrr daemon maintenance *` every command shares: how a finished run
+ * is printed, and how the command exits.
+ *
+ * With `--json` exactly one document goes to stdout, through `printJsonResult` so it
+ * carries `ok` first like every other command's result, and nothing else does:
+ * progress is always stderr. Without it a person gets the lines the run produced,
+ * results on stdout and refusals on stderr. The exit code is the run's, and it is
+ * the one thing a script gates on: 0 ready (or done), 1 refused, 2 still pending at
+ * the timeout, 3 unknown.
+ */
+class DaemonMaintenanceCommand extends base_command_1.BaseCommand {
+    /**
+     * A progress line. stderr, always, so `--json` stdout stays one document. A method,
+     * not an arrow property: a test builds a command with `Object.create(prototype)`,
+     * which never runs a constructor, and a property would be missing there.
+     */
+    progressLine(line) {
+        process.stderr.write(`${line}\n`);
+    }
+    conclude(run, json) {
+        if (json) {
+            this.printJsonResult(run.document, { ok: run.exit === 0 });
+        }
+        else {
+            for (const line of run.stdout)
+                this.log(line);
+            for (const line of run.stderr)
+                process.stderr.write(`${line}\n`);
+        }
+        if (run.exit !== 0)
+            this.exit(run.exit);
+    }
+}
+exports.DaemonMaintenanceCommand = DaemonMaintenanceCommand;

package/dist/lib/daemon-maintenance.d.ts

@@ -0,0 +1,275 @@
+import { DAEMON_MAINTENANCE_EXIT_CODES, type DaemonMaintenanceAttestationRequest, type DaemonMaintenanceChangeRequest, type DaemonMaintenanceDaemonRef, type DaemonMaintenanceOutcome, type DaemonMaintenanceSummary, type DaemonMaintenanceView } from '@skrr-ai/data-provider';
+import { type Machine } from './machines';
+/**
+ * daemon-maintenance.ts — the owner's pause on one of their own machines, from the
+ * terminal (`skrr daemon maintenance status | hold | resume | attest`; OSK-19107,
+ * Space OSK-S-524, plan §3.6, journey J12).
+ *
+ * ## What this file does NOT do
+ *
+ * It declares no phase, cause, refusal, control or word. All of them are owned by
+ * `@skrr-ai/data-provider` (`daemonMaintenance.ts`) and imported: the SERVER decides
+ * which phase a machine is in (`deriveMaintenanceJourney`), this file renders what
+ * the server answered. A synonym spelled here is the drift that module exists to stop.
+ *
+ * It never builds an `/api/...` URL. Every call is a `dataService` function
+ * (`listDaemonMaintenance` and its three siblings), which is how
+ * `domain-api-parity.spec.ts` sees this domain.
+ *
+ * ## The contract a script can rely on
+ *
+ * With `--json` every command writes EXACTLY ONE JSON object to stdout and nothing
+ * else (progress goes to stderr), with `schema: 1` and a `command` and an `outcome`.
+ * The exit code follows `scripts/release-status.js` and is in the document as
+ * `exit`: `DAEMON_MAINTENANCE_EXIT_CODES` — 0 ready, 1 refused, 2 still pending at
+ * the timeout, 3 unknown.
+ *
+ *  - Only `hold --wait ready` and a command that could not read the state end in 2 or 3.
+ *    `status`, a `hold` that did not wait, `resume` and `attest` end in 0 when they did
+ *    what was asked, and in 1 when the server (or this CLI, before asking) refused.
+ *  - **A timeout NEVER releases the hold**, and the document and the text both say so
+ *    (`holdInForce: true`). A script cannot mistake "timed out" for "ready", and a
+ *    person is told the one command that lets go.
+ *  - A state this CLI could not read (the network, a 5xx, a 429) is `unknown`, exit 3:
+ *    "I could not tell" is an answer, and it is never rendered as `ready` or as zero.
+ *
+ * ## Naming a machine, and why it never picks
+ *
+ * `<machine>` is a machine id, a name, or a runtimeKey. A hold addresses ONE
+ * `runtimeKey` (one daemon, so one profile), and one machine can span several, so a
+ * machine that is two daemons is ambiguous by construction. Resolution therefore
+ * REFUSES with the candidates when a reference matches zero or more than one, and
+ * the only inference it makes is the unambiguous one: no reference given and exactly
+ * one daemon that qualifies.
+ */
+/** The version of the documents `--json` prints. Bump it when a field's meaning changes. */
+export declare const DAEMON_MAINTENANCE_CLI_SCHEMA: 1;
+/** How often `--wait` reads the state, and how long it waits when no timeout is given. */
+export declare const MAINTENANCE_POLL_INTERVAL_MS = 5000;
+export declare const MAINTENANCE_DEFAULT_TIMEOUT_MS: number;
+export declare const MAINTENANCE_MAX_TIMEOUT_MS: number;
+/** A machine from `GET /api/machines`, with the two additive maintenance fields. */
+export type MaintenanceMachineRow = Machine & {
+    daemons?: DaemonMaintenanceDaemonRef[];
+    maintenance?: DaemonMaintenanceSummary;
+};
+/** One daemon a hold can address. */
+export interface MaintenanceCandidate {
+    runtimeKey: string;
+    machineId?: string;
+    name?: string;
+    profile?: string | null;
+    daemonId?: string;
+    held?: boolean;
+}
+/** A refusal as a value: the code is the vocabulary's (or a transport word), the message is a sentence. */
+export interface MaintenanceRefusal {
+    code: string;
+    message: string;
+    status?: number;
+    currentGeneration?: number;
+    /** Machine candidates from this CLI's own resolution, or machine uuids from a server `ambiguous`. */
+    candidates?: Array<MaintenanceCandidate | string>;
+    retryAfterMs?: number;
+}
+export type MaintenanceFailure = MaintenanceRefusal & {
+    /** `refused`: an answer (do not retry unchanged). `unknown`: no answer (the state is NOT known). */
+    kind: 'refused' | 'unknown';
+};
+export type MaintenanceResult<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: MaintenanceFailure;
+};
+/**
+ * Every call this CLI makes. A plain mutable object so a test replaces one member
+ * without touching a module: the real members are `dataService` functions and the
+ * machine list, nothing else.
+ */
+export declare const maintenanceApi: {
+    listMachines: () => Promise<MaintenanceMachineRow[]>;
+    list: () => Promise<{
+        holds: DaemonMaintenanceView[];
+    }>;
+    get: (runtimeKey: string) => Promise<DaemonMaintenanceView>;
+    change: (runtimeKey: string, body: DaemonMaintenanceChangeRequest) => Promise<DaemonMaintenanceView>;
+    attest: (runtimeKey: string, body: DaemonMaintenanceAttestationRequest) => Promise<DaemonMaintenanceView>;
+};
+export type MaintenanceApi = typeof maintenanceApi;
+/** The clock and the sleep `--wait` uses, replaceable so a timeout takes no time to test. */
+export declare const maintenanceClock: {
+    now: () => number;
+    sleep: (ms: number) => Promise<void>;
+};
+/**
+ * What a failed call means. Two kinds, and the difference is the whole design:
+ *
+ *  - `refused`: the server ANSWERED no (a 4xx other than 429). The answer carries a
+ *    code the vocabulary knows, or a transport word (`invalid_request`,
+ *    `unauthorized`), and a sentence. Repeating the request unchanged repeats it.
+ *  - `unknown`: there was NO answer (the network, a 5xx, a 429). Nothing is known
+ *    about the machine's state from it, so it is never reported as a refusal or as
+ *    "not held".
+ */
+export declare function failureFromError(err: unknown): MaintenanceFailure;
+/** Run one call and turn what it throws into a value. */
+export declare function attempt<T>(call: () => Promise<T>): Promise<MaintenanceResult<T>>;
+/** A runtimeKey needs no lookup: the server decides whether it is one of ours. */
+export declare function looksLikeRuntimeKey(ref: string): boolean;
+export type TargetScope = 'any' | 'held';
+export type Resolution = {
+    ok: true;
+    target: MaintenanceCandidate;
+} | {
+    ok: false;
+    refusal: MaintenanceRefusal;
+};
+/**
+ * Which daemon a reference names. Pure: the lists are passed in.
+ *
+ * A reference is matched in three tiers and the FIRST tier with any match decides:
+ * an exact id or runtimeKey, then an exact name (any case), then a unique id prefix of
+ * at least four characters. Within the tier the answer is the set of matching
+ * DAEMONS, and a set of anything but one is a refusal that lists them.
+ *
+ * `scope: 'held'` (resume, attest) considers only daemons with a live hold: naming a
+ * machine that is not held is `not_held`, not a pick of some other machine.
+ *
+ * With no reference, the one candidate that qualifies is used and anything else is a
+ * refusal listing them: `hold` with no argument on an account with a single
+ * machine is not a guess, and on an account with two it never picks.
+ */
+export declare function resolveMaintenanceTarget(input: {
+    ref?: string;
+    machines?: MaintenanceMachineRow[];
+    holds?: DaemonMaintenanceView[];
+    scope: TargetScope;
+}): Resolution;
+export interface WaitResult {
+    /**
+     * `ready`: the server says ready. `timeout`: it did not, in time, and the hold is
+     * STILL IN FORCE. `released`: the hold is gone (someone resumed it), so there is
+     * nothing left to wait for. `refused`: the server refused the read itself.
+     */
+    outcome: 'ready' | 'timeout' | 'released' | 'refused';
+    view: DaemonMaintenanceView | null;
+    error: MaintenanceFailure | null;
+    polls: number;
+    waitedMs: number;
+}
+/** The word and cause a progress line shows: the vocabulary's word, and the cause code as is. */
+export declare function stateLine(view: DaemonMaintenanceView): string;
+/**
+ * Poll the view until it says `ready`, the hold is gone, or the timeout passes.
+ *
+ * It stops waiting the moment the machine is `ready`; otherwise it keeps waiting until
+ * the timeout, because the server — not this loop — decides that `unknown` or
+ * `back_held` is final. At least one read is made even with a zero timeout. A read
+ * that cannot be answered (the network, a 5xx, a 429) is retried until the timeout and
+ * is never taken for progress, or for readiness; a read the server REFUSES (a 404, a
+ * 403) ends the wait.
+ *
+ * Reaching the timeout does nothing to the hold. This function has no way to release
+ * one: it is given a `read` and nothing else.
+ */
+export declare function waitForReady(io: {
+    read: () => Promise<MaintenanceResult<DaemonMaintenanceView>>;
+    now: () => number;
+    sleep: (ms: number) => Promise<void>;
+    progress: (line: string) => void;
+}, options: {
+    timeoutMs: number;
+    intervalMs: number;
+}): Promise<WaitResult>;
+export type MaintenanceCommandName = 'status' | 'hold' | 'resume' | 'attest';
+export type MaintenanceExitCode = (typeof DAEMON_MAINTENANCE_EXIT_CODES)[keyof typeof DAEMON_MAINTENANCE_EXIT_CODES];
+/** What a run produces: the one `--json` document, the exit code, and the text for a person. */
+export interface MaintenanceRun {
+    document: Record<string, unknown>;
+    exit: MaintenanceExitCode;
+    /** Printed to stdout when not `--json`. */
+    stdout: string[];
+    /** Printed to stderr when not `--json` (errors, refusals, and what to do next). */
+    stderr: string[];
+}
+export interface MaintenanceIo {
+    api: MaintenanceApi;
+    now: () => number;
+    sleep: (ms: number) => Promise<void>;
+    /** A progress line. Always stderr, so stdout stays one document. */
+    progress: (line: string) => void;
+}
+export declare function defaultIo(progress: (line: string) => void): MaintenanceIo;
+/**
+ * What became of the work a released hold had parked (OSK-19623): one summary line and, where
+ * something could not restart or ran out of time, one line per cause in the CLI's own words.
+ *
+ * A count that was never measured is "not counted", never zero, and a re-drive that has not
+ * finished says so: the numbers are what it has done so far. The causes are closed classes
+ * (`DAEMON_MAINTENANCE_RESTART_REFUSAL_WORDS`), so nothing here prints a run id or a reason
+ * the server wrote.
+ */
+export declare function outcomeLines(outcome: DaemonMaintenanceOutcome | null | undefined): string[];
+/** The lines `status` and the end of `hold` print for one machine. */
+export declare function describeView(view: DaemonMaintenanceView, options?: {
+    explain?: boolean;
+}): string[];
+/** `--explain`: each source the reading used, in the order it was read, and what each said. */
+export declare function explainLines(view: DaemonMaintenanceView): string[];
+/** `status`: every hold the owner has, or one machine's state. */
+export declare function runStatus(input: {
+    ref?: string;
+    explain?: boolean;
+}, io: MaintenanceIo): Promise<MaintenanceRun>;
+export interface HoldInput {
+    ref?: string;
+    reason?: string;
+    autoResume?: boolean;
+    /** Wait for `ready`. Undefined: take the hold and return. */
+    wait?: {
+        timeoutMs: number;
+        intervalMs?: number;
+    };
+    explain?: boolean;
+}
+/**
+ * `hold`: take the hold, and optionally wait for the machine to be ready.
+ *
+ * A hold already in force is not a refusal here: asking to hold a machine you have
+ * already held is the retry after a lost response, or the re-run after a Ctrl-C
+ * during `--wait`. The live hold is reported (`created: false`), its reason is kept
+ * and a different `--reason` is said to have been ignored, and `--wait` then waits
+ * on it.
+ */
+export declare function runHold(input: HoldInput, io: MaintenanceIo): Promise<MaintenanceRun>;
+export interface ResumeInput {
+    ref?: string;
+    generation?: number;
+}
+/** `resume`: release the hold. A compare-and-set on the generation. */
+export declare function runResume(input: ResumeInput, io: MaintenanceIo): Promise<MaintenanceRun>;
+export interface AttestInput {
+    ref?: string;
+    kind: 'attest_ready' | 'proceed_anyway';
+    generation?: number;
+}
+/** The labels of the work the reading shows, for a `proceed_anyway` the owner confirmed. */
+export declare function holdersShown(view: DaemonMaintenanceView): string[];
+/**
+ * `attest`: the owner says the machine is ready (`--ready`, only where the server
+ * allows it) or proceeds anyway (`--proceed`, naming what was running). The server
+ * decides whether an attestation applies; the CLI never decides it from a phase.
+ */
+export declare function runAttest(input: AttestInput, io: MaintenanceIo): Promise<MaintenanceRun>;
+/** `--timeout`, parsed and bounded. */
+export declare function parseTimeout(value: string | undefined): {
+    ok: true;
+    ms: number;
+} | {
+    ok: false;
+    message: string;
+};
+/** A failed flag, as a refusal the command prints the way every other refusal is printed. */
+export declare function invalidFlagRun(command: MaintenanceCommandName, message: string): MaintenanceRun;