@tuanhv/op-cli 0.1.0

package/dist/core/errors.js

@@ -0,0 +1,102 @@
+export const ERROR_CATALOGUE = {
+    USAGE_ERROR: {
+        exitCode: 1,
+        message: "Invalid command usage.",
+        hint: "run op-cli --help.",
+    },
+    PROFILE_NOT_FOUND: {
+        exitCode: 1,
+        message: "No active profile.",
+        hint: "run op-cli auth login.",
+    },
+    NOT_FOUND: {
+        exitCode: 4,
+        message: "Not found.",
+        hint: "check the id; run op-cli meta refresh if names changed recently.",
+    },
+    API_ERROR: {
+        exitCode: 2,
+        message: "OpenProject request failed.",
+        hint: "try again later.",
+    },
+    INTERNAL_ERROR: {
+        exitCode: 2,
+        message: "Unexpected failure.",
+        hint: "retry or report the error.",
+    },
+    AUTH_FAILED: {
+        exitCode: 3,
+        message: "Authentication failed.",
+        hint: "run op-cli auth login.",
+    },
+    UNSUPPORTED_VERSION: {
+        exitCode: 7,
+        message: "The instance version is not supported.",
+        hint: "OpenProject v13 with API v3 or newer is required.",
+    },
+    CONFLICT: {
+        exitCode: 5,
+        message: "The work package was modified while the update ran.",
+        hint: "read the current values, merge them with your change, and repeat.",
+    },
+    NETWORK_ERROR: {
+        exitCode: 6,
+        message: "Could not reach the instance.",
+        hint: "check the instance URL and try again.",
+    },
+};
+export class OpCliError extends Error {
+    code;
+    exitCode;
+    hint;
+    /** Extra machine-readable facts merged into JSON error output. */
+    details;
+    // The code stays inside the closed catalogue; only the wording is
+    // contextual, so scripts matching on codes keep their promise.
+    constructor(code, message, hint, details) {
+        const definition = ERROR_CATALOGUE[code];
+        super(message ?? definition.message);
+        this.name = "OpCliError";
+        this.code = code;
+        this.exitCode = definition.exitCode;
+        this.hint = hint ?? definition.hint;
+        this.details = details;
+    }
+}
+/** OpenProject's own explanation of a refusal, when the body carries one. */
+function explanationOf(body) {
+    const message = typeof body === "object" && body !== null
+        ? body.message
+        : undefined;
+    return typeof message === "string" ? message : undefined;
+}
+/**
+ * The catalogue entry for a write the instance refused. A refusal is not
+ * an outage: the same request will be refused the same way until the
+ * values change, so it must not borrow the "try again later" hint that
+ * belongs to an unreachable or overloaded instance. The one exception is
+ * 429, where waiting is exactly the repair.
+ */
+export function writeRefusal(subject, status, body) {
+    const explanation = explanationOf(body);
+    const message = `OpenProject rejected the ${subject}`
+        + (explanation === undefined ? "." : `: ${explanation}`);
+    if (status === 429) {
+        return new OpCliError("API_ERROR", message);
+    }
+    return new OpCliError("API_ERROR", message, "fix the rejected values and repeat the command.");
+}
+export function renderTextError(error) {
+    return `[${error.code}] ${error.message} Hint: ${error.hint}\n`;
+}
+export function renderJsonError(error) {
+    return `${JSON.stringify({
+        error: {
+            code: error.code,
+            message: error.message,
+            hint: error.hint,
+            ...(error.details ?? {}),
+        },
+    })}\n`;
+}
+//# sourceMappingURL=errors.js.map

package/dist/core/filters.js

