@tuanhv/op-cli 0.1.0

package/dist/context/profile.js

@@ -0,0 +1,218 @@
+import { chmod, mkdir, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { OpCliError } from "../core/errors.js";
+export const LOGIN_PROFILE = "default";
+function writableConfigDirectory(env) {
+    if (env.OP_CLI_CONFIG_DIR) {
+        return env.OP_CLI_CONFIG_DIR;
+    }
+    const home = env.HOME;
+    if (!home) {
+        throw new OpCliError("USAGE_ERROR");
+    }
+    return join(home, ".config", "op-cli");
+}
+async function readStored(env) {
+    const directory = env.OP_CLI_CONFIG_DIR ??
+        (env.HOME !== undefined ? join(env.HOME, ".config", "op-cli") : undefined);
+    if (directory === undefined) {
+        return undefined;
+    }
+    try {
+        const config = JSON.parse(await readFile(join(directory, "config.json"), "utf8"));
+        let credentials = {};
+        try {
+            credentials = JSON.parse(await readFile(join(directory, "credentials.json"), "utf8"));
+        }
+        catch {
+            // Credentials are optional when only the profile identity is needed,
+            // e.g. --version reading cached metadata without an API key.
+        }
+        // `profiles` is required by the type but comes straight from JSON, so a
+        // config file that parses without it would otherwise reach every caller
+        // as a missing map. Normalising here keeps the guards downstream simple.
+        return {
+            config: { ...config, profiles: config.profiles ?? {} },
+            credentials,
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+async function writeStored(env, parts) {
+    const directory = writableConfigDirectory(env);
+    await mkdir(directory, { recursive: true });
+    if (parts.config) {
+        await writeFile(join(directory, "config.json"), `${JSON.stringify(parts.config, null, 2)}\n`);
+    }
+    if (!parts.credentials) {
+        return;
+    }
+    const credentialsPath = join(directory, "credentials.json");
+    await writeFile(credentialsPath, `${JSON.stringify(parts.credentials, null, 2)}\n`, {
+        mode: 0o600,
+    });
+    await chmod(credentialsPath, 0o600);
+}
+export async function saveProfile(env, instanceUrl, apiKey, name = LOGIN_PROFILE, project) {
+    const state = await readStored(env);
+    const profiles = {
+        ...state?.config.profiles,
+        [name]: project === undefined
+            ? { url: instanceUrl }
+            : { url: instanceUrl, project },
+    };
+    const credentials = {
+        ...state?.credentials,
+        [name]: { api_key: apiKey },
+    };
+    const config = { profiles };
+    // Only the first login ever claims default+active; logging into another
+    // profile merges alongside instead of stealing the selection.
+    config.default_profile =
+        state?.config.default_profile ?? name;
+    config.active_profile = state?.config.active_profile ?? name;
+    await writeStored(env, { config, credentials });
+}
+function storedSelectedName(state) {
+    const { config } = state;
+    if (config.active_profile && config.profiles[config.active_profile]) {
+        return config.active_profile;
+    }
+    if (config.default_profile && config.profiles[config.default_profile]) {
+        return config.default_profile;
+    }
+    return undefined;
+}
+export async function listProfiles(env) {
+    const state = await readStored(env);
+    if (!state) {
+        throw new OpCliError("PROFILE_NOT_FOUND");
+    }
+    const profiles = Object.entries(state.config.profiles ?? {}).map(([name, entry]) => ({
+        name,
+        instanceUrl: entry.url.replace(/\/+$/, ""),
+        project: entry.project,
+    }));
+    return { activeName: storedSelectedName(state), profiles };
+}
+export async function setActiveProfile(env, name, options = {}) {
+    const state = await readStored(env);
+    if (!state || !state.config.profiles[name]) {
+        throw new OpCliError("PROFILE_NOT_FOUND");
+    }
+    const profiles = {
+        ...state.config.profiles,
+    };
+    const entry = state.config.profiles[name];
+    if (options.project !== undefined && entry !== undefined) {
+        profiles[name] = { ...entry, project: options.project };
+    }
+    const config = { active_profile: name, profiles };
+    if (state.config.default_profile !== undefined) {
+        config.default_profile = state.config.default_profile;
+    }
+    await writeStored(env, { config });
+}
+export async function requireStoredName(env) {
+    const state = await readStored(env);
+    const name = state ? storedSelectedName(state) : undefined;
+    if (!name) {
+        throw new OpCliError("PROFILE_NOT_FOUND");
+    }
+    return name;
+}
+export async function removeProfile(env, name) {
+    const state = await readStored(env);
+    if (!state || !(state.config.profiles[name] || state.credentials[name])) {
+        throw new OpCliError("PROFILE_NOT_FOUND");
+    }
+    const credentials = { ...state.credentials };
+    delete credentials[name];
+    await writeStored(env, { credentials });
+}
+export const ENV_PROFILE_NAME = "env";
+function firstDefined(...values) {
+    for (const value of values) {
+        if (value) {
+            return value;
+        }
+    }
+    return undefined;
+}
+export function parseOptionalId(raw) {
+    if (raw === undefined || raw === "") {
+        return undefined;
+    }
+    const value = Number(raw);
+    if (!Number.isInteger(value) || value <= 0) {
+        throw new OpCliError("USAGE_ERROR");
+    }
+    return value;
+}
+export async function resolveProfile(env, overrides = {}) {
+    const state = await readStored(env);
+    const explicitName = firstDefined(overrides.profile, env.OP_CLI_PROFILE);
+    // A named profile has to exist, whether or not a config file was ever
+    // written: environment variables alone form an implicit *unnamed* profile,
+    // so no name can select it. Falling through here would run the named
+    // command against the environment instance and report it as healthy.
+    if (explicitName !== undefined && !state?.config.profiles[explicitName]) {
+        throw new OpCliError("PROFILE_NOT_FOUND");
+    }
+    const storedName = state ? storedSelectedName(state) : undefined;
+    const name = explicitName ?? storedName;
+    const entry = name !== undefined ? state?.config.profiles[name] : undefined;
+    const secret = name !== undefined ? state?.credentials[name]?.api_key : undefined;
+    // An explicit --profile flag sits at the top of the documented order: the
+    // named entry's own URL and key beat the environment for this command.
+    // OP_CLI_PROFILE stays in the environment tier: environment first, then the
+    // selected entry's stored values (#20).
+    const flagCarriesValues = overrides.profile !== undefined;
+    const instanceUrl = (flagCarriesValues
+        ? firstDefined(entry?.url, env.OPENPROJECT_URL)
+        : firstDefined(env.OPENPROJECT_URL, entry?.url))?.replace(/\/+$/, "");
+    const apiKey = flagCarriesValues
+        ? firstDefined(secret, env.OPENPROJECT_API_KEY)
+        : firstDefined(env.OPENPROJECT_API_KEY, secret);
+    if (!instanceUrl) {
+        throw new OpCliError("PROFILE_NOT_FOUND");
+    }
+    if (!apiKey) {
+        throw new OpCliError("AUTH_FAILED");
+    }
+    // Claim the profile name only when its own values were actually used; a run
+    // served by the environment renders as the environment profile so it can
+    // never contradict what auth list shows for that name.
+    const claimsProfile = entry !== undefined &&
+        name !== undefined &&
+        instanceUrl === entry.url.replace(/\/+$/, "") &&
+        apiKey === secret;
+    return {
+        name: claimsProfile ? name : ENV_PROFILE_NAME,
+        instanceUrl,
+        apiKey,
+        project: overrides.project ??
+            parseOptionalId(env.OP_CLI_PROJECT) ??
+            entry?.project,
+    };
+}
+// Resolves the active profile identity without requiring credentials, for
+// read-only commands such as --version that must run without an API key.
+export async function peekActiveProfile(env) {
+    const state = await readStored(env);
+    const explicitName = env.OP_CLI_PROFILE;
+    const storedName = state ? storedSelectedName(state) : undefined;
+    const name = explicitName ?? storedName;
+    const entry = name !== undefined ? state?.config.profiles[name] : undefined;
+    const instanceUrl = firstDefined(env.OPENPROJECT_URL, entry?.url)?.replace(/\/+$/, "");
+    if (!instanceUrl) {
+        return undefined;
+    }
+    return {
+        name: entry !== undefined && name !== undefined ? name : ENV_PROFILE_NAME,
+        instanceUrl,
+    };
+}
+//# sourceMappingURL=profile.js.map

package/dist/context/resolve.js

@@ -0,0 +1,96 @@
+import { OpCliError } from "../core/errors.js";
+export function isIdForm(raw) {
+    return /^\d+$/.test(raw);
+}
+/**
+ * The explicit `customFieldN` spelling of a field key. It is accepted
+ * wherever a human field name is, to disambiguate a name defined by more
+ * than one work package type.
+ */
+export function explicitCustomFieldKey(raw) {
+    const normalized = raw.toLowerCase();
+    return /^customfield\d+$/.test(normalized)
+        ? normalized.replace(/^customfield/, "customField")
+        : undefined;
+}
+/**
+ * Exact-name matching over one vocabulary snapshot. Entries carrying the
+ * same value collapse together (the same user may sit in several
+ * memberships); distinct values under one name are ambiguous.
+ */
+export function matchByName(raw, entries) {
+    const hits = entries.filter((entry) => entry.name === raw);
+    if (hits.length === 0) {
+        return { kind: "missing" };
+    }
+    const distinct = new Map();
+    for (const entry of hits) {
+        const key = typeof entry.value === "string" ? entry.value : String(entry.value);
+        if (!distinct.has(key)) {
+            distinct.set(key, entry);
+        }
+    }
+    const candidates = [...distinct.values()];
+    return candidates.length === 1
+        ? { kind: "unique", entry: candidates[0] }
+        : { kind: "ambiguous", candidates };
+}
+function editDistance(a, b) {
+    let previous = Array.from({ length: b.length + 1 }, (_, i) => i);
+    for (let i = 1; i <= a.length; i += 1) {
+        const current = [i];
+        for (let j = 1; j <= b.length; j += 1) {
+            current[j] = Math.min(previous[j] + 1, current[j - 1] + 1, previous[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+        }
+        previous = current;
+    }
+    return previous[b.length];
+}
+/**
+ * Valid values ordered by closeness to what the caller typed (case
+ * ignored), ties alphabetical, so a failed resolution teaches instead of
+ * just failing.
+ */
+export function rankByCloseness(raw, names) {
+    const needle = raw.toLowerCase();
+    return [...new Set(names)].sort((a, b) => editDistance(needle, a.toLowerCase()) - editDistance(needle, b.toLowerCase())
+        || a.localeCompare(b));
+}
+function missingError(raw, source, names) {
+    const hint = "run op-cli meta refresh if the instance changed recently.";
+    // An empty vocabulary has nothing to rank, and "closest first: ." reads
+    // as a rendering fault rather than as the fact that there is no
+    // candidate at all.
+    if (names.length === 0) {
+        return new OpCliError("USAGE_ERROR", `${source.label} "${raw}" not found; no ${source.label} is available to match.`, hint);
+    }
+    return new OpCliError("USAGE_ERROR", `${source.label} "${raw}" not found. Valid values, closest first: `
+        + `${rankByCloseness(raw, names).join(", ")}.`, hint);
+}
+function ambiguityError(raw, source, candidates) {
+    const listed = candidates
+        .map((candidate) => `${String(candidate.value)} (${candidate.owner})`)
+        .join(", ");
+    return new OpCliError("USAGE_ERROR", `${source.label} "${raw}" is ambiguous. Candidates: ${listed}.`, "repeat the value in the explicit id or key form of one candidate.");
+}
+/**
+ * Resolve a non-id value against metadata: exact match wins, a miss
+ * triggers exactly one refresh and one retry, and every remaining failure
+ * is a loud exit-1 misuse that never guesses on the caller's behalf.
+ */
+export async function resolveName(raw, source) {
+    let match = matchByName(raw, await source.load());
+    if (match.kind === "missing") {
+        await source.refresh();
+        match = matchByName(raw, await source.load());
+    }
+    if (match.kind === "unique") {
+        return match.entry.value;
+    }
+    if (match.kind === "ambiguous") {
+        throw ambiguityError(raw, source, match.candidates);
+    }
+    const all = await source.load();
+    throw missingError(raw, source, all.map((entry) => entry.name));
+}
+//# sourceMappingURL=resolve.js.map

package/dist/core/define.js

@@ -0,0 +1,155 @@
+import { Command } from "commander";
+import { OpCliError } from "./errors.js";
+import { formatCell, renderTable } from "../output/table.js";
+import { allPageSize, halElements, parsePageSize, withPageSize } from "./paginate.js";
+import { isIdForm, rankByCloseness } from "../context/resolve.js";
+// Commander camel-cases option names ("--open-only" -> options.openOnly),
+// so the declared flag must go through the same transformation before the
+// parsed options object is consulted.
+function optionKey(flag) {
+    return flag.replace(/^--/, "").replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+export function defineLookupCommand(spec, runtime) {
+    const command = new Command(spec.name).description(spec.description);
+    const filters = spec.filters ?? [];
+    for (const filter of filters) {
+        command.option(filter.flag, filter.description);
+    }
+    for (const option of spec.options ?? []) {
+        command.option(option.flag, option.description);
+    }
+    command.option("--json", "emit a JSON array");
+    command.action(async (options) => {
+        runtime.setJsonMode(options.json === true);
+        const active = filters.filter((filter) => options[optionKey(filter.flag)] === true);
+        if (active.length > 1) {
+            throw new OpCliError("USAGE_ERROR");
+        }
+        let rows = spec.select(await runtime.load(options));
+        if (active.length === 1) {
+            rows = rows.filter(active[0]?.keep ?? (() => true));
+        }
+        if (options.json === true) {
+            runtime.write(`${JSON.stringify(rows)}\n`);
+            return;
+        }
+        runtime.write(renderTable(spec.columns.map((column) => column.title), rows.map((row) => spec.columns.map((column) => column.cell(row)))));
+    });
+    return command;
+}
+/**
+ * Help text of --json wherever --all exists. With --all the output is one
+ * record per line, not an array (#8), and a caller who reads only --help
+ * would otherwise write JSON.parse over the whole body.
+ */
+export const PAGED_JSON_HELP = "emit a flat JSON array, or NDJSON (one record per line) with --all";
+/**
+ * The column view behind one invocation: --fields validated against the
+ * declared columns (before any traffic) plus the row picker it implies.
+ * Without --fields the table shows every declared column while JSON keeps
+ * the whole flat record, matching `wp list`.
+ */
+export function rowViewOf(columns, options) {
+    const fields = options.fields;
+    if (typeof fields !== "string") {
+        return { view: columns, pick: (row) => row };
+    }
+    const requested = [
+        ...new Set(fields.split(",").map((name) => name.trim()).filter((name) => name !== "")),
+    ];
+    const declared = columns.map((column) => column.field);
+    const missing = requested.find((name) => !declared.includes(name));
+    if (missing !== undefined) {
+        throw new OpCliError("USAGE_ERROR", `field "${missing}" is not a column. Valid fields, closest first: `
+            + `${rankByCloseness(missing, declared).join(", ")}.`, "run the command without --fields to list every available column.");
+    }
+    const view = requested.map((name) => columns.find((column) => column.field === name));
+    return {
+        view,
+        pick: (row) => Object.fromEntries(view.map((column) => [column.field, row[column.field]])),
+    };
+}
+function renderRowsTable(view, rows) {
+    return renderTable(view.map((column) => column.title), rows.map((row) => view.map((column) => formatCell(row[column.field]))));
+}
+/**
+ * Render rows as a table or one flat JSON array. Shared by every
+ * non-streaming listing so field selection exists exactly once.
+ */
+export function emitRows(io, columns, rows, options) {
+    const { view, pick } = rowViewOf(columns, options);
+    if (options.json === true) {
+        io.write(`${JSON.stringify(rows.map(pick))}\n`);
+        return;
+    }
+    io.write(renderRowsTable(view, rows));
+}
+/**
+ * Declaration of one paginated listing over a per-work-package HAL
+ * collection: pagination, the truncation notice, both output shapes and
+ * field selection all come from here; a declaration only names the
+ * endpoint, its rows, and its columns.
+ */
+export function defineCollectionCommand(spec, runtime) {
+    const command = new Command(spec.name)
+        .description(spec.description)
+        .argument("<id>", "work package id")
+        .option("--json", PAGED_JSON_HELP)
+        .option("--fields <list>", "comma-separated columns to show")
+        .option("--limit <n>", "maximum number of results to show")
+        .option("--all", "fetch every page instead of one limited page")
+        .option("--profile <name>", "use this profile for this command only")
+        .option("--project <id>", "override the profile default project");
+    command.action(async (reference, options) => {
+        runtime.setJsonMode(options.json === true);
+        // Flag misuse is refused before any traffic.
+        const { view, pick } = rowViewOf(spec.columns, options);
+        if (!isIdForm(reference)) {
+            throw new OpCliError("USAGE_ERROR", `work package "${reference}" is not an id.`, "work packages are addressed by their numeric id.");
+        }
+        const getPage = await runtime.connect(options);
+        const resolve = spec.resolve?.(getPage) ?? ((row) => Promise.resolve(row));
+        const limit = parsePageSize(typeof options.limit === "string" ? options.limit : undefined);
+        const startPath = withPageSize(spec.path(reference), options.all === true ? await allPageSize(getPage) : limit);
+        if (options.all === true) {
+            if (options.json === true) {
+                for await (const element of halElements(getPage, startPath)) {
+                    const row = spec.row(element);
+                    if (row !== undefined) {
+                        runtime.write(`${JSON.stringify(pick(await resolve(row)))}\n`);
+                    }
+                }
+                return;
+            }
+            const rows = [];
+            for await (const element of halElements(getPage, startPath)) {
+                const row = spec.row(element);
+                if (row !== undefined) {
+                    rows.push(await resolve(row));
+                }
+            }
+            runtime.write(renderRowsTable(view, rows));
+            return;
+        }
+        const page = (await getPage(startPath));
+        const elements = page._embedded?.elements ?? [];
+        const rows = [];
+        for (const element of elements) {
+            const row = spec.row(element);
+            if (row !== undefined) {
+                rows.push(await resolve(row));
+            }
+        }
+        emitRows(runtime, spec.columns, rows, options);
+        // The notice compares against what the API delivered on the page, not
+        // the post-filter count: a comments listing drops other activity kinds
+        // even when the page was complete.
+        const total = typeof page.total === "number" ? page.total : elements.length;
+        if (total > elements.length) {
+            runtime.writeErr(`Showing ${rows.length} of ${total} records. `
+                + "Pass --all to fetch every result.\n");
+        }
+    });
+    return command;
+}
+//# sourceMappingURL=define.js.map

package/dist/core/duration.js

@@ -0,0 +1,151 @@
+import { OpCliError } from "./errors.js";
+// The accepted value grammar of --hours, taught verbatim in every refusal.
+const ACCEPTED_FORMS = "a decimal number of hours such as 1.5, a compound form such as 1h30m, "
+    + "or an ISO 8601 duration such as PT1H30M";
+// Every fixed-length ISO 8601 component, in the order the grammar spells
+// them: weeks and days before the T, hours, minutes, and seconds after it.
+// Years and months are absent on purpose: they name calendar spans of no
+// fixed number of hours, so no value can be read out of them.
+const ISO_DURATION = /^p(?:(\d+(?:\.\d+)?)w)?(?:(\d+(?:\.\d+)?)d)?(t(?:(\d+(?:\.\d+)?)h)?(?:(\d+(?:\.\d+)?)m)?(?:(\d+(?:\.\d+)?)s)?)?$/i;
+/**
+ * Parse any fixed-length ISO 8601 duration into milliseconds, or return
+ * undefined when the string is not that grammar. This is the read path:
+ * OpenProject spells a duration of 24 hours or more with a day component
+ * ("P3DT1H") and a week component beyond that, so everything the instance
+ * can emit has to be readable here.
+ */
+function isoDurationToMs(raw) {
+    const match = ISO_DURATION.exec(raw.trim());
+    if (match === null) {
+        return undefined;
+    }
+    // Each matched component, paired with the seconds one unit of it is worth.
+    const dateComponents = [[match[1], 604_800], [match[2], 86_400]];
+    const timeComponents = [[match[4], 3_600], [match[5], 60], [match[6], 1]];
+    const components = [...dateComponents, ...timeComponents];
+    const missing = ([component]) => component === undefined;
+    // "P" and "PT" name no amount of time at all, and a "T" carrying nothing
+    // after it is half a form; refuse them like any other malformed input
+    // rather than reading a gap as zero. match[3] is the whole T section when
+    // one was written, so its presence beside no H, M, or S is that bare "T".
+    if (components.every(missing)) {
+        return undefined;
+    }
+    if (match[3] !== undefined && timeComponents.every(missing)) {
+        return undefined;
+    }
+    const seconds = components.reduce((carry, [component, perUnit]) => carry + Number(component ?? 0) * perUnit, 0);
+    return Math.round(seconds * 1000);
+}
+/**
+ * Parse one ISO 8601 time-only duration (PT…) into milliseconds, or return
+ * undefined when the string is not exactly that grammar. Weeks and days
+ * are refused on purpose: this is the write path, and the hours field of
+ * a single time entry never carries a calendar component.
+ *
+ * The narrowing rides on the shape of ISO_DURATION, where the week and day
+ * components can only ever precede the "T": a value that starts "PT" has
+ * none of them. Keep that ordering if the shared grammar is ever rewritten.
+ */
+function isoTimeToMs(raw) {
+    const token = raw.trim();
+    return /^pt/i.test(token) ? isoDurationToMs(token) : undefined;
+}
+/**
+ * Convert an ISO 8601 duration the instance reported ("PT1H30M", "PT0S",
+ * "P3DT1H") to decimal hours. The inverse of [hoursToIso] within
+ * millisecond precision for every value [hoursToIso] can render.
+ *
+ * The value read here was never typed by the caller, so a duration this
+ * client cannot read is the instance's answer failing, not misuse.
+ */
+export function isoToHours(iso) {
+    const ms = isoDurationToMs(iso);
+    if (ms === undefined) {
+        throw new OpCliError("API_ERROR", `the instance reported the duration "${iso}", which is not an ISO 8601 `
+            + "duration such as PT1H30M, PT0S, or P3DT1H.", "durations in weeks, days, hours, minutes, or seconds can be read; "
+            + "report the value if the instance keeps sending it.");
+    }
+    return ms / 3_600_000;
+}
+/**
+ * Convert decimal hours into the canonical ISO 8601 duration OpenProject
+ * expects on the wire: the shortest exact H/M/S spelling of the value at
+ * millisecond precision, so binary-fraction noise from decimal input can
+ * never leak into a request.
+ */
+export function hoursToIso(hours) {
+    if (!Number.isFinite(hours) || hours < 0) {
+        throw new OpCliError("USAGE_ERROR", `cannot render ${String(hours)} hours as a duration.`, "hours must be a finite number of 0 or more.");
+    }
+    let rest = Math.round(hours * 3_600_000);
+    const h = Math.floor(rest / 3_600_000);
+    rest -= h * 3_600_000;
+    const m = Math.floor(rest / 60_000);
+    rest -= m * 60_000;
+    const s = rest / 1000;
+    const parts = [];
+    if (h > 0) {
+        parts.push(`${String(h)}H`);
+    }
+    if (m > 0) {
+        parts.push(`${String(m)}M`);
+    }
+    if (s > 0) {
+        // Up to three decimals, no trailing zeros: 0.5S stays 0.5S, 27S stays 27S.
+        parts.push(`${s.toFixed(3).replace(/\.?0+$/, "")}S`);
+    }
+    return parts.length === 0 ? "PT0S" : `PT${parts.join("")}`;
+}
+/**
+ * Read one raw `--hours` value: a decimal number of hours ("1.5"), a
+ * compound form ("1h30m"), or an ISO 8601 duration ("PT1H30M"). Every
+ * accepted spelling of the same amount produces the identical result.
+ */
+export function parseDuration(raw) {
+    const token = raw.trim();
+    if (/^\d+(?:\.\d+)?$/.test(token)) {
+        return parsedFromHours(Number(token), raw);
+    }
+    const compound = token.toLowerCase().replace(/\s+/g, "");
+    // Segments are consumed in whatever units the caller used, but the
+    // h → m → s order must hold and no unit may repeat: "45m" is legal,
+    // "30m1h" and "1h30h" are refused instead of guessed at. Any
+    // unconsumed tail refuses the whole input; NaN marks the refusal.
+    const segment = /^(\d+(?:\.\d+)?)([hms])/;
+    const UNIT_MS = {
+        h: 3_600_000,
+        m: 60_000,
+        s: 1_000,
+    };
+    let rest = compound;
+    let ms = 0;
+    let lastIndex = -1;
+    while (rest !== "") {
+        const match = segment.exec(rest);
+        const unitIndex = match === null ? -1 : ["h", "m", "s"].indexOf(match[2]);
+        if (match === null || unitIndex < 0 || unitIndex <= lastIndex) {
+            ms = Number.NaN;
+            break;
+        }
+        lastIndex = unitIndex;
+        ms += Number(match[1]) * UNIT_MS[match[2]];
+        rest = rest.slice(match[0].length);
+    }
+    if (!Number.isNaN(ms)) {
+        return parsedFromHours(ms / 3_600_000, raw);
+    }
+    const direct = isoTimeToMs(token);
+    if (direct !== undefined) {
+        return parsedFromHours(direct / 3_600_000, raw);
+    }
+    throw new OpCliError("USAGE_ERROR", `cannot read "${raw}" as a duration.`, `--hours accepts ${ACCEPTED_FORMS}.`);
+}
+/** Shared tail of parseDuration: positive amounts only. */
+function parsedFromHours(hours, raw) {
+    if (!(hours > 0)) {
+        throw new OpCliError("USAGE_ERROR", `"${raw}" does not name a positive amount of time.`, `--hours accepts ${ACCEPTED_FORMS}, and logging needs more than zero.`);
+    }
+    return { hours, iso: hoursToIso(hours) };
+}
+//# sourceMappingURL=duration.js.map