@lynxship/cli 0.1.0

package/dist/secure-store.js

@@ -0,0 +1,263 @@
+import { chmod, mkdir, readFile, unlink, writeFile } from "node:fs/promises";
+import { spawn } from "node:child_process";
+import { join, resolve } from "node:path";
+import { assert } from "@lynxship/contracts";
+import { globalLynxShipDirectory } from "./paths.js";
+export function credentialStorageDescription() {
+    if (process.platform === "win32")
+        return "Windows DPAPI encrypted";
+    if (process.platform === "darwin")
+        return "macOS Keychain";
+    return "owner-only credential file";
+}
+const fileName = ".credentials.dpapi.json";
+const keychainService = "com.lynxship.cli.credentials";
+function credentialFile(root, global = false) {
+    return join(global ? globalLynxShipDirectory() : join(root, ".lynxship"), fileName);
+}
+function runPowerShell(command, input) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(`${process.env.SystemRoot ?? "C:\\Windows"}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe`, ["-NoProfile", "-NonInteractive", "-Command", command], {
+            windowsHide: true,
+            stdio: ["pipe", "pipe", "pipe"],
+            env: {
+                ...process.env,
+                PSModulePath: [
+                    `${process.env.SystemRoot ?? "C:\\Windows"}\\System32\\WindowsPowerShell\\v1.0\\Modules`,
+                    `${process.env.ProgramFiles ?? "C:\\Program Files"}\\WindowsPowerShell\\Modules`,
+                ].join(";"),
+            },
+        });
+        let output = "";
+        let error = "";
+        child.stdout.on("data", (chunk) => (output += chunk.toString()));
+        child.stderr.on("data", (chunk) => (error += chunk.toString()));
+        child.once("error", reject);
+        child.once("close", (code) => {
+            if (code !== 0)
+                reject(new Error(error.trim() || "Windows secure storage failed"));
+            else
+                resolve(output.trim());
+        });
+        child.stdin.end(input);
+    });
+}
+async function protect(value) {
+    if (process.platform !== "win32")
+        return value;
+    return runPowerShell("Import-Module Microsoft.PowerShell.Security; $input | ConvertTo-SecureString -AsPlainText -Force | ConvertFrom-SecureString", value);
+}
+async function unprotect(value) {
+    if (process.platform !== "win32")
+        return value;
+    return runPowerShell("Import-Module Microsoft.PowerShell.Security; $cipher = [Console]::In.ReadToEnd(); $secure = ConvertTo-SecureString $cipher; $ptr = [Runtime.InteropServices.Marshal]::SecureStringToBSTR($secure); try { [Runtime.InteropServices.Marshal]::PtrToStringBSTR($ptr) } finally { [Runtime.InteropServices.Marshal]::ZeroFreeBSTR($ptr) }", value);
+}
+function runSecurity(args) {
+    return new Promise((resolveOutput, reject) => {
+        const child = spawn("security", args, {
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        let output = "";
+        let error = "";
+        child.stdout.on("data", (chunk) => (output += chunk.toString()));
+        child.stderr.on("data", (chunk) => (error += chunk.toString()));
+        child.once("error", reject);
+        child.once("close", (code) => {
+            if (code !== 0)
+                reject(new Error(error.trim() || "macOS Keychain operation failed"));
+            else
+                resolveOutput(output.trim());
+        });
+        child.stdin.end();
+    });
+}
+function keychainAccount(root, global) {
+    return global ? "global" : `project:${resolve(root)}`;
+}
+function credentialValues(credentials) {
+    const values = {};
+    if (credentials.r2) {
+        values.r2AccessKeyId = credentials.r2.accessKeyId;
+        values.r2SecretAccessKey = credentials.r2.secretAccessKey;
+    }
+    if (credentials.android) {
+        values.androidKeystorePath = credentials.android.keystorePath;
+        values.androidKeyAlias = credentials.android.keyAlias;
+        values.androidKeystorePassword = credentials.android.keystorePassword;
+        values.androidKeyPassword = credentials.android.keyPassword;
+    }
+    if (credentials.googlePlay) {
+        values.googlePlayServiceAccountJson =
+            credentials.googlePlay.serviceAccountJson;
+        values.googlePlayApplicationId = credentials.googlePlay.applicationId;
+        values.googlePlayTrack = credentials.googlePlay.track;
+        values.googlePlayReleaseStatus = credentials.googlePlay.releaseStatus;
+    }
+    if (credentials.appStoreConnect) {
+        values.ascApiKeyId = credentials.appStoreConnect.apiKeyId;
+        values.ascIssuerId = credentials.appStoreConnect.issuerId;
+        values.ascPrivateKey = credentials.appStoreConnect.privateKey;
+        values.ascBundleIdentifier = credentials.appStoreConnect.bundleIdentifier;
+        values.ascAppId = credentials.appStoreConnect.ascAppId ?? "";
+        values.ascTransporterPath =
+            credentials.appStoreConnect.transporterPath ?? "";
+    }
+    return values;
+}
+function credentialsFromValues(values) {
+    return {
+        r2: values.r2AccessKeyId && values.r2SecretAccessKey
+            ? {
+                accessKeyId: values.r2AccessKeyId,
+                secretAccessKey: values.r2SecretAccessKey,
+            }
+            : undefined,
+        android: values.androidKeystorePath &&
+            values.androidKeyAlias &&
+            values.androidKeystorePassword &&
+            values.androidKeyPassword
+            ? {
+                keystorePath: values.androidKeystorePath,
+                keyAlias: values.androidKeyAlias,
+                keystorePassword: values.androidKeystorePassword,
+                keyPassword: values.androidKeyPassword,
+            }
+            : undefined,
+        googlePlay: values.googlePlayServiceAccountJson &&
+            values.googlePlayApplicationId &&
+            values.googlePlayTrack &&
+            values.googlePlayReleaseStatus
+            ? {
+                serviceAccountJson: values.googlePlayServiceAccountJson,
+                applicationId: values.googlePlayApplicationId,
+                track: values.googlePlayTrack,
+                releaseStatus: values.googlePlayReleaseStatus,
+            }
+            : undefined,
+        appStoreConnect: values.ascApiKeyId &&
+            values.ascIssuerId &&
+            values.ascPrivateKey &&
+            values.ascBundleIdentifier
+            ? {
+                apiKeyId: values.ascApiKeyId,
+                issuerId: values.ascIssuerId,
+                privateKey: values.ascPrivateKey,
+                bundleIdentifier: values.ascBundleIdentifier,
+                ascAppId: values.ascAppId || undefined,
+                transporterPath: values.ascTransporterPath || undefined,
+            }
+            : undefined,
+    };
+}
+async function readKeychain(root, global) {
+    try {
+        const value = await runSecurity([
+            "find-generic-password",
+            "-a",
+            keychainAccount(root, global),
+            "-s",
+            keychainService,
+            "-w",
+        ]);
+        const stored = JSON.parse(value);
+        assert(stored.version === 1 && stored.platform === "macos-keychain", "CLI_CREDENTIALS_INVALID", "Unsupported LynxShip Keychain record");
+        return credentialsFromValues(stored.values);
+    }
+    catch {
+        return undefined;
+    }
+}
+async function saveKeychain(root, credentials, global) {
+    const record = {
+        version: 1,
+        platform: "macos-keychain",
+        values: credentialValues(credentials),
+    };
+    await runSecurity([
+        "add-generic-password",
+        "-U",
+        "-a",
+        keychainAccount(root, global),
+        "-s",
+        keychainService,
+        "-w",
+        JSON.stringify(record),
+    ]);
+    await unlink(credentialFile(root, global)).catch(() => undefined);
+}
+function mergeCredentials(global, project) {
+    return {
+        r2: project.r2 ?? global.r2,
+        android: project.android ?? global.android,
+        googlePlay: project.googlePlay ?? global.googlePlay,
+        appStoreConnect: project.appStoreConnect ?? global.appStoreConnect,
+    };
+}
+async function readCredentialFile(file) {
+    try {
+        const encrypted = JSON.parse(await readFile(file, "utf8"));
+        assert(encrypted.version === 1 &&
+            (encrypted.platform === "windows-dpapi" ||
+                encrypted.platform === "macos-keychain" ||
+                encrypted.platform === "file-mode-600"), "CLI_CREDENTIALS_INVALID", "Unsupported LynxShip credential store");
+        const values = Object.fromEntries(await Promise.all(Object.entries(encrypted.values).map(async ([key, value]) => [
+            key,
+            encrypted.platform === "windows-dpapi"
+                ? await unprotect(value)
+                : value,
+        ])));
+        return credentialsFromValues(values);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return {};
+        throw error;
+    }
+}
+async function readCredentialStore(root, global) {
+    if (process.platform === "darwin") {
+        const keychain = await readKeychain(root, global);
+        if (keychain)
+            return keychain;
+    }
+    const legacy = await readCredentialFile(credentialFile(root, global));
+    if (process.platform === "darwin" &&
+        (legacy.r2 !== undefined || legacy.android !== undefined)) {
+        await saveKeychain(root, legacy, global).catch(() => undefined);
+    }
+    return legacy;
+}
+export async function loadCredentials(root) {
+    const [global, project] = await Promise.all([
+        readCredentialStore(root, true),
+        readCredentialStore(root, false),
+    ]);
+    return mergeCredentials(global, project);
+}
+export async function saveCredentials(root, credentials, options = {}) {
+    const global = options.global ?? false;
+    if (process.platform === "darwin") {
+        await saveKeychain(root, credentials, global);
+        return;
+    }
+    const values = credentialValues(credentials);
+    const encrypted = {
+        version: 1,
+        platform: process.platform === "win32" ? "windows-dpapi" : "file-mode-600",
+        values: Object.fromEntries(await Promise.all(Object.entries(values).map(async ([key, value]) => [
+            key,
+            await protect(value),
+        ]))),
+    };
+    const directory = global
+        ? globalLynxShipDirectory()
+        : join(root, ".lynxship");
+    await mkdir(directory, { recursive: true });
+    const file = credentialFile(root, global);
+    await writeFile(file, `${JSON.stringify(encrypted, null, 2)}\n`, {
+        encoding: "utf8",
+        mode: 0o600,
+    });
+    if (process.platform !== "win32")
+        await chmod(file, 0o600);
+}

package/dist/ui/colors.d.ts

@@ -0,0 +1,24 @@
+import { type ChalkInstance } from "chalk";
+export declare const LYNX_BRAND: {
+    readonly pink: "#ff6b9d";
+    readonly cyan: "#45b7d1";
+};
+export type ColorName = "teal" | "tealDim" | "blue" | "orange" | "yellow" | "red" | "purple" | "green" | "text" | "muted" | "dim";
+export interface CliColors {
+    brand: (value: string) => string;
+    brandBold: (value: string) => string;
+    teal: ChalkInstance;
+    tealDim: ChalkInstance;
+    blue: ChalkInstance;
+    orange: ChalkInstance;
+    yellow: ChalkInstance;
+    red: ChalkInstance;
+    purple: ChalkInstance;
+    green: ChalkInstance;
+    text: ChalkInstance;
+    muted: ChalkInstance;
+    dim: ChalkInstance;
+    bold: (value: string) => string;
+}
+export declare function createColors(enabled: boolean): CliColors;
+//# sourceMappingURL=colors.d.ts.map

package/dist/ui/colors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"colors.d.ts","sourceRoot":"","sources":["../../src/ui/colors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,KAAK,aAAa,EAAE,MAAM,OAAO,CAAC;AAElD,eAAO,MAAM,UAAU;;;CAGb,CAAC;AAEX,MAAM,MAAM,SAAS,GACjB,MAAM,GACN,SAAS,GACT,MAAM,GACN,QAAQ,GACR,QAAQ,GACR,KAAK,GACL,QAAQ,GACR,OAAO,GACP,MAAM,GACN,OAAO,GACP,KAAK,CAAC;AAEV,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;IACjC,SAAS,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;IACrC,IAAI,EAAE,aAAa,CAAC;IACpB,OAAO,EAAE,aAAa,CAAC;IACvB,IAAI,EAAE,aAAa,CAAC;IACpB,MAAM,EAAE,aAAa,CAAC;IACtB,MAAM,EAAE,aAAa,CAAC;IACtB,GAAG,EAAE,aAAa,CAAC;IACnB,MAAM,EAAE,aAAa,CAAC;IACtB,KAAK,EAAE,aAAa,CAAC;IACrB,IAAI,EAAE,aAAa,CAAC;IACpB,KAAK,EAAE,aAAa,CAAC;IACrB,GAAG,EAAE,aAAa,CAAC;IACnB,IAAI,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;CACjC;AAiDD,wBAAgB,YAAY,CAAC,OAAO,EAAE,OAAO,GAAG,SAAS,CAmBxD"}

package/dist/ui/colors.js

@@ -0,0 +1,64 @@
+import { Chalk } from "chalk";
+export const LYNX_BRAND = {
+    pink: "#ff6b9d",
+    cyan: "#45b7d1",
+};
+function createColor(hex, enabled) {
+    return new Chalk({ level: enabled ? 3 : 0 }).hex(hex);
+}
+function hexToRgb(hex) {
+    const value = hex.replace("#", "");
+    return [
+        Number.parseInt(value.slice(0, 2), 16),
+        Number.parseInt(value.slice(2, 4), 16),
+        Number.parseInt(value.slice(4, 6), 16),
+    ];
+}
+function rgbToHex(red, green, blue) {
+    return `#${[red, green, blue]
+        .map((channel) => channel.toString(16).padStart(2, "0"))
+        .join("")}`;
+}
+function createBrand(enabled) {
+    const brandChalk = new Chalk({ level: enabled ? 3 : 0 });
+    const [startRed, startGreen, startBlue] = hexToRgb(LYNX_BRAND.pink);
+    const [endRed, endGreen, endBlue] = hexToRgb(LYNX_BRAND.cyan);
+    return (value) => {
+        if (!enabled || value.length === 0)
+            return value;
+        const characters = [...value];
+        const visibleCount = characters.filter((character) => !/\s/u.test(character)).length;
+        let visibleIndex = 0;
+        return characters
+            .map((character) => {
+            if (/\s/u.test(character))
+                return character;
+            const ratio = visibleCount <= 1 ? 0 : visibleIndex / (visibleCount - 1);
+            visibleIndex += 1;
+            const red = Math.round(startRed + (endRed - startRed) * ratio);
+            const green = Math.round(startGreen + (endGreen - startGreen) * ratio);
+            const blue = Math.round(startBlue + (endBlue - startBlue) * ratio);
+            return brandChalk.hex(rgbToHex(red, green, blue))(character);
+        })
+            .join("");
+    };
+}
+export function createColors(enabled) {
+    const brand = createBrand(enabled);
+    return {
+        brand,
+        brandBold: (value) => new Chalk({ level: enabled ? 3 : 0 }).bold(brand(value)),
+        teal: createColor(LYNX_BRAND.cyan, enabled),
+        tealDim: createColor("#2f91ab", enabled),
+        blue: createColor("#72c7df", enabled),
+        orange: createColor("#ff9a8b", enabled),
+        yellow: createColor("#f6c15d", enabled),
+        red: createColor("#ff6b7a", enabled),
+        purple: createColor("#c5a0ff", enabled),
+        green: createColor("#58d6b4", enabled),
+        text: createColor("#f4f8fb", enabled),
+        muted: createColor("#91a8b8", enabled),
+        dim: createColor("#526b7c", enabled),
+        bold: new Chalk({ level: enabled ? 3 : 0 }).bold,
+    };
+}

package/dist/ui/components.d.ts

@@ -0,0 +1,36 @@
+import type { ColorName } from "./colors.js";
+export interface BoxRow {
+    label: string;
+    value: string;
+    valueColor?: ColorName;
+}
+export declare function sectionHeader(title: string): void;
+export declare const log: {
+    success(message: string): void;
+    warn(message: string): void;
+    error(message: string): void;
+    info(message: string): void;
+    debug(message: string): void;
+};
+export declare function summaryBox(title: string, rows: BoxRow[]): void;
+export interface ProgressHandle {
+    event(message: string): void;
+    update(value?: number, label?: string): void;
+    stop(): void;
+}
+export declare function createProgress(label: string, enabled: boolean): ProgressHandle;
+export interface SpinnerHandle {
+    succeed(message: string): void;
+    fail(message: string): void;
+    stop(): void;
+}
+export declare function spin(text: string, enabled: boolean): SpinnerHandle;
+export declare const pill: {
+    success: (text: string) => string;
+    warn: (text: string) => string;
+    info: (text: string) => string;
+    error: (text: string) => string;
+};
+export declare function finalLine(message: string, success?: boolean): void;
+export declare function downloadArtifact(url: string, expiresAt?: string, enabled?: boolean): void;
+//# sourceMappingURL=components.d.ts.map

package/dist/ui/components.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"components.d.ts","sourceRoot":"","sources":["../../src/ui/components.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAI7C,MAAM,WAAW,MAAM;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,SAAS,CAAC;CACxB;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAEjD;AAED,eAAO,MAAM,GAAG;qBACG,MAAM,GAAG,IAAI;kBAGhB,MAAM,GAAG,IAAI;mBAGZ,MAAM,GAAG,IAAI;kBAGd,MAAM,GAAG,IAAI;mBAGZ,MAAM,GAAG,IAAI;CAG7B,CAAC;AAgBF,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI,CA6C9D;AAED,MAAM,WAAW,cAAc;IAC7B,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,MAAM,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7C,IAAI,IAAI,IAAI,CAAC;CACd;AA2FD,wBAAgB,cAAc,CAC5B,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,OAAO,GACf,cAAc,CA8DhB;AAED,MAAM,WAAW,aAAa;IAC5B,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,IAAI,IAAI,IAAI,CAAC;CACd;AAED,wBAAgB,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,aAAa,CA2BlE;AAYD,eAAO,MAAM,IAAI;oBACC,MAAM;iBACT,MAAM;iBACN,MAAM;kBACL,MAAM;CACrB,CAAC;AAEF,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,UAAO,GAAG,IAAI,CAE/D;AAED,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,MAAM,EACX,SAAS,CAAC,EAAE,MAAM,EAClB,OAAO,UAAO,GACb,IAAI,CAQN"}

package/dist/ui/components.js

@@ -0,0 +1,268 @@
+import boxen from "boxen";
+import { Chalk } from "chalk";
+import cliProgress from "cli-progress";
+import ora from "ora";
+import qrcode from "qrcode-terminal";
+import { c, colorsEnabled } from "./state.js";
+import { supportsUnicode, terminalWidth } from "./terminal.js";
+export function sectionHeader(title) {
+    console.log(`\n${c.brandBold(`◆ LynxShip — ${title}`)}`);
+}
+export const log = {
+    success(message) {
+        console.log(`  ${c.teal("[OK]  ")} ${c.text(message)}`);
+    },
+    warn(message) {
+        console.log(`  ${c.yellow("[WARN]")} ${c.yellow(message)}`);
+    },
+    error(message) {
+        console.error(`  ${c.red("[ERROR]")} ${c.red(message)}`);
+    },
+    info(message) {
+        console.log(`  ${c.muted(message)}`);
+    },
+    debug(message) {
+        console.log(`  ${c.dim(`debug: ${message}`)}`);
+    },
+};
+const valueColors = {
+    teal: (value) => c.teal(value),
+    tealDim: (value) => c.tealDim(value),
+    blue: (value) => c.blue(value),
+    orange: (value) => c.orange(value),
+    yellow: (value) => c.yellow(value),
+    red: (value) => c.red(value),
+    purple: (value) => c.purple(value),
+    green: (value) => c.green(value),
+    text: (value) => c.text(value),
+    muted: (value) => c.muted(value),
+    dim: (value) => c.dim(value),
+};
+export function summaryBox(title, rows) {
+    const width = terminalWidth();
+    const labelWidth = Math.min(16, Math.max(...rows.map((row) => row.label.length), 0));
+    const plain = rows
+        .map((row) => `${row.label.padEnd(labelWidth)}  ${row.value}`)
+        .join("\n");
+    if (width < 58) {
+        console.log(`\n${plain}`);
+        return;
+    }
+    const content = rows
+        .map((row) => {
+        const label = c.muted(row.label.padEnd(labelWidth));
+        const value = row.valueColor
+            ? valueColors[row.valueColor](row.value)
+            : c.text(row.value);
+        return `${label}  ${value}`;
+    })
+        .join("\n");
+    // Measure the plain title first. Coloring the title before boxen measures it
+    // would make ANSI escape sequences affect the visible width of the border.
+    const rendered = boxen(content, {
+        width: Math.min(120, Math.max(56, width - 2)),
+        padding: { top: 0, bottom: 0, left: 1, right: 1 },
+        borderStyle: "round",
+        borderColor: "#29495b",
+        title,
+        titleAlignment: "left",
+    });
+    const firstLineEnd = rendered.indexOf("\n");
+    const firstLine = firstLineEnd === -1 ? rendered : rendered.slice(0, firstLineEnd);
+    const titleStart = firstLine.indexOf(title);
+    const coloredTitle = titleStart === -1
+        ? firstLine
+        : `${firstLine.slice(0, titleStart)}${c.brand(title)}${firstLine.slice(titleStart + title.length)}`;
+    const coloredBox = firstLineEnd === -1
+        ? coloredTitle
+        : `${coloredTitle}${rendered.slice(firstLineEnd)}`;
+    console.log(`\n${coloredBox}`);
+}
+function eventTone(message) {
+    const normalized = message.trim().toLowerCase();
+    if (normalized.startsWith("$ "))
+        return "command";
+    if (normalized.includes("error") ||
+        normalized.includes("failed") ||
+        normalized.includes("exception"))
+        return "error";
+    if (normalized.includes("warning") ||
+        normalized.includes("no-source") ||
+        normalized.includes("deprecated"))
+        return "warning";
+    if (normalized.includes("successful") ||
+        normalized.includes("ready") ||
+        normalized.startsWith("artifact ready") ||
+        normalized.startsWith("done"))
+        return "success";
+    if (normalized.startsWith("building ") ||
+        normalized.startsWith("checking ") ||
+        normalized.startsWith("syncing ") ||
+        normalized.startsWith("running ") ||
+        normalized.startsWith("uploading ") ||
+        normalized.startsWith("verifying ") ||
+        normalized.startsWith("build queued"))
+        return "step";
+    return "output";
+}
+function formatEvent(message) {
+    const colors = {
+        command: c.blue,
+        step: c.teal,
+        success: c.green,
+        warning: c.yellow,
+        error: c.red,
+        output: c.text,
+    };
+    const tone = eventTone(message);
+    const tag = {
+        command: "[CMD]",
+        step: "[STEP]",
+        success: "[OK]",
+        warning: "[WARN]",
+        error: "[ERROR]",
+        output: "[LOG]",
+    }[tone];
+    const normalized = message.trim().replace(/^\$\s*/, "");
+    const rail = supportsUnicode() ? "│" : "|";
+    return `  ${colors[tone](rail)} ${colors[tone](tag.padEnd(7))} ${colors[tone](normalized)}`;
+}
+const activeAnimations = new Set();
+let cleanupHooksInstalled = false;
+function installCleanupHooks() {
+    if (cleanupHooksInstalled)
+        return;
+    cleanupHooksInstalled = true;
+    const cleanup = () => {
+        for (const stop of activeAnimations)
+            stop();
+        activeAnimations.clear();
+    };
+    process.once("exit", cleanup);
+    process.once("SIGINT", () => {
+        cleanup();
+        process.exitCode = 130;
+    });
+}
+function trackAnimation(stop) {
+    installCleanupHooks();
+    activeAnimations.add(stop);
+    return () => activeAnimations.delete(stop);
+}
+export function createProgress(label, enabled) {
+    if (!enabled)
+        return {
+            event: () => undefined,
+            update: () => undefined,
+            stop: () => undefined,
+        };
+    const spinnerFrames = supportsUnicode()
+        ? ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+        : ["|", "/", "-", "\\"];
+    let spinnerIndex = 0;
+    let currentValue = 0;
+    let hasMeasuredValue = false;
+    const formatPercent = (value) => `${value.toFixed(2).replace(/\.?0+$/, "")}%`;
+    const bar = new cliProgress.SingleBar({
+        format: `  {spinner} {stage} ${c.teal("{bar}")} ${c.muted("{percent}")}`,
+        barCompleteChar: "█",
+        barIncompleteChar: "░",
+        barsize: 20,
+        hideCursor: true,
+        clearOnComplete: true,
+    });
+    const stage = (value) => c.muted(value.padEnd(38));
+    const payload = (value) => ({
+        stage: stage(value),
+        spinner: c.brand(spinnerFrames[spinnerIndex] ?? ""),
+        percent: hasMeasuredValue ? formatPercent(currentValue) : "",
+    });
+    let currentLabel = label;
+    bar.start(100, currentValue, payload(currentLabel));
+    const timer = setInterval(() => {
+        spinnerIndex = (spinnerIndex + 1) % spinnerFrames.length;
+        bar.update(currentValue, payload(currentLabel));
+    }, 120);
+    timer.unref?.();
+    const untrack = trackAnimation(() => {
+        clearInterval(timer);
+        bar.stop();
+    });
+    const logEvent = (message) => {
+        if (!bar.isActive)
+            return;
+        bar.stop();
+        console.log(formatEvent(message));
+        bar.start(100, currentValue, payload(currentLabel));
+    };
+    return {
+        event: logEvent,
+        update: (value, nextLabel) => {
+            if (value !== undefined) {
+                currentValue = Math.min(100, Math.max(0, value));
+                hasMeasuredValue = true;
+            }
+            if (nextLabel)
+                currentLabel = nextLabel;
+            bar.update(currentValue, payload(currentLabel));
+        },
+        stop: () => {
+            clearInterval(timer);
+            bar.stop();
+            untrack();
+        },
+    };
+}
+export function spin(text, enabled) {
+    if (!enabled)
+        return {
+            succeed: () => undefined,
+            fail: () => undefined,
+            stop: () => undefined,
+        };
+    const spinner = ora({
+        text: c.brand(text),
+        spinner: "dots",
+        color: "cyan",
+    }).start();
+    const untrack = trackAnimation(() => spinner.stop());
+    return {
+        succeed: (message) => {
+            spinner.succeed(`${c.teal("[OK]")} ${c.text(message)}`);
+            untrack();
+        },
+        fail: (message) => {
+            spinner.fail(`${c.red("[ERROR]")} ${c.red(message)}`);
+            untrack();
+        },
+        stop: () => {
+            spinner.stop();
+            untrack();
+        },
+    };
+}
+function pillStyle(background, foreground, text) {
+    return new Chalk({ level: colorsEnabled ? 3 : 0 })
+        .bgHex(background)
+        .hex(foreground)(` ${text} `);
+}
+export const pill = {
+    success: (text) => pillStyle("#0d2e22", "#10B981", text),
+    warn: (text) => pillStyle("#2e2208", "#FFD166", text),
+    info: (text) => pillStyle("#0a1f30", "#4F9EFF", text),
+    error: (text) => pillStyle("#2e0d10", "#FF4757", text),
+};
+export function finalLine(message, success = true) {
+    console.log(`\n${success ? c.brand("◆") : c.red("◆")} ${c.text(message)}`);
+}
+export function downloadArtifact(url, expiresAt, enabled = true) {
+    if (!enabled)
+        return;
+    console.log(`\n${c.brandBold("Download artifact")}`);
+    // qrcode-terminal's small mode is the safest compact terminal renderer.
+    // A shorter QR requires a shorter download URL, not fewer QR modules.
+    qrcode.generate(url, { small: true }, (code) => console.log(code));
+    console.log(`  ${c.teal("URL")}  ${url}`);
+    if (expiresAt)
+        console.log(`  ${c.muted(`Link expires at ${expiresAt}`)}`);
+}

package/dist/ui/index.d.ts

@@ -0,0 +1,24 @@
+import { type BoxRow, type ProgressHandle, type SpinnerHandle } from "./components.js";
+import { terminalOptions, type TerminalOptions } from "./terminal.js";
+export declare class CliUi {
+    readonly options: TerminalOptions;
+    readonly interactive: boolean;
+    constructor(args: string[]);
+    banner(): void;
+    header(title: string): void;
+    success(message: string): void;
+    warn(message: string): void;
+    info(message: string): void;
+    debug(message: string): void;
+    error(message: string): void;
+    summary(title: string, rows: BoxRow[]): void;
+    configurationStatus(rows: BoxRow[]): void;
+    progress(label: string): ProgressHandle;
+    spinner(text: string): SpinnerHandle;
+    done(message: string, success?: boolean): void;
+    downloadArtifact(url: string, expiresAt?: string): void;
+}
+export declare function createCliUi(args: string[]): CliUi;
+export { terminalOptions };
+export type { BoxRow, TerminalOptions };
+//# sourceMappingURL=index.d.ts.map