@@ -0,0 +1,133 @@
+import { OpCliError } from "./errors.js";
+const DATE_FORMS = "today, yesterday, a number of days such as 7d, or an explicit YYYY-MM-DD date";
+export function isoDate(date) {
+    const month = String(date.getMonth() + 1).padStart(2, "0");
+    const day = String(date.getDate()).padStart(2, "0");
+    return `${String(date.getFullYear())}-${month}-${day}`;
+}
+function isCalendarDate(raw) {
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(raw)) {
+        return false;
+    }
+    const year = Number(raw.slice(0, 4));
+    const month = Number(raw.slice(5, 7));
+    const day = Number(raw.slice(8, 10));
+    const probe = new Date(year, month - 1, day);
+    return (probe.getFullYear() === year
+        && probe.getMonth() === month - 1
+        && probe.getDate() === day);
+}
+function daysAgo(now, days) {
+    return new Date(now.getFullYear(), now.getMonth(), now.getDate() - days);
+}
+/**
+ * Turn the raw `--updated-after` input into the local date the window
+ * opens at: today, yesterday, N days ago, or an explicit date. The
+ * upper bound is deliberately left open (#24): the API reads a closed
+ * one as the start of that day, so every change made during the
+ * closing day would drop out. Callers emit `<>d [date, ""]`.
+ */
+export function sinceDate(raw, now) {
+    const token = raw.trim().toLowerCase();
+    const today = isoDate(now);
+    if (token === "today") {
+        return today;
+    }
+    if (token === "yesterday") {
+        return isoDate(daysAgo(now, 1));
+    }
+    const relative = /^(\d+)d$/.exec(token);
+    if (relative !== null) {
+        const days = Number(relative[1]);
+        if (days >= 1) {
+            return isoDate(daysAgo(now, days));
+        }
+    }
+    if (/^\d{4}-\d{2}-\d{2}$/.test(token)) {
+        if (!isCalendarDate(token)) {
+            throw new OpCliError("USAGE_ERROR", `"${raw}" is not a real date.`, `--updated-after accepts ${DATE_FORMS}.`);
+        }
+        if (token > today) {
+            throw new OpCliError("USAGE_ERROR", `"${raw}" is in the future.`, "--updated-after needs a date up to today.");
+        }
+        return token;
+    }
+    throw new OpCliError("USAGE_ERROR", `cannot read "${raw}" as an updated-after value.`, `--updated-after accepts ${DATE_FORMS}.`);
+}
+function unique(values) {
+    return [...new Set(values)];
+}
+/**
+ * Build the exact filter JSON the work-packages endpoint expects. Flag
+ * combinations that cannot reach the API as one query (--open with
+ * --closed, either with explicit statuses) fail here so both commands
+ * refuse them before any network traffic.
+ */
+export function buildWpFilters(flags, now) {
+    if (flags.open === true && flags.closed === true) {
+        throw new OpCliError("USAGE_ERROR", "--open and --closed cannot be combined.", "pass only one of the two shorthands.");
+    }
+    const statuses = unique(flags.statuses ?? []);
+    if ((flags.open === true || flags.closed === true) && statuses.length > 0) {
+        throw new OpCliError("USAGE_ERROR", "--status cannot be combined with --open or --closed.", "list explicit statuses or use one shorthand, not both.");
+    }
+    const filters = [];
+    // The project leads: it is the scope every other clause narrows, and it
+    // is the same clause the project-scoped collection applies internally,
+    // subprojects included.
+    if (flags.project !== undefined) {
+        filters.push({ name: "project", operator: "=", values: [flags.project] });
+    }
+    if (flags.open === true) {
+        filters.push({ name: "status", operator: "o", values: [] });
+    }
+    else if (flags.closed === true) {
+        filters.push({ name: "status", operator: "c", values: [] });
+    }
+    else if (statuses.length > 0) {
+        filters.push({ name: "status", operator: "=", values: statuses });
+    }
+    if ((flags.types ?? []).length > 0) {
+        filters.push({ name: "type", operator: "=", values: unique(flags.types) });
+    }
+    if ((flags.assignees ?? []).length > 0) {
+        filters.push({ name: "assigned_to", operator: "=", values: unique(flags.assignees) });
+    }
+    if ((flags.authors ?? []).length > 0) {
+        filters.push({ name: "author", operator: "=", values: unique(flags.authors) });
+    }
+    if ((flags.versions ?? []).length > 0) {
+        filters.push({ name: "version", operator: "=", values: unique(flags.versions) });
+    }
+    if ((flags.categories ?? []).length > 0) {
+        filters.push({ name: "category", operator: "=", values: unique(flags.categories) });
+    }
+    if ((flags.priorities ?? []).length > 0) {
+        filters.push({ name: "priority", operator: "=", values: unique(flags.priorities) });
+    }
+    if ((flags.parents ?? []).length > 0) {
+        filters.push({ name: "parent", operator: "=", values: unique(flags.parents) });
+    }
+    if (flags.updatedAfter !== undefined) {
+        const since = sinceDate(flags.updatedAfter, now);
+        filters.push({
+            name: "updated_at",
+            operator: "<>d",
+            // The empty upper bound is the fix for #24: a closed one drops
+            // everything changed during its own day.
+            values: [since, ""],
+        });
+    }
+    return filters;
+}
+/**
+ * Serialise clauses into the URL-encoded `filters` query parameter
+ * value, in wire shape: one object per clause keyed by filter name.
+ */
+export function filtersQuery(filters) {
+    const wire = filters.map((filter) => ({
+        [filter.name]: { operator: filter.operator, values: [...filter.values] },
+    }));
+    return encodeURIComponent(JSON.stringify(wire));
+}
+//# sourceMappingURL=filters.js.map

