@shreejitverma/x-axi 0.0.0-stage → 0.3.0

package/dist/src/config.js

@@ -0,0 +1,67 @@
+import { AxiError } from "axi-sdk-js";
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+/** A fixed port and path, because X matches the registered callback exactly. 127.0.0.1 follows RFC 8252 section 7.3. */
+export const DEFAULT_REDIRECT_URI = "http://127.0.0.1:8711/callback";
+export function configDir() {
+    const xdg = process.env["XDG_CONFIG_HOME"];
+    return join(xdg || join(homedir(), ".config"), "x-axi");
+}
+export function configPath() {
+    return join(configDir(), "config.json");
+}
+export function readConfig() {
+    let raw;
+    try {
+        raw = readFileSync(configPath(), "utf8");
+    }
+    catch (error) {
+        if (["ENOENT", "ENOTDIR"].includes(error.code ?? ""))
+            return {};
+        throw new AxiError(`cannot read ${configPath()}: ${error.message}`, "CONFIG_INVALID");
+    }
+    let value;
+    try {
+        value = JSON.parse(raw);
+    }
+    catch (error) {
+        throw new AxiError(`${configPath()} is not valid JSON: ${error.message}`, "CONFIG_INVALID", ["Fix or delete the file, then run `x-axi login --client-id YOUR_CLIENT_ID`"]);
+    }
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new AxiError(`${configPath()} must hold a JSON object`, "CONFIG_INVALID");
+    const config = value;
+    const result = {};
+    if (config["client_id"] !== undefined)
+        result.client_id = parseClientId(config["client_id"], configPath());
+    if (config["redirect_uri"] !== undefined)
+        result.redirect_uri = parseRedirectUri(config["redirect_uri"], configPath());
+    return result;
+}
+export function writeConfig(config) {
+    const dir = configDir();
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const temp = join(dir, "config.json.tmp");
+    writeFileSync(temp, `${JSON.stringify(config, null, 2)}\n`, { mode: 0o600 });
+    renameSync(temp, configPath());
+}
+/** X client IDs are URL-safe tokens. Anything else is a paste error, and must not reach a URL. */
+export function parseClientId(value, source) {
+    if (typeof value !== "string" || !/^[A-Za-z0-9_-]{8,200}$/.test(value)) {
+        throw new AxiError(`${source} does not hold a valid OAuth 2.0 client ID`, "VALIDATION_ERROR", [
+            "Copy the OAuth 2.0 Client ID from your app's Keys and tokens page at https://console.x.com",
+        ]);
+    }
+    return value;
+}
+/** Only a 127.0.0.1 callback on an unprivileged port: the browser must come back to this machine, and X must match it exactly. */
+export function parseRedirectUri(value, source) {
+    const port = typeof value === "string" ? /^http:\/\/127\.0\.0\.1:([1-9]\d{3,4})\/[\w/-]*$/.exec(value)?.[1] : undefined;
+    if (port === undefined || Number(port) < 1024 || Number(port) > 65535) {
+        throw new AxiError(`${source} redirect_uri must be an http://127.0.0.1 URL with a port from 1024 to 65535, like ${DEFAULT_REDIRECT_URI}`, "VALIDATION_ERROR", [
+            "Register the same URI as the app's Callback URI in the X portal; X matches it character for character",
+        ]);
+    }
+    return value;
+}
+//# sourceMappingURL=config.js.map

package/dist/src/keystore.js

