@runinfra/cli 0.1.0

package/dist/progress.js

@@ -0,0 +1,63 @@
+const MIN_ELAPSED_MS_FOR_RATE = 1_000;
+export function readProgress(snapshot) {
+    const total = Math.max(0, snapshot.totalBytes);
+    const completed = Math.min(Math.max(0, snapshot.completedBytes), total || Number.MAX_SAFE_INTEGER);
+    const percent = total > 0 ? (completed / total) * 100 : 0;
+    if (snapshot.elapsedMs < MIN_ELAPSED_MS_FOR_RATE || snapshot.sessionBytes <= 0) {
+        return { percent, bytesPerSecond: 0, etaSeconds: null };
+    }
+    const bytesPerSecond = snapshot.sessionBytes / (snapshot.elapsedMs / 1000);
+    const remaining = Math.max(0, total - completed);
+    return {
+        percent,
+        bytesPerSecond,
+        etaSeconds: bytesPerSecond > 0 ? Math.ceil(remaining / bytesPerSecond) : null,
+    };
+}
+const UNITS = ["B", "KB", "MB", "GB", "TB"];
+export function formatBytes(bytes) {
+    if (!Number.isFinite(bytes) || bytes < 0)
+        return "0 B";
+    let value = bytes;
+    let unit = 0;
+    while (value >= 1024 && unit < UNITS.length - 1) {
+        value /= 1024;
+        unit += 1;
+    }
+    const decimals = unit === 0 ? 0 : value >= 100 ? 0 : value >= 10 ? 1 : 2;
+    return `${value.toFixed(decimals)} ${UNITS[unit] ?? "B"}`;
+}
+export function formatDuration(seconds) {
+    if (!Number.isFinite(seconds) || seconds < 0)
+        return "unknown";
+    const whole = Math.round(seconds);
+    if (whole < 60)
+        return `${whole}s`;
+    const minutes = Math.floor(whole / 60);
+    if (minutes < 60)
+        return `${minutes}m ${String(whole % 60).padStart(2, "0")}s`;
+    const hours = Math.floor(minutes / 60);
+    return `${hours}h ${String(minutes % 60).padStart(2, "0")}m`;
+}
+export function formatRate(bytesPerSecond) {
+    if (!Number.isFinite(bytesPerSecond) || bytesPerSecond <= 0)
+        return "--";
+    return `${formatBytes(bytesPerSecond)}/s`;
+}
+const BAR_WIDTH = 24;
+export function renderBar(percent) {
+    const clamped = Math.min(100, Math.max(0, percent));
+    const filled = Math.round((clamped / 100) * BAR_WIDTH);
+    return `[${"#".repeat(filled)}${"-".repeat(BAR_WIDTH - filled)}]`;
+}
+export function renderProgress(label, snapshot, reading = readProgress(snapshot)) {
+    const eta = reading.etaSeconds === null ? "--" : formatDuration(reading.etaSeconds);
+    return [
+        label,
+        renderBar(reading.percent),
+        `${reading.percent.toFixed(1)}%`,
+        `${formatBytes(snapshot.completedBytes)} / ${formatBytes(snapshot.totalBytes)}`,
+        formatRate(reading.bytesPerSecond),
+        `ETA ${eta}`,
+    ].join("  ");
+}

package/dist/prompt.js

@@ -0,0 +1,46 @@
+import { createInterface } from "node:readline";
+export function promptLine(question, streams = {}) {
+    const input = streams.input ?? process.stdin;
+    const output = streams.output ?? process.stderr;
+    let settled = false;
+    let close = null;
+    let finishRef = null;
+    const answer = new Promise((resolve) => {
+        const finish = (value) => {
+            if (settled)
+                return;
+            settled = true;
+            close?.();
+            resolve(value);
+        };
+        finishRef = finish;
+        let rl;
+        try {
+            rl = createInterface({
+                input,
+                output,
+                terminal: input.isTTY === true,
+            });
+        }
+        catch {
+            finish(null);
+            return;
+        }
+        close = () => {
+            rl.removeAllListeners();
+            rl.close();
+            if (input === process.stdin)
+                process.stdin.pause();
+        };
+        rl.on("line", (line) => finish(line.trim()));
+        rl.on("close", () => finish(null));
+        rl.on("error", () => finish(null));
+        output.write(`${question}`);
+    });
+    return {
+        answer,
+        cancel() {
+            finishRef?.(null);
+        },
+    };
+}