package/dist/core/hal.js

@@ -0,0 +1,114 @@
+/** Trailing numeric segment of an href ("/api/v3/types/2" -> 2). */
+export function halRefId(href) {
+    if (href === undefined || href === null) {
+        return null;
+    }
+    const match = /(\d+)\/?$/.exec(href);
+    return match === null ? null : Number(match[1]);
+}
+export function flattenHalLink(link) {
+    const body = link;
+    if (typeof body !== "object" || body === null || Array.isArray(body)) {
+        return { id: null, name: null };
+    }
+    return {
+        id: halRefId(typeof body.href === "string" ? body.href : null),
+        name: typeof body.title === "string" ? body.title : null,
+    };
+}
+/**
+ * Whether a link belongs in the flat record. HAL mixes two kinds under
+ * `_links`: attributes that point at a resource, and operations the
+ * caller may perform. An operation declares its `method`, and its href
+ * often ends in the record's own id, so keeping it would spell an
+ * unrelated action as if it were a resource. A link that names nothing
+ * at all (`{"id":null,"name":null}` from a real href, such as a
+ * sub-collection endpoint) carries no fact either. What stays is every
+ * link that names a resource, plus the unset attributes whose href is
+ * null: "no version" is data.
+ */
+function namesAResource(link, flat) {
+    const body = link;
+    if (typeof body === "object" && body !== null && body.method !== undefined) {
+        return false;
+    }
+    if (flat.id !== null || flat.name !== null) {
+        return true;
+    }
+    return typeof body?.href !== "string";
+}
+function isFlatLink(value) {
+    const record = value;
+    if (typeof record !== "object" || record === null || Array.isArray(record)) {
+        return false;
+    }
+    return (Object.keys(record).every((key) => key === "id" || key === "name")
+        && ("id" in record || "name" in record));
+}
+/**
+ * Flatten one HAL resource in place: `_type` is dropped, `_embedded` is
+ * stripped (embedded resources are never merged into the record), every
+ * `_links` entry except `self` and the operations shrinks to
+ * `{ id, name }`, and scalars pass through untouched. The result is the
+ * bare record; nothing wraps it. See ADR-0003 for what the shape
+ * promises.
+ */
+export function flattenHalRecord(record) {
+    const resource = record;
+    if (typeof resource !== "object" || resource === null || Array.isArray(resource)) {
+        throw new TypeError("expected a HAL resource object");
+    }
+    const flat = {};
+    for (const [key, value] of Object.entries(resource)) {
+        if (key === "_type" || key === "_embedded" || key === "_links") {
+            continue;
+        }
+        flat[key] = Array.isArray(value)
+            ? value.map(flattenHalRecord)
+            : typeof value === "object" && value !== null
+                ? flattenHalRecord(value)
+                : value;
+    }
+    const links = resource._links;
+    if (typeof links === "object" && links !== null) {
+        for (const [key, link] of Object.entries(links)) {
+            if (key === "self") {
+                continue;
+            }
+            if (Array.isArray(link)) {
+                flat[key] = link.map(flattenHalLink);
+                continue;
+            }
+            const flatLink = flattenHalLink(link);
+            if (namesAResource(link, flatLink)) {
+                flat[key] = flatLink;
+            }
+        }
+    }
+    return flat;
+}
+/**
+ * The write form of a Formattable field. API v3 models `description` and
+ * `comment` as `{ raw, format }`: a bare string is accepted, silently
+ * ignored, and reported as success, so every write goes through here.
+ */
+export function toFormattable(value) {
+    return { raw: value };
+}
+/**
+ * The markdown behind a Formattable field as it arrives: the `raw` of the
+ * object the API returns, the string itself when an instance answers with
+ * one, null when the field carries nothing.
+ */
+export function formattableRaw(value) {
+    if (typeof value === "string") {
+        return value;
+    }
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return null;
+    }
+    const raw = value.raw;
+    return typeof raw === "string" ? raw : null;
+}
+export { isFlatLink };
+//# sourceMappingURL=hal.js.map