@@ -0,0 +1,186 @@
+import { AxiError } from "axi-sdk-js";
+import { execFile } from "node:child_process";
+import { accessSync, constants } from "node:fs";
+import { delimiter, join } from "node:path";
+const COMMAND_TIMEOUT_MS = 30_000;
+export const runCommand = (spec) => new Promise((resolve) => {
+    const child = execFile(spec.file, spec.args, { timeout: COMMAND_TIMEOUT_MS, maxBuffer: 1 << 20 }, (error, stdout, stderr) => {
+        const failure = error;
+        resolve({
+            code: failure ? (typeof failure.code === "number" ? failure.code : null) : 0,
+            stdout,
+            stderr: failure?.killed ? `timed out after ${COMMAND_TIMEOUT_MS / 1000} seconds\n${stderr}` : stderr,
+            missing: failure?.code === "ENOENT",
+        });
+    });
+    // A child that exits before reading stdin raises EPIPE here; its exit code already carries the failure.
+    child.stdin?.on("error", () => undefined);
+    child.stdin?.end(spec.stdin ?? "");
+});
+const SERVICE = "x-axi";
+const ACCOUNT = "oauth2";
+const SECURITY = "/usr/bin/security";
+// `security -i` splits a line near 4096 bytes and runs each fragment as its own command, which
+// in the experiment wrote a fragment to the default keychain. Refusing well below that bound
+// keeps a record from ever being split.
+const MAX_SECURITY_LINE = 3000;
+const ERR_SEC_ITEM_NOT_FOUND = 44;
+const ERR_SEC_ITEM_NOT_FOUND_STATUS = "-25300";
+const ERR_SEC_INTERACTION_NOT_ALLOWED = 36;
+/** Base64 keeps the record to one shell-safe token with no quoting rules to get wrong. */
+function encode(secret) {
+    return Buffer.from(secret, "utf8").toString("base64");
+}
+/** KEYSTORE_CORRUPT is the one read failure logout may treat as "a record exists": the backend worked, the content did not. */
+function decode(stored, backend) {
+    if (!/^[A-Za-z0-9+/]*={0,2}$/.test(stored)) {
+        throw new AxiError(`the ${backend} record for x-axi is not one this version wrote`, "KEYSTORE_CORRUPT", [
+            "Run `x-axi logout` to delete it, then `x-axi login`",
+        ]);
+    }
+    return Buffer.from(stored, "base64").toString("utf8");
+}
+/**
+ * `security` exits with the low byte of an OSStatus, so the text is checked too before a failure counts as "no record".
+ * That text follows the system language, so `security error` supplies it. It exits 1 even when it prints the message.
+ */
+async function keychainSaysNotFound(result, run) {
+    if (result.code !== ERR_SEC_ITEM_NOT_FOUND)
+        return false;
+    const explained = await run({ file: SECURITY, args: ["error", ERR_SEC_ITEM_NOT_FOUND_STATUS] });
+    const message = new RegExp(`^Error: \\S+ ${ERR_SEC_ITEM_NOT_FOUND_STATUS} (.+)$`).exec(explained.stdout.trim())?.[1];
+    return message !== undefined && result.stderr.includes(message);
+}
+/** Only the first line of stderr, with the secret removed in case a tool echoed its input. */
+function stderrSummary(result, secrets) {
+    let line = result.stderr.split("\n").find((l) => l.trim()) ?? "";
+    for (const secret of secrets)
+        if (secret)
+            line = line.replaceAll(secret, "[redacted]");
+    return line.slice(0, 160) || `exit code ${String(result.code)}`;
+}
+function keystoreFailure(backend, action, result, secrets = []) {
+    return new AxiError(`${backend} could not ${action} the x-axi login: ${stderrSummary(result, secrets)}`, "KEYSTORE_ERROR");
+}
+/**
+ * macOS Keychain through the system `security` tool at its absolute path. Writes go through
+ * `security -i`, which reads the whole command from stdin, so the record never appears in argv.
+ * The optional keychain path exists for tests, which use a temporary keychain and never the login keychain.
+ */
+export function keychainStore(run, keychain) {
+    const backend = "macOS Keychain";
+    if (keychain !== undefined && !/^[\w./-]+$/.test(keychain)) {
+        throw new AxiError("the keychain path may contain only letters, digits, and ./_-", "VALIDATION_ERROR");
+    }
+    const target = keychain === undefined ? [] : [keychain];
+    const fail = (action, result, secrets) => {
+        if (result.code === ERR_SEC_INTERACTION_NOT_ALLOWED) {
+            return new AxiError(`the keychain is locked and this session cannot show an unlock prompt, so x-axi could not ${action} its login`, "KEYSTORE_LOCKED", [
+                "Unlock it with `security unlock-keychain` in that session, or log in to the Mac's desktop session",
+            ]);
+        }
+        return keystoreFailure(backend, action, result, secrets);
+    };
+    return {
+        backend,
+        async read() {
+            const result = await run({ file: SECURITY, args: ["find-generic-password", "-a", ACCOUNT, "-s", SERVICE, "-w", ...target] });
+            if (await keychainSaysNotFound(result, run))
+                return undefined;
+            if (result.code !== 0)
+                throw fail("read", result);
+            return decode(result.stdout.trim(), backend);
+        },
+        async write(secret) {
+            const encoded = encode(secret);
+            const line = `add-generic-password -a ${ACCOUNT} -s ${SERVICE} -w ${encoded} -U ${target.join(" ")}\n`;
+            if (Buffer.byteLength(line) > MAX_SECURITY_LINE) {
+                throw new AxiError("the login record is too large to store in the keychain safely; nothing was written", "KEYSTORE_ERROR");
+            }
+            const result = await run({ file: SECURITY, args: ["-i"], stdin: line });
+            if (result.code !== 0)
+                throw fail("store", result, [secret, encoded]);
+        },
+        async delete() {
+            const result = await run({ file: SECURITY, args: ["delete-generic-password", "-a", ACCOUNT, "-s", SERVICE, ...target] });
+            if (result.code !== 0 && !(await keychainSaysNotFound(result, run)))
+                throw fail("delete", result);
+        },
+    };
+}
+export const SECRET_SERVICE_INSTALL = [
+    "Install secret-tool: `sudo apt install libsecret-tools` (Debian, Ubuntu), `sudo dnf install libsecret` (Fedora), or `sudo pacman -S libsecret` (Arch)",
+    "Make sure a Secret Service is running, such as GNOME Keyring or KeePassXC with Secret Service integration enabled",
+];
+/** Linux Secret Service through `secret-tool`, which reads the secret from stdin when stdin is not a terminal. */
+export function secretServiceStore(run, tool) {
+    const backend = "Secret Service";
+    const attrs = ["service", SERVICE, "account", ACCOUNT];
+    const unavailable = (result) => new AxiError(`secret-tool failed: ${stderrSummary(result, [])}`, "KEYSTORE_UNAVAILABLE", SECRET_SERVICE_INSTALL);
+    return {
+        backend,
+        async read() {
+            const result = await run({ file: tool, args: ["lookup", ...attrs] });
+            if (result.missing)
+                throw unavailable(result);
+            // secret-tool exits 1 both for a missing item and for a missing daemon; only the daemon case writes to stderr.
+            if (result.code === 1 && !result.stderr.trim())
+                return undefined;
+            if (result.code !== 0)
+                throw unavailable(result);
+            return decode(result.stdout.trim(), backend);
+        },
+        async write(secret) {
+            const encoded = encode(secret);
+            const result = await run({ file: tool, args: ["store", `--label=${SERVICE}`, ...attrs], stdin: encoded });
+            if (result.missing)
+                throw unavailable(result);
+            if (result.code !== 0)
+                throw keystoreFailure(backend, "store", result, [secret, encoded]);
+        },
+        async delete() {
+            const result = await run({ file: tool, args: ["clear", ...attrs] });
+            if (result.missing)
+                throw unavailable(result);
+            if (result.code !== 0)
+                throw keystoreFailure(backend, "delete", result);
+        },
+    };
+}
+/** Every call fails with the reason the platform has no keystore. There is no plaintext fallback. */
+export function unavailableKeystore(error) {
+    const reject = () => Promise.reject(error);
+    return { backend: `unavailable (${error.message})`, read: reject, write: reject, delete: reject };
+}
+export function findOnPath(name, path = process.env["PATH"] ?? "") {
+    for (const dir of path.split(delimiter)) {
+        if (!dir)
+            continue;
+        const candidate = join(dir, name);
+        try {
+            accessSync(candidate, constants.X_OK);
+            return candidate;
+        }
+        catch {
+            // Not here; keep looking.
+        }
+    }
+    return undefined;
+}
+export function selectKeystore(env = { platform: process.platform, run: runCommand, which: findOnPath }) {
+    if (env.platform === "darwin")
+        return keychainStore(env.run);
+    if (env.platform === "linux") {
+        const tool = env.which("secret-tool");
+        if (tool)
+            return secretServiceStore(env.run, tool);
+        return unavailableKeystore(new AxiError("no OS keystore is available: secret-tool is not installed, and x-axi never stores a login in a plain file", "KEYSTORE_UNAVAILABLE", SECRET_SERVICE_INSTALL));
+    }
+    if (env.platform === "win32") {
+        return unavailableKeystore(new AxiError("Windows is not supported: x-axi has no Windows Credential Manager backend yet, and it never stores a login in a plain file", "KEYSTORE_UNAVAILABLE", [
+            "Run x-axi on macOS or Linux, or add a Credential Manager backend",
+        ]));
+    }
+    return unavailableKeystore(new AxiError(`no OS keystore backend exists for ${env.platform}, and x-axi never stores a login in a plain file`, "KEYSTORE_UNAVAILABLE"));
+}
+//# sourceMappingURL=keystore.js.map

