@shreejitverma/x-axi 0.0.0-stage → 0.3.0

package/dist/src/approve.js

@@ -0,0 +1,325 @@
+import { execFile, spawn } from "node:child_process";
+import { accessSync, constants, statSync } from "node:fs";
+const DEFAULT_TIMEOUT_SECONDS = 120;
+// setTimeout fires at once for a delay over 2^31 - 1 milliseconds.
+const MAX_TIMEOUT_SECONDS = 2_147_483;
+const DIALOG_TITLE = "x-axi: approve this action";
+// Room for a whole 280 character post after its "Replying to @handle: " prefix.
+const MAX_UNWRAPPED_CONTEXT = 320;
+export const SYSTEM_DIRECTORIES = ["/usr/bin", "/bin", "/usr/local/bin"];
+// zenity comes first because it can make Cancel the default button and kdialog cannot.
+const LINUX_TOOLS = ["zenity", "kdialog"];
+// Arguments reach AppleScript through argv, so post text can never be parsed as script.
+const SCRIPT = `on run argv
+  set answer to display dialog (item 1 of argv) with title "${DIALOG_TITLE}" buttons {"Cancel", "Approve"} default button "Cancel" cancel button "Cancel" with icon caution giving up after ((item 2 of argv) as integer)
+  if gave up of answer then return "timed_out"
+  return button returned of answer
+end run`;
+export function counted(count, noun) {
+    return `${count} ${noun}${count === 1 ? "" : "s"}`;
+}
+function approvalHead(request) {
+    const cost = request.estCostUsd === null ? "unknown" : `about $${request.estCostUsd.toFixed(3)}`;
+    return `${request.action} as @${request.account} (${cost})`;
+}
+// The tool writes the counts, so outgoing text cannot pass part of itself off as not sent.
+function textLabel(text) {
+    return `Text to send, all of it (${counted(Array.from(text).length, "character")}, ${counted(text.split("\n").length, "line")}):`;
+}
+const CONTEXT_RULE = "----- context from X, not sent -----";
+const cutMarker = (text) => `[cut to fit: ${counted(Array.from(text).length, "character")} in full]`;
+/** The text for a dialog that has no line budget: macOS. */
+export function formatApproval(request) {
+    const body = "text" in request ? [textLabel(request.text), request.text] : [request.content];
+    // The body comes first and context last, flattened, so text from X cannot pose as it.
+    const lines = [approvalHead(request), "", ...body];
+    if (request.context) {
+        const characters = Array.from(request.context);
+        const shown = characters.length <= MAX_UNWRAPPED_CONTEXT ? request.context : `${characters.slice(0, MAX_UNWRAPPED_CONTEXT).join("")}\n${cutMarker(request.context)}`;
+        lines.push("", CONTEXT_RULE, shown);
+    }
+    return lines.join("\n");
+}
+/**
+ * Picks the dialog for this machine. Linux tools are looked up only in fixed
+ * system directories, never on PATH, so a PATH entry cannot answer the dialog.
+ */
+export function selectBackend(machine) {
+    if (machine.platform === "darwin")
+        return { kind: "osascript", path: "/usr/bin/osascript" };
+    if (machine.platform !== "linux")
+        return { kind: "none", reason: "unsupported_platform" };
+    if (!machine.env["DISPLAY"] && !machine.env["WAYLAND_DISPLAY"])
+        return { kind: "none", reason: "no_graphical_session" };
+    for (const kind of LINUX_TOOLS) {
+        for (const directory of machine.directories ?? SYSTEM_DIRECTORIES) {
+            const path = `${directory}/${kind}`;
+            if (machine.isExecutable(path))
+                return { kind, path };
+        }
+    }
+    return { kind: "none", reason: "no_dialog_tool" };
+}
+export function isExecutableFile(path) {
+    try {
+        if (!statSync(path).isFile())
+            return false;
+        accessSync(path, constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function approvalTimeoutSeconds(env) {
+    const requested = Number(env["X_AXI_APPROVAL_TIMEOUT"]);
+    return Number.isFinite(requested) && requested > 0 ? Math.min(Math.ceil(requested), MAX_TIMEOUT_SECONDS) : DEFAULT_TIMEOUT_SECONDS;
+}
+// GTK dialogs do not scroll on every zenity version, so an oversized one can push text and buttons off the screen.
+// kdialog elides any word too wide for the screen, which would hide part of the text while still offering Approve.
+// These limits are conservative estimates for a 1024x768 screen, not measurements of a real window.
+const WRAP_CELLS = 50;
+const MAX_WRAPPED_LINES = 25;
+// Held back from the text whether or not this action has context, so context can never decide a refusal:
+// one blank line, the context rule, and the context's cut marker.
+const CONTEXT_RESERVE_LINES = 3;
+const CONTINUES = "\u21b5";
+const BREAKS_ANYWHERE = String.raw `\p{sc=Han}\p{sc=Hiragana}\p{sc=Katakana}\p{sc=Hangul}`;
+const WIDE = new RegExp(`[${BREAKS_ANYWHERE}\\p{Extended_Pictographic}]`, "u");
+const WRAP_UNITS = new RegExp(`[${BREAKS_ANYWHERE}]|[^\\s${BREAKS_ANYWHERE}]+|\\s+`, "gu");
+const GRAPHEMES = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+const cellsOf = (text) => Array.from(text).reduce((sum, ch) => sum + (WIDE.test(ch) ? 2 : 1), 0);
+/** Splits a run too wide for one row, leaving each piece room for the continuation mark. */
+function splitRun(run) {
+    const pieces = [];
+    let piece = "";
+    let used = 0;
+    for (const { segment } of GRAPHEMES.segment(run)) {
+        const cells = cellsOf(segment);
+        if (used > 0 && used + cells > WRAP_CELLS - 1) {
+            pieces.push(piece);
+            piece = "";
+            used = 0;
+        }
+        piece += segment;
+        used += cells;
+    }
+    pieces.push(piece);
+    return pieces;
+}
+/**
+ * Greedy line wrapping. Each row keeps what ends it, so joining the rows gives the text back,
+ * changed only by the marked breaks inside runs too wide for a row.
+ */
+function wrapRows(text) {
+    const rows = [];
+    let breaks = 0;
+    for (const line of text.split("\n")) {
+        let row = "";
+        let used = 0;
+        for (const unit of line.match(WRAP_UNITS) ?? []) {
+            const blank = !unit.trim();
+            const cells = cellsOf(unit);
+            if (used > 0 && used + cells > WRAP_CELLS) {
+                rows.push(blank ? row + unit : row); // Whitespace at a wrap point takes no room.
+                row = "";
+                used = 0;
+                if (blank)
+                    continue;
+            }
+            if (!blank && cells > WRAP_CELLS) {
+                const pieces = splitRun(unit);
+                row = pieces.pop();
+                used = cellsOf(row);
+                rows.push(...pieces.map((piece) => `${piece}${CONTINUES}\n`));
+                breaks += pieces.length;
+            }
+            else {
+                row += unit;
+                used += cells;
+            }
+        }
+        rows.push(`${row}\n`);
+    }
+    return { rows, breaks };
+}
+const joinRows = (rows) => rows.join("").slice(0, -1);
+const rowCount = (text) => wrapRows(text).rows.length;
+/** Text the user cannot change gets whatever rows remain, and is cut with a marker instead of ever causing a refusal. */
+function clipToRows(text, maxRows) {
+    const { rows } = wrapRows(text);
+    if (rows.length <= maxRows)
+        return joinRows(rows);
+    const kept = rows.slice(0, maxRows - 1).join("").trimEnd();
+    return kept ? `${kept}\n${cutMarker(text)}` : cutMarker(text);
+}
+/**
+ * The text for a dialog that may not scroll, or null if the outgoing text cannot fit in it.
+ * Outgoing text must be shown in full to be approved, so it is the only thing that can cause a refusal.
+ */
+export function linuxApprovalText(request) {
+    const head = wrapRows(approvalHead(request));
+    const opening = [joinRows(head.rows), ""];
+    const marksNote = (breaks) => (breaks ? [`This dialog splits long words at ${counted(breaks, "mark")} (${CONTINUES}), which are not sent.`] : []);
+    const roomForBody = MAX_WRAPPED_LINES - CONTEXT_RESERVE_LINES;
+    let shown;
+    if ("text" in request) {
+        const { rows, breaks } = wrapRows(request.text);
+        shown = [...opening, textLabel(request.text), ...marksNote(head.breaks + breaks), joinRows(rows)].join("\n");
+        if (rowCount(shown) > roomForBody)
+            return null;
+    }
+    else {
+        const intro = [...opening, ...marksNote(head.breaks)].join("\n");
+        shown = [intro, clipToRows(request.content, roomForBody - rowCount(intro))].join("\n");
+    }
+    if (!request.context)
+        return shown;
+    return [shown, "", CONTEXT_RULE, clipToRows(request.context, MAX_WRAPPED_LINES - rowCount(shown) - 2)].join("\n");
+}
+const KDIALOG_ESCAPES = { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "\\": "&#92;", "\n": "<br>" };
+/**
+ * kdialog has no plain text option: Qt guesses whether a label is rich text, and
+ * kdialog also expands backslash escapes. Always sending escaped rich text removes
+ * the guess, and a backslash entity never reaches the escape parser.
+ */
+export function kdialogText(text) {
+    const escaped = text.replace(/[&<>"\\\n]/g, (ch) => KDIALOG_ESCAPES[ch]);
+    return `<qt><div style="white-space: pre-wrap">${escaped}</div></qt>`;
+}
+function linuxDialogArgs(kind, text, timeout) {
+    if (kind === "zenity") {
+        // The --name=value form keeps text that starts with a dash from being read as a flag.
+        // With --no-markup, zenity neither parses Pango markup nor expands backslash escapes.
+        return [
+            "--question",
+            "--no-markup",
+            "--default-cancel",
+            `--title=${DIALOG_TITLE}`,
+            "--ok-label=Approve",
+            "--cancel-label=Cancel",
+            `--timeout=${timeout}`,
+            `--text=${text}`,
+        ];
+    }
+    // kdialog has no flag for a timeout or for the default button.
+    return ["--title", DIALOG_TITLE, "--yes-label", "Approve", "--no-label", "Cancel", "--warningyesno", kdialogText(text)];
+}
+// A dialog tool reads the environment too. zenity takes its exit codes from ZENITY_OK, ZENITY_CANCEL, and the like,
+// so ZENITY_CANCEL=0 would turn Cancel into approval, and LD_PRELOAD or GTK_MODULES would load code into it.
+const DIALOG_ENV = [
+    "DISPLAY",
+    "WAYLAND_DISPLAY",
+    "XAUTHORITY",
+    "XDG_RUNTIME_DIR",
+    "XDG_SESSION_TYPE",
+    "XDG_CURRENT_DESKTOP",
+    "DBUS_SESSION_BUS_ADDRESS",
+    "HOME",
+    "LANG",
+    "LANGUAGE",
+    "LC_ALL",
+    "LC_CTYPE",
+    "LC_MESSAGES",
+];
+function dialogEnvironment(env) {
+    const kept = { PATH: SYSTEM_DIRECTORIES.join(":") };
+    for (const name of DIALOG_ENV) {
+        const value = env[name];
+        if (value !== undefined)
+            kept[name] = value;
+    }
+    return kept;
+}
+// GTK exits 1 when it cannot open the display, the same code as the Cancel button. GTK 3 and 4 do not translate these.
+const GTK_DISPLAY_FAILURE = /cannot open display|failed to open display/i;
+const MAX_STDERR_CHARS = 64 * 1024;
+function linuxResult(tool, code, stderr) {
+    if (code === 0)
+        return "approved";
+    if (tool === "zenity" && code === 1 && GTK_DISPLAY_FAILURE.test(stderr))
+        return "unavailable";
+    if (code === 1)
+        return "cancelled";
+    if (tool === "zenity" && code === 5)
+        return "timed_out";
+    return "unavailable"; // A crash, a signal, or any other failure.
+}
+function askLinux(tool, path, text, env) {
+    const timeout = approvalTimeoutSeconds(env);
+    return new Promise((resolve) => {
+        let child;
+        try {
+            // No shell and no stdin: the answer is the exit code, and nothing can type into the tool.
+            child = spawn(path, linuxDialogArgs(tool, text, timeout), { stdio: ["ignore", "ignore", "pipe"], env: dialogEnvironment(env) });
+        }
+        catch {
+            resolve("unavailable"); // For example, a NUL in the text.
+            return;
+        }
+        let stderr = "";
+        child.stderr.setEncoding("utf8");
+        child.stderr.on("data", (chunk) => {
+            if (stderr.length < MAX_STDERR_CHARS)
+                stderr += chunk;
+        });
+        // kdialog has no timeout of its own. The kill also covers a zenity that hangs or ignores its --timeout.
+        const timer = setTimeout(() => {
+            child.kill("SIGKILL");
+            resolve("timed_out");
+        }, timeout * 1000);
+        child.once("error", () => {
+            clearTimeout(timer);
+            resolve("unavailable");
+        });
+        // "close" rather than "exit", so all of stderr has arrived before the exit code is read.
+        child.once("close", (code) => {
+            clearTimeout(timer);
+            resolve(linuxResult(tool, code, stderr));
+        });
+    });
+}
+function askMac(path, text, env) {
+    return new Promise((resolve) => {
+        execFile(path, // Absolute, so a PATH entry cannot answer the dialog.
+        ["-e", SCRIPT, text, String(approvalTimeoutSeconds(env))], (error, stdout, stderr) => {
+            if (!error) {
+                const answer = stdout.trim();
+                if (answer === "Approve")
+                    resolve("approved");
+                else if (answer === "timed_out")
+                    resolve("timed_out");
+                else
+                    resolve("cancelled");
+                return;
+            }
+            // AppleScript reports the Cancel button as user-canceled error -128.
+            resolve(stderr.includes("-128") ? "cancelled" : "unavailable");
+        });
+    });
+}
+/**
+ * The human gate for every write. It runs in the tool rather than in a harness
+ * hook so it holds under every agent harness and permission mode, and it fails
+ * closed: anything other than an explicit click on Approve stops the write.
+ * There is deliberately no terminal prompt or override, because an agent could answer those.
+ */
+export function createApprover(machine) {
+    return (request) => {
+        const backend = selectBackend(machine);
+        if (backend.kind === "none")
+            return Promise.resolve(backend.reason);
+        if (backend.kind === "osascript")
+            return askMac(backend.path, formatApproval(request), machine.env);
+        const text = linuxApprovalText(request);
+        if (text === null)
+            return Promise.resolve("too_long");
+        return askLinux(backend.kind, backend.path, text, machine.env);
+    };
+}
+export const approveWithDialog = createApprover({
+    platform: process.platform,
+    env: process.env,
+    isExecutable: isExecutableFile,
+});
+//# sourceMappingURL=approve.js.map

package/dist/src/args.js

@@ -0,0 +1,201 @@
+import { AxiError } from "axi-sdk-js";
+/** Fails loud on unknown flags. `valueFlags` take a value and `boolFlags` do not. */
+export function parseArgs(args, command, valueFlags, boolFlags = []) {
+    const parsed = { positional: [], flags: new Map() };
+    const valid = [...valueFlags, ...boolFlags].join(", ") || "none";
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === "--") {
+            parsed.positional.push(...args.slice(i + 1));
+            break;
+        }
+        if (!arg.startsWith("--")) {
+            parsed.positional.push(arg);
+            continue;
+        }
+        const eq = arg.indexOf("=");
+        const name = eq === -1 ? arg : arg.slice(0, eq);
+        if (boolFlags.includes(name) && eq === -1) {
+            parsed.flags.set(name, true);
+        }
+        else if (valueFlags.includes(name)) {
+            const value = eq === -1 ? args[++i] : arg.slice(eq + 1);
+            if (value === undefined)
+                throw usage(`${name} needs a value`);
+            // The last value winning would silently drop an earlier one, such as a media file.
+            if (parsed.flags.has(name))
+                throw usage(`${name} was given twice; \`${command}\` takes it once`);
+            parsed.flags.set(name, value);
+        }
+        else {
+            throw usage(`unknown flag ${name} for \`${command}\`; valid flags: ${valid}`);
+        }
+    }
+    return parsed;
+}
+export function usage(message, suggestions = []) {
+    return new AxiError(message, "VALIDATION_ERROR", suggestions);
+}
+export function parseLimit(parsed, fallback, min, max) {
+    const raw = parsed.flags.get("--limit");
+    if (raw === undefined)
+        return fallback;
+    const limit = Number(raw);
+    if (!Number.isInteger(limit) || limit < min || limit > max) {
+        throw usage(`--limit must be an integer from ${min} to ${max}`);
+    }
+    return limit;
+}
+/** A dollar cap on what one command may spend. Undefined when the flag is absent. */
+export function parseMaxSpend(parsed) {
+    const raw = parsed.flags.get("--max-spend");
+    if (raw === undefined)
+        return undefined;
+    const usd = Number(raw);
+    if (!Number.isFinite(usd) || usd <= 0)
+        throw usage("--max-spend must be a positive amount in US dollars, such as 2.50");
+    return usd;
+}
+/** Accepts a numeric post ID or a post URL. */
+export function parsePostId(value) {
+    const match = value?.match(/^(?:https?:\/\/(?:www\.)?(?:x|twitter)\.com\/\w+\/status\/)?(\d{1,25})(?:[/?].*)?$/);
+    if (!match?.[1])
+        throw usage(`expected a post ID or URL, got: ${value ?? "nothing"}`);
+    return match[1];
+}
+/** Accepts a numeric List ID or a List URL such as https://x.com/i/lists/123. */
+export function parseListId(value) {
+    const match = value?.match(/^(?:https?:\/\/(?:www\.)?(?:x|twitter)\.com\/i\/lists\/)?(\d{1,19})(?:[/?].*)?$/);
+    if (!match?.[1])
+        throw usage(`expected a List ID or URL such as https://x.com/i/lists/123, got: ${value ?? "nothing"}`);
+    return match[1];
+}
+export function parseHandle(value) {
+    const handle = value?.replace(/^@/, "") ?? "";
+    if (!/^\w{1,15}$/.test(handle))
+        throw usage(`expected an X handle, got: ${value ?? "nothing"}`);
+    return handle;
+}
+// Control and bidi-override characters could make the approval dialog show
+// something other than what gets sent.
+// This covers format, control, separator, private-use, and unassigned code points
+// (tag characters included), plus blank fillers and hidden variation selectors.
+const DECEPTIVE = /[\p{Cc}\p{Cf}\p{Zl}\p{Zp}\p{Co}\p{Cn}\p{Cs}͏ᅟᅠ឴឵᠋-᠍⠀ㅤ︀-︎ﾠ\u{e0100}-\u{e01ef}]/u;
+// Viramas are listed by script because JavaScript has no property for them.
+const VIRAMAS = {
+    Devanagari: "\\u094d",
+    Bengali: "\\u09cd",
+    Gurmukhi: "\\u0a4d",
+    Gujarati: "\\u0acd",
+    Oriya: "\\u0b4d",
+    Tamil: "\\u0bcd",
+    Telugu: "\\u0c4d",
+    Kannada: "\\u0ccd",
+    Malayalam: "\\u0d4d",
+    Sinhala: "\\u0dca",
+};
+const RTL_SCRIPTS = ["Arabic", "Hebrew", "Syriac", "Thaana", "Nko", "Adlam", "Hanifi_Rohingya", "Mandaic", "Samaritan"];
+const letterOf = (script) => `[\\p{L}&&\\p{sc=${script}}]`;
+const RTL_LETTER = `[\\p{L}&&[${RTL_SCRIPTS.map((script) => `\\p{sc=${script}}`).join("")}]]`;
+// The only places DECEPTIVE's characters are ordinary text. Everywhere else they stay refused,
+// and bidi embeddings, overrides, and isolates have no exception, because they can reorder the dialog.
+const ORDINARY_FORMAT = new RegExp(`(${[
+    // U+200D between two emoji, after any U+FE0F or skin tone.
+    String.raw `(?<=\p{Extended_Pictographic}[\u{fe0f}\u{1f3fb}-\u{1f3ff}]?)‍(?=\p{Extended_Pictographic})`,
+    // U+200D after a virama, or between a letter and its script's virama, as in the Bengali ra-phala.
+    `(?<=[${Object.values(VIRAMAS).join("")}])\\u200d`,
+    ...Object.entries(VIRAMAS).map(([script, virama]) => `(?<=${letterOf(script)})\\u200d(?=${virama})`),
+    // U+200C between letters of one script that uses it. The left letter may carry marks, such as a virama.
+    ...["Arabic", ...Object.keys(VIRAMAS)].map((script) => `(?<=${letterOf(script)}\\p{M}*)\\u200c(?=${letterOf(script)})`),
+    // Tag characters only in a well-formed subdivision flag, such as England's.
+    String.raw `(?<=\u{1f3f4})[\u{e0030}-\u{e0039}\u{e0061}-\u{e007a}]{3,7}\u{e007f}`,
+    // U+200E and U+200F only in text that has a right-to-left letter.
+    `[\\u200e\\u200f](?:(?<=${RTL_LETTER}[\\s\\S]*)|(?=[\\s\\S]*${RTL_LETTER}))`,
+    // Emoji newer than this runtime's Unicode tables.
+    String.raw `[\p{Cn}&&\p{Extended_Pictographic}]`,
+].join("|")})`, "gv");
+const MAX_APPROVABLE = 4000;
+const MAX_APPROVABLE_LINES = 40;
+// Three blank lines in a row, or a long run of spaces, could push text out of view in the dialog.
+const HIDING_GAP = /(?:[^\S\n]*\n){4}|[^\S\n]{40}/;
+const ACCEPTED_BLANK = /[\u200d-\u200f\p{M}]/gu;
+/** Length is left to X because the limit depends on the account. */
+export function parseOutgoingText(value) {
+    const visible = (value ?? "").replace(ACCEPTED_BLANK, "");
+    if (value === undefined || !visible.trim())
+        throw usage("the text must not be empty");
+    if (DECEPTIVE.test(value.replace(ORDINARY_FORMAT, "").replaceAll("\n", "")))
+        throw usage("the text contains invisible or control characters; remove them");
+    if (value.length > MAX_APPROVABLE || value.split("\n").length > MAX_APPROVABLE_LINES) {
+        throw usage(`the text is over ${MAX_APPROVABLE} characters or ${MAX_APPROVABLE_LINES} lines, too long to review in the approval dialog`);
+    }
+    if (HIDING_GAP.test(visible))
+        throw usage("the text has a long run of blank lines or spaces; shorten it");
+    return value;
+}
+/** Makes text from X safe to show in the approval dialog: one line, nothing invisible. */
+export function displayText(value) {
+    return value
+        .replace(/\s+/gu, " ")
+        .split(ORDINARY_FORMAT)
+        .map((part, index) => (index % 2 === 1 ? part : Array.from(part, (ch) => (DECEPTIVE.test(ch) ? "\ufffd" : ch)).join("")))
+        .join("");
+}
+const MAX_SHOWN_PATH = 120;
+/** Keeps both ends of a path, because the name of the file and where it sits are what identify it. */
+export function shortenPath(path) {
+    const characters = Array.from(path);
+    if (characters.length <= MAX_SHOWN_PATH)
+        return path;
+    const end = MAX_SHOWN_PATH / 2;
+    return `${characters.slice(0, end).join("")} ...[${characters.length} characters in full]... ${characters.slice(-end).join("")}`;
+}
+export function onePositional(parsed, command) {
+    if (parsed.positional.length > 1) {
+        throw usage(`\`${command}\` takes one argument; quote it if it contains spaces`);
+    }
+    return parsed.positional[0];
+}
+/**
+ * One line of text X will publish that has a documented length range, such as a List name or a poll option.
+ * Characters are counted as code points; X may count some characters as two and refuses what it does not accept.
+ */
+export function parseShortText(value, what, max) {
+    const text = value ?? "";
+    const length = Array.from(text).length;
+    if (length < 1 || length > max)
+        throw usage(`${what} must be 1 to ${max} characters, got ${length}`);
+    if (/[\r\n]/.test(text))
+        throw usage(`${what} must be one line`);
+    try {
+        return parseOutgoingText(text);
+    }
+    catch (error) {
+        throw usage(`${what}: ${error.message}`);
+    }
+}
+// From the create post reference: 2 to 4 options of 1 to 25 characters, open 5 to 10080 minutes.
+const POLL_OPTIONS_MIN = 2;
+const POLL_OPTIONS_MAX = 4;
+const POLL_OPTION_MAX_CHARS = 25;
+export const POLL_MINUTES_MIN = 5;
+export const POLL_MINUTES_MAX = 10_080;
+export const POLL_MINUTES_DEFAULT = 1440;
+/** `--poll "yes|no|maybe"`: options separated by `|`, with the spaces around each trimmed. */
+export function parsePollOptions(raw) {
+    const options = raw.split("|").map((option) => option.trim());
+    if (options.length < POLL_OPTIONS_MIN || options.length > POLL_OPTIONS_MAX) {
+        throw usage(`--poll needs ${POLL_OPTIONS_MIN} to ${POLL_OPTIONS_MAX} options separated by |, got ${options.length}`);
+    }
+    return options.map((option, index) => parseShortText(option, `poll option ${index + 1}`, POLL_OPTION_MAX_CHARS));
+}
+export function parsePollMinutes(raw) {
+    if (raw === undefined)
+        return POLL_MINUTES_DEFAULT;
+    const minutes = Number(raw);
+    if (!Number.isInteger(minutes) || minutes < POLL_MINUTES_MIN || minutes > POLL_MINUTES_MAX) {
+        throw usage(`--poll-minutes must be an integer from ${POLL_MINUTES_MIN} to ${POLL_MINUTES_MAX} (7 days)`);
+    }
+    return minutes;
+}
+//# sourceMappingURL=args.js.map