package/dist/core/http.js

@@ -0,0 +1,119 @@
+import { OpCliError } from "./errors.js";
+export async function authenticate(instanceUrl, apiKey) {
+    const user = (await apiGet(instanceUrl, apiKey, "/api/v3/users/me"));
+    return {
+        id: user.id,
+        name: user.name,
+        login: user.login,
+    };
+}
+// Reads may burn exactly one extra attempt on a transient 429/5xx; writes
+// never retry (ADR-0002): a replayed create or update can duplicate data.
+const READ_RETRY_DELAY_MS = 200;
+// The per-attempt budget is a policy of the run environment, not a
+// constant: OP_CLI_TIMEOUT_MS names a larger one for slow reads, and an
+// unusable value is refused like a bad --limit instead of silently
+// falling back.
+const DEFAULT_TIMEOUT_MS = 10_000;
+function parseTimeoutMs(raw) {
+    if (raw === undefined) {
+        return DEFAULT_TIMEOUT_MS;
+    }
+    if (!/^\d+$/.test(raw) || Number(raw) < 1) {
+        throw new OpCliError("USAGE_ERROR", `OP_CLI_TIMEOUT_MS "${raw}" is not a positive integer.`, "pass a whole number of milliseconds, 1 or more.");
+    }
+    return Number(raw);
+}
+let timeoutMs = DEFAULT_TIMEOUT_MS;
+/**
+ * Derive the per-request timeout from the run environment. Called once
+ * per run so every request of one session shares one budget.
+ */
+export function bindRequestTimeout(env) {
+    timeoutMs = parseTimeoutMs(env.OP_CLI_TIMEOUT_MS);
+}
+async function attempt(instanceUrl, apiKey, path, method, body) {
+    // AbortSignal.timeout aborts with a TimeoutError reason. A budget
+    // problem (too impatient) and a reachability problem (wrong URL)
+    // share the NETWORK_ERROR code and exit 6 by contract; only the
+    // wording and machine-readable details tell them apart.
+    const signal = AbortSignal.timeout(timeoutMs);
+    try {
+        return await fetch(`${instanceUrl}${path}`, {
+            headers: {
+                accept: "application/hal+json",
+                authorization: `Basic ${Buffer.from(`apikey:${apiKey}`).toString("base64")}`,
+                // The API rejects non-JSON bodies with 415; without this header
+                // fetch would label the body text/plain.
+                ...(method === "POST" || method === "PATCH"
+                    ? { "content-type": "application/json" }
+                    : {}),
+            },
+            signal,
+            ...(method === "POST" || method === "PATCH"
+                ? { method, body: JSON.stringify(body) }
+                : { method }),
+        });
+    }
+    catch {
+        if (signal.reason instanceof Error && signal.reason.name === "TimeoutError") {
+            throw new OpCliError("NETWORK_ERROR", `The request exceeded the ${timeoutMs} ms timeout.`, "raise OP_CLI_TIMEOUT_MS and try again.", { timedOut: true, timeoutMs });
+        }
+        throw new OpCliError("NETWORK_ERROR");
+    }
+}
+async function request(instanceUrl, apiKey, path, method, body) {
+    let response = await attempt(instanceUrl, apiKey, path, method, body);
+    if (method === "GET" && (response.status === 429 || response.status >= 500)) {
+        // Promise.withResolvers needs ES2024 lib; the executor form stays.
+        await new Promise((resolve) => setTimeout(resolve, READ_RETRY_DELAY_MS));
+        response = await attempt(instanceUrl, apiKey, path, method, body);
+    }
+    if (response.status === 401 || response.status === 403) {
+        throw new OpCliError("AUTH_FAILED");
+    }
+    return response;
+}
+async function send(instanceUrl, apiKey, path, method, body) {
+    const response = await request(instanceUrl, apiKey, path, method, body);
+    if (response.status === 204) {
+        return undefined;
+    }
+    if (response.status === 404) {
+        throw new OpCliError("NOT_FOUND");
+    }
+    if (!response.ok) {
+        throw new OpCliError("API_ERROR");
+    }
+    return await response.json();
+}
+async function bodyOf(response) {
+    const text = await response.text();
+    if (text === "") {
+        return undefined;
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+export async function apiPostRaw(instanceUrl, apiKey, path, body) {
+    const response = await request(instanceUrl, apiKey, path, "POST", body);
+    return { status: response.status, body: await bodyOf(response) };
+}
+export async function apiPatchRaw(instanceUrl, apiKey, path, body) {
+    const response = await request(instanceUrl, apiKey, path, "PATCH", body);
+    return { status: response.status, body: await bodyOf(response) };
+}
+export async function apiDelete(instanceUrl, apiKey, path) {
+    return send(instanceUrl, apiKey, path, "DELETE");
+}
+export async function apiGet(instanceUrl, apiKey, path) {
+    return send(instanceUrl, apiKey, path, "GET");
+}
+export async function apiPost(instanceUrl, apiKey, path, body) {
+    return send(instanceUrl, apiKey, path, "POST", body);
+}
+//# sourceMappingURL=http.js.map

package/dist/core/paginate.js

@@ -0,0 +1,55 @@
+import { OpCliError } from "./errors.js";
+export const DEFAULT_PAGE_SIZE = 100;
+/** Same contract as the flag of `wp list`: a whole number of 1 or more. */
+export function parsePageSize(raw) {
+    if (raw === undefined) {
+        return DEFAULT_PAGE_SIZE;
+    }
+    if (!/^\d+$/.test(raw) || Number(raw) < 1) {
+        throw new OpCliError("USAGE_ERROR", `--limit "${raw}" is not a positive integer.`, "pass a whole number of 1 or more.");
+    }
+    return Number(raw);
+}
+/** Append pageSize to an endpoint path that may or may not carry a query. */
+export function withPageSize(path, size) {
+    return `${path}${path.includes("?") ? "&" : "?"}pageSize=${String(size)}`;
+}
+/**
+ * The page size an --all walk requests: the largest page the instance
+ * allows, taken from the maximumAPIV3PageSize the API root advertises,
+ * with the collection default as the fallback. One root document read
+ * replaces a walk of dozens of --limit-sized pages.
+ */
+export async function allPageSize(getPage) {
+    const root = (await getPage("/api/v3/"));
+    const advertised = root?.maximumAPIV3PageSize;
+    return typeof advertised === "number" && advertised >= 1
+        ? advertised
+        : DEFAULT_PAGE_SIZE;
+}
+/**
+ * Reduce a nextByOffset href (path or absolute URL) to the path the API
+ * client should request next, or undefined when the collection ended.
+ */
+export function halNextPath(href) {
+    if (href === undefined || href === "") {
+        return undefined;
+    }
+    const url = new URL(href, "https://op-cli.invalid");
+    return `${url.pathname}${url.search}`;
+}
+/**
+ * Walk a HAL collection page by page, yielding every element in server
+ * order. The only pagination contract is `_links.nextByOffset`.
+ */
+export async function* halElements(getPage, startPath) {
+    let path = startPath;
+    while (path !== undefined) {
+        const collection = (await getPage(path));
+        for (const element of collection._embedded?.elements ?? []) {
+            yield element;
+        }
+        path = halNextPath(collection._links?.nextByOffset?.href);
+    }
+}
+//# sourceMappingURL=paginate.js.map

package/dist/core/usage.js

@@ -0,0 +1,58 @@
+import { OpCliError } from "./errors.js";
+/**
+ * The single-quoted token Commander puts in its own prose: the offending
+ * flag, option declaration, argument name, or command.
+ */
+function quoted(detail) {
+    return /'([^']*)'/.exec(detail)?.[1];
+}
+/** Commander's suggestion tail, "(Did you mean --field?)", if it made one. */
+function suggestion(message) {
+    const match = /\(Did you mean (.+)\?\)/.exec(message);
+    return match === null ? "" : ` Did you mean ${match[1]}?`;
+}
+/** Commander's first prose line without its "error: " prefix. */
+function detailOf(message) {
+    return (message.split("\n")[0] ?? "").replace(/^error:\s*/, "");
+}
+/**
+ * Commander's prose, ended as a sentence and requoted: the catalogue
+ * spells names in double quotes, and a message that mixes both reads as
+ * two voices.
+ */
+function sentence(detail) {
+    const requoted = detail.replace(/'([^']*)'/g, '"$1"');
+    return requoted.endsWith(".") ? requoted : `${requoted}.`;
+}
+/**
+ * The catalogue line for a parse failure. Commander knows which flag,
+ * argument, or command was refused and by whom; the code stays the
+ * stable `USAGE_ERROR` while the wording carries those facts instead of
+ * discarding them.
+ */
+export function usageErrorFrom(error, commandPath) {
+    const detail = detailOf(error.message);
+    const named = quoted(detail);
+    const hint = `run ${commandPath} --help to see what it accepts.`;
+    const message = (() => {
+        if (named === undefined) {
+            return sentence(detail === "" ? "Invalid command usage" : detail);
+        }
+        switch (error.code) {
+            case "commander.unknownOption":
+                return `unknown option "${named}".${suggestion(error.message)}`;
+            case "commander.unknownCommand":
+                return `unknown command "${named}".${suggestion(error.message)}`;
+            case "commander.missingMandatoryOptionValue":
+                return `required option "${named}" is missing.`;
+            case "commander.optionMissingArgument":
+                return `option "${named}" needs a value.`;
+            case "commander.missingArgument":
+                return `missing required argument "${named}".`;
+            default:
+                return sentence(detail);
+        }
+    })();
+    return new OpCliError("USAGE_ERROR", message, hint);
+}
+//# sourceMappingURL=usage.js.map