package/dist/src/ledger.js

@@ -0,0 +1,172 @@
+import { AxiError } from "axi-sdk-js";
+import { appendFileSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+export function stateDir() {
+    return process.env["X_AXI_STATE_DIR"] ?? join(homedir(), ".local", "state", "x-axi");
+}
+function ensureDir() {
+    const dir = stateDir();
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    return dir;
+}
+/** Returns a warning instead of throwing: a ledger problem must never hide that a write succeeded. */
+export function recordSpend(op, usd, now = new Date()) {
+    try {
+        const entry = { at: now.toISOString(), op, usd };
+        appendFileSync(join(ensureDir(), "ledger.jsonl"), `${JSON.stringify(entry)}\n`);
+        return undefined;
+    }
+    catch (error) {
+        return `spend ledger not updated: ${String(error)}`;
+    }
+}
+export function summarizeSpend(now = new Date()) {
+    let raw = "";
+    try {
+        raw = readFileSync(join(stateDir(), "ledger.jsonl"), "utf8");
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    const day = now.toISOString().slice(0, 10);
+    const cutoff = now.getTime() - 30 * 24 * 3600 * 1000;
+    let today = 0;
+    let month = 0;
+    let calls = 0;
+    let unpriced = 0;
+    let corrupt = 0;
+    for (const line of raw.split("\n")) {
+        if (!line)
+            continue;
+        let entry;
+        try {
+            entry = JSON.parse(line);
+        }
+        catch {
+            corrupt += 1;
+            continue;
+        }
+        if (new Date(entry.at).getTime() < cutoff)
+            continue;
+        calls += 1;
+        if (entry.usd === null)
+            unpriced += 1;
+        month += entry.usd ?? 0;
+        if (entry.at.startsWith(day))
+            today += entry.usd ?? 0;
+    }
+    return {
+        today_usd: today.toFixed(3),
+        last_30d_usd: month.toFixed(3),
+        calls_30d: calls,
+        unpriced_calls_30d: unpriced,
+        corrupt_lines: corrupt,
+    };
+}
+export function readAccount() {
+    try {
+        return JSON.parse(readFileSync(join(stateDir(), "account.json"), "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+}
+export function writeAccount(account) {
+    migrateFollowLog(readAccount() ?? account);
+    writeFileSync(join(ensureDir(), "account.json"), JSON.stringify(account), { mode: 0o600 });
+}
+/** After logout the cached account would name a login that no longer exists. The ledger and follow log stay. */
+export function clearAccount() {
+    const account = readAccount();
+    if (account)
+        migrateFollowLog(account);
+    try {
+        unlinkSync(join(stateDir(), "account.json"));
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+}
+export const DAY_MS = 24 * 3600 * 1000;
+/**
+ * Version 1 was a flat map of user ID to time, with no owner. Only account.json
+ * can name that owner, so this must run before account.json is overwritten or deleted.
+ * A missing or corrupt file is left for readFollows to handle.
+ */
+function migrateFollowLog(owner) {
+    let value;
+    try {
+        value = JSON.parse(readFileSync(join(stateDir(), "follows.json"), "utf8"));
+    }
+    catch {
+        return;
+    }
+    if (!value || typeof value !== "object" || Array.isArray(value) || "version" in value)
+        return;
+    const following = value;
+    saveFollowFile({ version: 2, accounts: { [owner.id]: { following, events: Object.values(following) } } });
+}
+/** Callers after a confirmed write report only the message, so the help can speak for the checks made before sending. */
+function followLogError(path, reason) {
+    return new AxiError(`the follow log at ${path} is unusable: ${reason}`, "FOLLOW_LOG_CORRUPT", [
+        "Nothing was sent. Repair or restore that file; it holds the resume state and the 24-hour follow count",
+    ]);
+}
+// A corrupt log must stop a batch, or the daily cap would silently reset.
+function loadFollowFile() {
+    const path = join(stateDir(), "follows.json");
+    let file;
+    try {
+        file = JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return { version: 2, accounts: {} };
+        throw followLogError(path, error.message);
+    }
+    if (file?.version !== 2 || !file.accounts)
+        throw followLogError(path, "it is not a version 2 follow log");
+    return file;
+}
+function saveFollowFile(file) {
+    const dir = ensureDir();
+    const temp = join(dir, "follows.json.tmp");
+    writeFileSync(temp, JSON.stringify(file), { mode: 0o600 });
+    renameSync(temp, join(dir, "follows.json"));
+}
+export function readFollows(accountId) {
+    return loadFollowFile().accounts[accountId] ?? { following: {}, events: [] };
+}
+/** Throws if a later log update would fail on the current file, so a problem can stop a write before it is sent. */
+export function assertFollowLogReadable() {
+    loadFollowFile();
+}
+function addFollowEvent(file, accountId, now) {
+    const record = file.accounts[accountId] ?? { following: {}, events: [] };
+    record.events = [...record.events.filter((event) => now.getTime() - new Date(event).getTime() < DAY_MS), now.toISOString()];
+    file.accounts[accountId] = record;
+    return record;
+}
+export function logFollow(accountId, targetId, now = new Date()) {
+    const file = loadFollowFile();
+    addFollowEvent(file, accountId, now).following[targetId] = now.toISOString();
+    saveFollowFile(file);
+}
+/** For a follow X may have applied: it counts against the cap, but resume must still check that account. */
+export function logFollowAttempt(accountId, now = new Date()) {
+    const file = loadFollowFile();
+    addFollowEvent(file, accountId, now);
+    saveFollowFile(file);
+}
+export function logUnfollow(accountId, targetId) {
+    const file = loadFollowFile();
+    const record = file.accounts[accountId];
+    if (!record)
+        return;
+    delete record.following[targetId];
+    saveFollowFile(file);
+}
+//# sourceMappingURL=ledger.js.map

package/dist/src/media.js

@@ -0,0 +1,123 @@
+import { AxiError } from "axi-sdk-js";
+import { closeSync, openSync, readSync, statSync } from "node:fs";
+import { basename, extname, resolve } from "node:path";
+import { displayText, shortenPath, usage } from "./args.js";
+/**
+ * From https://docs.x.com/x-api/media/quickstart/media-upload-chunked and
+ * https://docs.x.com/x-api/media/quickstart/best-practices, read 2026-11-01.
+ * Each segment at or below 5 MB; the server maximum is 8 MB. Decimal here, so it holds whichever megabyte X means.
+ */
+export const MEDIA_CHUNK_BYTES = 5_000_000;
+const MIB = 1024 * 1024;
+// Video allows the Premium size, because the account's tier is not known locally. X applies the 8 GB default itself.
+const KINDS = {
+    "image/jpeg": { category: "tweet_image", maxBytes: 5 * MIB, extensions: [".jpg", ".jpeg"] },
+    "image/png": { category: "tweet_image", maxBytes: 5 * MIB, extensions: [".png"] },
+    "image/webp": { category: "tweet_image", maxBytes: 5 * MIB, extensions: [".webp"] },
+    "image/gif": { category: "tweet_gif", maxBytes: 15 * MIB, extensions: [".gif"] },
+    "video/mp4": { category: "tweet_video", maxBytes: 16 * 1024 * MIB, extensions: [".mp4", ".m4v"] },
+    "video/quicktime": { category: "tweet_video", maxBytes: 16 * 1024 * MIB, extensions: [".mov"] },
+    "video/webm": { category: "tweet_video", maxBytes: 16 * 1024 * MIB, extensions: [".webm"] },
+};
+// ftyp major brands of plain MP4 files, from the MP4 Registration Authority (mp4ra.org). HEIC, AVIF, M4A, and 3GP share the container but are not on it.
+const MP4_BRANDS = new Set(["isom", "iso2", "iso3", "iso4", "iso5", "iso6", "mp41", "mp42", "avc1", "M4V ", "M4VH", "M4VP", "dash", "MSNV", "XAVC"]);
+const EBML_DOCTYPE_ID = Buffer.from([0x42, 0x82]);
+/** The EBML header holds the DocType, which separates WebM from other Matroska files. */
+function isWebm(header) {
+    const id = header.indexOf(EBML_DOCTYPE_ID);
+    return id !== -1 && header.toString("latin1", id + 3, id + 7) === "webm";
+}
+/** The file's own bytes decide its type, so a renamed file cannot pass as something else. */
+function sniff(header) {
+    const ascii = (start, end) => header.toString("latin1", start, end);
+    if (header[0] === 0xff && header[1] === 0xd8 && header[2] === 0xff)
+        return "image/jpeg";
+    if (header[0] === 0x89 && ascii(1, 4) === "PNG")
+        return "image/png";
+    if (ascii(0, 4) === "GIF8")
+        return "image/gif";
+    if (ascii(0, 4) === "RIFF" && ascii(8, 12) === "WEBP")
+        return "image/webp";
+    if (ascii(4, 8) === "ftyp") {
+        const brand = ascii(8, 12);
+        if (brand === "qt  ")
+            return "video/quicktime";
+        return MP4_BRANDS.has(brand) ? "video/mp4" : undefined;
+    }
+    if (header.subarray(0, 4).equals(Buffer.from([0x1a, 0x45, 0xdf, 0xa3])))
+        return isWebm(header) ? "video/webm" : undefined;
+    return undefined;
+}
+function mb(bytes) {
+    return `${(bytes / 1_000_000).toFixed(1)} MB`;
+}
+/** Checks everything knowable without spending. Video duration is not knowable here, so X judges that. */
+export function inspectMedia(path) {
+    const header = Buffer.alloc(64);
+    let size;
+    let modifiedAt;
+    try {
+        const stat = statSync(path);
+        if (!stat.isFile())
+            throw usage(`${path} is not a file`);
+        size = stat.size;
+        modifiedAt = stat.mtimeMs;
+        const fd = openSync(path, "r");
+        try {
+            readSync(fd, header, 0, header.length, 0);
+        }
+        finally {
+            closeSync(fd);
+        }
+    }
+    catch (error) {
+        if (error instanceof AxiError)
+            throw error;
+        throw usage(`cannot read ${path}: ${error.message}`);
+    }
+    if (size === 0)
+        throw usage(`${path} is empty`);
+    const mediaType = sniff(header);
+    const kind = mediaType ? KINDS[mediaType] : undefined;
+    if (!mediaType || !kind)
+        throw usage(`${path} is not a supported file: expected JPEG, PNG, WebP, GIF, MP4, MOV, or WebM content`);
+    if (!kind.extensions.includes(extname(path).toLowerCase())) {
+        throw usage(`${path} holds ${mediaType} content, but its extension says otherwise; rename it to ${kind.extensions[0]}`);
+    }
+    if (size > kind.maxBytes)
+        throw usage(`${path} is ${mb(size)}, over X's ${mb(kind.maxBytes)} limit for ${mediaType}`);
+    return { path, name: basename(path), mediaType, category: kind.category, size, modifiedAt };
+}
+export function chunkCount(size) {
+    return Math.ceil(size / MEDIA_CHUNK_BYTES);
+}
+/** The approval dialog and the dry-run output both name the file this way. */
+export function describeMedia(media) {
+    return `${shortenPath(displayText(resolve(media.path)))} (${media.mediaType}, ${mb(media.size)})`;
+}
+/** Yields one reused buffer, so a consumer must copy what it keeps. Refuses a file that changed after approval. */
+export function* readChunks(media) {
+    const assertUnchanged = () => {
+        const stat = statSync(media.path);
+        if (stat.size !== media.size || stat.mtimeMs !== media.modifiedAt) {
+            throw new AxiError(`${media.path} changed after it was approved; nothing was posted`, "VALIDATION_ERROR", ["Run the command again so the dialog shows the current file"]);
+        }
+    };
+    assertUnchanged();
+    const fd = openSync(media.path, "r");
+    try {
+        const buffer = Buffer.alloc(Math.min(MEDIA_CHUNK_BYTES, media.size));
+        for (let offset = 0; offset < media.size; offset += MEDIA_CHUNK_BYTES) {
+            const want = Math.min(MEDIA_CHUNK_BYTES, media.size - offset);
+            const got = readSync(fd, buffer, 0, want, offset);
+            if (got !== want)
+                throw new AxiError(`${media.path} changed after it was approved; nothing was posted`, "VALIDATION_ERROR");
+            yield buffer.subarray(0, want);
+        }
+        assertUnchanged();
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+//# sourceMappingURL=media.js.map