package/dist/pull.js

@@ -0,0 +1,236 @@
+import { open, mkdir, rename, rm, stat, writeFile } from "node:fs/promises";
+import { isAbsolute, join, resolve as resolvePath } from "node:path";
+import { artifactFileName, partFileName, sidecarFileName } from "./artifact-name.js";
+import { probeArtifact, requestLease } from "./catalog-api.js";
+import { judgeChecksum, sha256File } from "./checksum.js";
+import { requireCredentials } from "./context.js";
+import { assertFreeSpace } from "./disk.js";
+import { runDownload } from "./downloader.js";
+import { CliError } from "./errors.js";
+import { formatBytes, formatDuration } from "./progress.js";
+import { clampConcurrency, normalizeRanges, totalBytes, } from "./range-plan.js";
+import { describeMismatch, parseSidecar, serializeSidecar, sidecarMismatch, SIDECAR_FORMAT, } from "./sidecar.js";
+export async function pull(context, options, signal) {
+    const { output } = context;
+    const { credentials, endpoints } = await requireCredentials(context);
+    const concurrency = clampConcurrency(options.concurrency);
+    let lease = await requestLease(endpoints, credentials.apiKey, options.slug, signal);
+    let probe = await probeArtifact(lease.url, signal);
+    if (!probe.ok && probe.reason === "lease_expired") {
+        lease = await requestLease(endpoints, credentials.apiKey, options.slug, signal);
+        probe = await probeArtifact(lease.url, signal);
+    }
+    if (!probe.ok) {
+        throw new CliError("artifact_not_ready", `The stored files for ${options.slug} could not be read.`, "Try again shortly. If it keeps failing, contact support.");
+    }
+    const artifact = probe.probe;
+    const directory = resolveDestination(options.out);
+    await ensureDirectory(directory);
+    const fileName = artifactFileName({
+        url: lease.url,
+        slug: options.slug,
+        packageVersion: lease.packageVersion,
+    });
+    const finalPath = join(directory, fileName);
+    const partPath = join(directory, partFileName(fileName));
+    const sidecarPath = join(directory, sidecarFileName(fileName));
+    const existing = await statOrNull(finalPath);
+    if (existing !== null) {
+        if (existing.size === artifact.sizeBytes) {
+            output.info(`${fileName} is already downloaded.`);
+            output.result(finalPath);
+            return 0;
+        }
+        throw new CliError("storage_unwritable", `${finalPath} already exists and is a different size (${formatBytes(existing.size)} on disk, ${formatBytes(artifact.sizeBytes)} published).`, "Move or delete that file, or pass --out to a different directory.");
+    }
+    const sidecar = await resolveSidecar({
+        context,
+        slug: options.slug,
+        sidecarPath,
+        partPath,
+        packageVersion: lease.packageVersion,
+        checksumSha256: lease.checksumSha256,
+        sizeBytes: artifact.sizeBytes,
+        etag: artifact.etag,
+    });
+    const usableRanges = normalizeRanges(sidecar.committedRanges, artifact.sizeBytes) ?? [];
+    const alreadyOnDisk = totalBytes(usableRanges);
+    const remaining = Math.max(0, artifact.sizeBytes - alreadyOnDisk);
+    await assertFreeSpace(directory, remaining);
+    if (alreadyOnDisk > 0) {
+        output.info(`Resuming ${fileName}: ${formatBytes(alreadyOnDisk)} of ${formatBytes(artifact.sizeBytes)} already on disk.`);
+    }
+    else {
+        output.info(`Downloading ${fileName} (${formatBytes(artifact.sizeBytes)}) into ${directory}`);
+    }
+    const handle = await openPartFile(partPath, artifact.sizeBytes);
+    const startedAtMs = Date.now();
+    let sessionBytes = 0;
+    try {
+        const result = await runDownload({
+            output,
+            endpoints,
+            apiKey: credentials.apiKey,
+            slug: options.slug,
+            label: fileName,
+            lease,
+            sidecar,
+            handle,
+            concurrency,
+            rangesSupported: artifact.rangesSupported,
+            signal,
+            onCommit: async (committed) => {
+                sidecar.committedRanges = committed;
+                sidecar.updatedAt = new Date().toISOString();
+                await writeSidecar(sidecarPath, sidecar);
+            },
+        });
+        sessionBytes = result.sessionBytes;
+        await handle.sync();
+    }
+    finally {
+        await handle.close().catch(() => undefined);
+    }
+    const elapsedSeconds = Math.max(1, Math.round((Date.now() - startedAtMs) / 1000));
+    output.info(`Transferred ${formatBytes(sessionBytes)} in ${formatDuration(elapsedSeconds)}.`);
+    if (sidecar.checksumSha256 !== null) {
+        let lastTickMs = 0;
+        const actual = await sha256File(partPath, (hashed) => {
+            const nowMs = Date.now();
+            if (nowMs - lastTickMs < 500)
+                return;
+            lastTickMs = nowMs;
+            const percent = artifact.sizeBytes > 0 ? (hashed / artifact.sizeBytes) * 100 : 0;
+            output.status(`  Verifying checksum  ${percent.toFixed(1)}%`);
+        }, signal);
+        output.endStatus();
+        const verdict = judgeChecksum(sidecar.checksumSha256, actual);
+        if (verdict === "mismatch") {
+            throw new CliError("checksum_mismatch", `The downloaded bytes do not match the published checksum for ${options.slug}.`, `The partial file was left at ${partPath}. Delete it and run the command again.`);
+        }
+        if (verdict === "match") {
+            output.detail("Checksum verified.");
+        }
+        else {
+            output.warn("The published checksum could not be read, so the file is UNVERIFIED.");
+        }
+    }
+    else {
+        output.warn("This package publishes no checksum, so the file is UNVERIFIED.");
+    }
+    await rename(partPath, finalPath);
+    await rm(sidecarPath, { force: true });
+    output.info(`Saved ${fileName}.`);
+    output.result(finalPath);
+    return 0;
+}
+function resolveDestination(out) {
+    if (out === null)
+        return process.cwd();
+    return isAbsolute(out) ? resolvePath(out) : resolvePath(process.cwd(), out);
+}
+async function ensureDirectory(directory) {
+    try {
+        await mkdir(directory, { recursive: true });
+    }
+    catch (error) {
+        throw new CliError("storage_unwritable", `Could not create ${directory}: ${error.message}`, "Pass --out to a directory you can write to.");
+    }
+}
+async function statOrNull(path) {
+    try {
+        const stats = await stat(path);
+        return { size: stats.size };
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw new CliError("storage_unwritable", `Could not read ${path}: ${error.message}`, null);
+    }
+}
+async function resolveSidecar(input) {
+    const fresh = {
+        format: SIDECAR_FORMAT,
+        slug: input.slug,
+        packageVersion: input.packageVersion,
+        sizeBytes: input.sizeBytes,
+        checksumSha256: input.checksumSha256,
+        etag: input.etag,
+        committedRanges: [],
+        updatedAt: new Date().toISOString(),
+    };
+    const raw = await readFileOrNull(input.sidecarPath);
+    const existing = raw === null ? null : parseSidecar(raw);
+    const partExists = (await statOrNull(input.partPath)) !== null;
+    if (existing === null) {
+        if (partExists) {
+            input.context.output.warn("The resume record for this download is missing or unreadable, so it starts over.");
+        }
+        await discardPartial(input.partPath, input.sidecarPath);
+        return fresh;
+    }
+    const mismatch = sidecarMismatch(existing, {
+        slug: input.slug,
+        packageVersion: input.packageVersion,
+        sizeBytes: input.sizeBytes,
+        etag: input.etag,
+        checksumSha256: input.checksumSha256,
+    });
+    if (mismatch !== null) {
+        input.context.output.warn(`Starting over because ${describeMismatch(mismatch)}. The partial file was discarded so two versions are never mixed.`);
+        await discardPartial(input.partPath, input.sidecarPath);
+        return fresh;
+    }
+    if (!partExists) {
+        await discardPartial(input.partPath, input.sidecarPath);
+        return fresh;
+    }
+    return {
+        ...existing,
+        checksumSha256: existing.checksumSha256 ?? input.checksumSha256,
+        etag: existing.etag ?? input.etag,
+    };
+}
+async function readFileOrNull(path) {
+    try {
+        const handle = await open(path, "r");
+        try {
+            return await handle.readFile("utf8");
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        return null;
+    }
+}
+async function discardPartial(partPath, sidecarPath) {
+    await rm(partPath, { force: true });
+    await rm(sidecarPath, { force: true });
+}
+async function openPartFile(partPath, sizeBytes) {
+    try {
+        let handle;
+        try {
+            handle = await open(partPath, "r+");
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+            handle = await open(partPath, "w+");
+        }
+        await handle.truncate(sizeBytes);
+        return handle;
+    }
+    catch (error) {
+        throw new CliError("storage_unwritable", `Could not open ${partPath} for writing: ${error.message}`, "Check permissions and free space on the destination, then try again.");
+    }
+}
+async function writeSidecar(path, sidecar) {
+    const temp = `${path}.tmp`;
+    await writeFile(temp, serializeSidecar(sidecar), "utf8");
+    await rename(temp, path);
+}

package/dist/range-plan.js

@@ -0,0 +1,112 @@
+export const DEFAULT_CONCURRENCY = 8;
+export const MIN_CONCURRENCY = 1;
+export const MAX_CONCURRENCY = 16;
+export const MIN_CHUNK_BYTES = 1024 * 1024;
+export const TARGET_CHUNK_BYTES = 32 * 1024 * 1024;
+export function clampConcurrency(requested) {
+    if (requested === null || !Number.isFinite(requested))
+        return DEFAULT_CONCURRENCY;
+    const rounded = Math.trunc(requested);
+    if (rounded < MIN_CONCURRENCY)
+        return MIN_CONCURRENCY;
+    if (rounded > MAX_CONCURRENCY)
+        return MAX_CONCURRENCY;
+    return rounded;
+}
+export function rangeLength(range) {
+    return range.endInclusive - range.start + 1;
+}
+export function totalBytes(ranges) {
+    let sum = 0;
+    for (const range of ranges)
+        sum += rangeLength(range);
+    return sum;
+}
+export function chunkSizeFor(sizeBytes, concurrency) {
+    if (sizeBytes <= 0)
+        return MIN_CHUNK_BYTES;
+    const perWorker = Math.ceil(sizeBytes / Math.max(1, concurrency));
+    return Math.max(MIN_CHUNK_BYTES, Math.min(TARGET_CHUNK_BYTES, perWorker));
+}
+export function planChunks(sizeBytes, chunkBytes) {
+    if (sizeBytes <= 0)
+        return [];
+    const size = Math.max(1, Math.trunc(chunkBytes));
+    const chunks = [];
+    for (let start = 0; start < sizeBytes; start += size) {
+        chunks.push({
+            start,
+            endInclusive: Math.min(start + size, sizeBytes) - 1,
+        });
+    }
+    return chunks;
+}
+export function normalizeRanges(ranges, sizeBytes) {
+    if (!Number.isSafeInteger(sizeBytes) || sizeBytes < 0)
+        return null;
+    const sorted = [];
+    for (const range of ranges) {
+        if (!Number.isSafeInteger(range.start) || !Number.isSafeInteger(range.endInclusive)) {
+            return null;
+        }
+        if (range.start < 0 || range.endInclusive < range.start)
+            return null;
+        if (range.endInclusive > sizeBytes - 1)
+            return null;
+        sorted.push({ start: range.start, endInclusive: range.endInclusive });
+    }
+    sorted.sort((a, b) => a.start - b.start);
+    const merged = [];
+    for (const range of sorted) {
+        const last = merged[merged.length - 1];
+        if (last && range.start <= last.endInclusive + 1) {
+            last.endInclusive = Math.max(last.endInclusive, range.endInclusive);
+            continue;
+        }
+        merged.push(range);
+    }
+    return merged;
+}
+export function missingRanges(sizeBytes, committed) {
+    if (sizeBytes <= 0)
+        return [];
+    const gaps = [];
+    let cursor = 0;
+    for (const range of committed) {
+        if (range.start > cursor) {
+            gaps.push({ start: cursor, endInclusive: range.start - 1 });
+        }
+        cursor = Math.max(cursor, range.endInclusive + 1);
+    }
+    if (cursor <= sizeBytes - 1) {
+        gaps.push({ start: cursor, endInclusive: sizeBytes - 1 });
+    }
+    return gaps;
+}
+export function splitRanges(ranges, chunkBytes) {
+    const size = Math.max(1, Math.trunc(chunkBytes));
+    const out = [];
+    for (const range of ranges) {
+        for (let start = range.start; start <= range.endInclusive; start += size) {
+            out.push({
+                start,
+                endInclusive: Math.min(start + size - 1, range.endInclusive),
+            });
+        }
+    }
+    return out;
+}
+export function planResume(input) {
+    const concurrency = clampConcurrency(input.concurrency);
+    const normalized = normalizeRanges(input.committed, input.sizeBytes);
+    const committed = normalized ?? [];
+    const gaps = missingRanges(input.sizeBytes, committed);
+    const chunkBytes = chunkSizeFor(input.sizeBytes, concurrency);
+    const completedBytes = totalBytes(committed);
+    return {
+        chunks: splitRanges(gaps, chunkBytes),
+        completedBytes,
+        remainingBytes: Math.max(0, input.sizeBytes - completedBytes),
+        restarted: normalized === null,
+    };
+}

package/dist/redact.js

@@ -0,0 +1,8 @@
+export function redact(secret) {
+    const value = secret.trim();
+    if (value.length === 0)
+        return "";
+    if (value.length <= 12)
+        return "*".repeat(8);
+    return `${value.slice(0, 4)}...${value.slice(-4)}`;
+}

package/dist/scopes.js

@@ -0,0 +1,2 @@
+export const CLI_AUTH_SCOPE_CATALOG_DOWNLOAD = "catalog:download";
+export const CLI_REQUESTED_SCOPE = CLI_AUTH_SCOPE_CATALOG_DOWNLOAD;

package/dist/sidecar.js

@@ -0,0 +1,108 @@
+export const SIDECAR_FORMAT = 1;
+export function serializeSidecar(sidecar) {
+    return `${JSON.stringify(sidecar, null, 2)}\n`;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readRanges(value) {
+    if (!Array.isArray(value))
+        return null;
+    const ranges = [];
+    for (const entry of value) {
+        if (!isRecord(entry))
+            return null;
+        const { start, endInclusive } = entry;
+        if (typeof start !== "number" || typeof endInclusive !== "number")
+            return null;
+        if (!Number.isSafeInteger(start) || !Number.isSafeInteger(endInclusive))
+            return null;
+        ranges.push({ start, endInclusive });
+    }
+    return ranges;
+}
+export function parseSidecar(raw) {
+    let value;
+    try {
+        value = JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+    if (!isRecord(value))
+        return null;
+    if (value.format !== SIDECAR_FORMAT)
+        return null;
+    const { slug, packageVersion, sizeBytes, checksumSha256, etag, updatedAt } = value;
+    if (typeof slug !== "string" || slug.length === 0)
+        return null;
+    if (typeof packageVersion !== "number" || !Number.isSafeInteger(packageVersion))
+        return null;
+    if (typeof sizeBytes !== "number" || !Number.isSafeInteger(sizeBytes) || sizeBytes < 0) {
+        return null;
+    }
+    if (checksumSha256 !== null && typeof checksumSha256 !== "string")
+        return null;
+    if (etag !== null && typeof etag !== "string")
+        return null;
+    if (typeof updatedAt !== "string")
+        return null;
+    const committedRanges = readRanges(value.committedRanges);
+    if (committedRanges === null)
+        return null;
+    return {
+        format: SIDECAR_FORMAT,
+        slug,
+        packageVersion,
+        sizeBytes,
+        checksumSha256,
+        etag,
+        committedRanges,
+        updatedAt,
+    };
+}
+export function normalizeEtag(etag) {
+    if (etag === null)
+        return null;
+    const trimmed = etag.trim().replace(/^W\//iu, "");
+    const unquoted = trimmed.replace(/^"([\s\S]*)"$/u, "$1");
+    return unquoted.length > 0 ? unquoted : null;
+}
+export function sidecarMismatch(sidecar, remote) {
+    if (sidecar.slug !== remote.slug)
+        return "slug";
+    if (sidecar.packageVersion !== remote.packageVersion)
+        return "version";
+    if (sidecar.sizeBytes !== remote.sizeBytes)
+        return "size";
+    const stored = normalizeEtag(sidecar.etag);
+    const current = normalizeEtag(remote.etag);
+    if (stored !== null && current !== null && stored !== current)
+        return "etag";
+    if (sidecar.checksumSha256 !== null &&
+        remote.checksumSha256 !== null &&
+        sidecar.checksumSha256.toLowerCase() !== remote.checksumSha256.toLowerCase()) {
+        return "checksum";
+    }
+    const identityProven = stored !== null && current !== null;
+    const verifiableLater = sidecar.checksumSha256 !== null || remote.checksumSha256 !== null;
+    if (!identityProven && !verifiableLater)
+        return "unverifiable";
+    return null;
+}
+export function describeMismatch(mismatch) {
+    switch (mismatch) {
+        case "slug":
+            return "the partial file belongs to a different package";
+        case "version":
+            return "a newer version of this package was published";
+        case "size":
+            return "the published artifact changed size";
+        case "etag":
+            return "the published artifact was replaced";
+        case "checksum":
+            return "the published checksum for this artifact changed";
+        case "unverifiable":
+            return "the partial file cannot be proved to belong to the artifact being served, and this package publishes no checksum that would catch it later";
+    }
+}

package/dist/timers.js

@@ -0,0 +1,13 @@
+export function sleep(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+export function unrefTimer(timer) {
+    if (typeof timer === "object" && timer !== null && "unref" in timer) {
+        const candidate = timer.unref;
+        if (typeof candidate === "function") {
+            candidate.call(timer);
+        }
+    }
+}

package/dist/version.js

@@ -0,0 +1,14 @@
+export const CLI_NAME = "runinfra";
+export const CLI_PACKAGE = "@runinfra/cli";
+export const CLI_VERSION = "0.1.0";
+export const CLI_CLIENT_ID = "runinfra-cli";
+export const MINIMUM_NODE_MAJOR = 20;
+export function isSupportedNodeVersion(version) {
+    const major = Number.parseInt(version.split(".")[0] ?? "", 10);
+    if (!Number.isFinite(major))
+        return false;
+    return major >= MINIMUM_NODE_MAJOR;
+}
+export function userAgent(nodeVersion = process.versions.node, platform = process.platform) {
+    return `${CLI_PACKAGE}/${CLI_VERSION} (node/${nodeVersion}; ${platform})`;
+}

package/dist/whoami.js

@@ -0,0 +1,28 @@
+import { redact } from "./redact.js";
+import { credentialsExpired } from "./credentials.js";
+import { formatDuration } from "./progress.js";
+import { requireCredentials } from "./context.js";
+export async function whoami(context) {
+    const { credentials } = await requireCredentials(context);
+    const expiresAtMs = Date.parse(credentials.expiresAt);
+    const remainingSeconds = Math.max(0, Math.round((expiresAtMs - Date.now()) / 1000));
+    const rows = [
+        ["Workspace", credentials.workspaceId],
+        ["Key", `${credentials.keyPrefix} (${redact(credentials.apiKey)})`],
+        ["Grants", credentials.scope.length > 0 ? credentials.scope : "none"],
+        ["Endpoint", credentials.apiBase],
+        ["Connected", credentials.createdAt],
+        [
+            "Expires",
+            credentialsExpired(credentials)
+                ? `${credentials.expiresAt} (expired)`
+                : `${credentials.expiresAt} (in ${formatDuration(remainingSeconds)})`,
+        ],
+    ];
+    const width = Math.max(...rows.map(([label]) => label.length));
+    for (const [label, value] of rows) {
+        context.output.result(`${label.padEnd(width)}  ${value}`);
+    }
+    context.output.info("This is what this machine has stored. Access may have been revoked from Settings, API keys since it was granted.");
+    return 0;
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@runinfra/cli",
+  "version": "0.1.0",
+  "description": "RunInfra CLI: browser-approved sign-in and resumable downloads for optimized model packages",
+  "license": "SEE LICENSE IN LICENSE",
+  "homepage": "https://runinfra.ai/optimized-models",
+  "bugs": {
+    "url": "https://runinfra.ai/contact"
+  },
+  "keywords": [
+    "runinfra",
+    "cli",
+    "oauth",
+    "pkce",
+    "model",
+    "download",
+    "resumable"
+  ],
+  "type": "module",
+  "bin": {
+    "runinfra": "./bin/runinfra.mjs"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {},
+  "scripts": {
+    "build": "node ../node_modules/typescript/bin/tsc -p tsconfig.json",
+    "prepack": "node ../node_modules/typescript/bin/tsc -p tsconfig.json",
+    "test": "node ../node_modules/vitest/vitest.mjs run cli/src --root .."
+  },
+  "files": [
+    "bin",
+    "dist",
+    "README.md",
+    "LICENSE",
+    "package.json"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "sideEffects": false
+}