package/dist/io/node-io.js

@@ -0,0 +1,89 @@
+import { createInterface } from "node:readline/promises";
+import { StringDecoder } from "node:string_decoder";
+import { OpCliError } from "../core/errors.js";
+const ENV_HINT = "set OPENPROJECT_URL and OPENPROJECT_API_KEY in the environment for non-interactive use.";
+/**
+ * The binary's RunIo over real streams. Both prompt styles are bounded:
+ * a readline question races the interface's close event, so EOF settles
+ * the wait instead of hanging the awaited run() forever, and a secret is
+ * read through a raw-mode byte loop that never forwards keystrokes to
+ * the output stream.
+ */
+export function createNodeIo(input = process.stdin, output = process.stdout) {
+    const stdinIsTTY = input.isTTY === true;
+    // Executor form on purpose: Promise.withResolvers needs ES2024, and the
+    // published engines field still supports Node 20.
+    const askLine = (message) => new Promise((resolve, reject) => {
+        const line = createInterface({ input, output });
+        let settled = false;
+        const eofError = new OpCliError("USAGE_ERROR", "stdin closed while waiting for input.", ENV_HINT);
+        const settle = (finish) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            line.removeListener("close", onClose);
+            finish();
+            // Closing after every question keeps the process free to exit;
+            // an open interface would hold the event loop open.
+            line.close();
+        };
+        const onClose = () => settle(() => reject(eofError));
+        line.once("close", onClose);
+        void line.question(message).then((answer) => settle(() => resolve(answer)), (error) => settle(() => reject(error)));
+    });
+    const readSecret = async (message) => {
+        output.write(message);
+        const wasRaw = input.isRaw === true;
+        if (typeof input.setRawMode === "function" && !wasRaw) {
+            input.setRawMode(true);
+        }
+        const decoder = new StringDecoder("utf8");
+        let answer = "";
+        let terminated = false;
+        try {
+            for await (const chunk of input) {
+                const text = typeof chunk === "string" ? chunk : decoder.write(chunk);
+                for (const char of text) {
+                    if (char === "\r" || char === "\n") {
+                        terminated = true;
+                        break;
+                    }
+                    if (char === "\b" || char === "\u007f") {
+                        answer = answer.slice(0, -1);
+                        continue;
+                    }
+                    if (char === "\u0003") {
+                        throw new OpCliError("USAGE_ERROR", "credential entry cancelled.", ENV_HINT);
+                    }
+                    answer += char;
+                }
+                if (terminated) {
+                    break;
+                }
+            }
+            if (!terminated) {
+                throw new OpCliError("USAGE_ERROR", "stdin closed while waiting for input.", ENV_HINT);
+            }
+            output.write("\n");
+            return answer;
+        }
+        finally {
+            if (typeof input.setRawMode === "function") {
+                input.setRawMode(wasRaw);
+            }
+        }
+    };
+    return {
+        stdinIsTTY,
+        prompt: (message, secret) => (secret ? readSecret(message) : askLine(message)),
+        readStdin: async () => {
+            const chunks = [];
+            for await (const chunk of input) {
+                chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+            }
+            return Buffer.concat(chunks).toString("utf8");
+        },
+    };
+}
+//# sourceMappingURL=node-io.js.map