@lynxship/cli 0.1.0

package/dist/ios-build.d.ts

@@ -0,0 +1,13 @@
+import { type BuildJob } from "@lynxship/contracts";
+import type { BuildProfile } from "./config.js";
+interface IosBuildOptions {
+    root: string;
+    profile: BuildProfile;
+    quiet?: boolean;
+    onEvent?: (message: string) => void;
+    onProgress?: (value?: number, label?: string) => void;
+}
+export declare function hasIosHost(root: string, profile?: BuildProfile): boolean;
+export declare function runRealIosBuild(job: BuildJob, options: IosBuildOptions): Promise<BuildJob>;
+export {};
+//# sourceMappingURL=ios-build.d.ts.map

package/dist/ios-build.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ios-build.d.ts","sourceRoot":"","sources":["../src/ios-build.ts"],"names":[],"mappings":"AAGA,OAAO,EAAkB,KAAK,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAEpE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAShD,UAAU,eAAe;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,YAAY,CAAC;IACtB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACpC,UAAU,CAAC,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;CACvD;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY,GAAG,OAAO,CAcxE;AA0BD,wBAAsB,eAAe,CACnC,GAAG,EAAE,QAAQ,EACb,OAAO,EAAE,eAAe,GACvB,OAAO,CAAC,QAAQ,CAAC,CAsLnB"}

package/dist/ios-build.js

@@ -0,0 +1,174 @@
+import { copyFile, mkdir, readdir, readFile } from "node:fs/promises";
+import { existsSync, readdirSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { assert, sha256 } from "@lynxship/contracts";
+import { transitionBuild } from "@lynxship/build-orchestrator";
+import { loadR2, uploadR2Artifact } from "./r2.js";
+import { nativeArtifactName } from "./artifact-name.js";
+import { commandExists, packageManagerScriptCommand, runProcess, } from "./process-runner.js";
+export function hasIosHost(root, profile) {
+    if (process.platform !== "darwin")
+        return false;
+    const configured = profile?.ios?.workspace ?? profile?.ios?.project;
+    if (configured && existsSync(resolve(root, configured)))
+        return true;
+    return ["ios", "macos"].some((directory) => {
+        try {
+            return readdirSync(join(root, directory)).some((name) => name.endsWith(".xcworkspace") || name.endsWith(".xcodeproj"));
+        }
+        catch {
+            return false;
+        }
+    });
+}
+function findProject(root, profile) {
+    const configured = profile.ios?.workspace ?? profile.ios?.project;
+    if (configured)
+        return resolve(root, configured);
+    for (const directory of ["ios", "macos"]) {
+        try {
+            const candidate = readdirSync(join(root, directory)).find((name) => name.endsWith(".xcworkspace") || name.endsWith(".xcodeproj"));
+            if (candidate)
+                return join(root, directory, candidate);
+        }
+        catch {
+            // The platform host is optional until an iOS/macOS build is requested.
+        }
+    }
+    throw new Error("No Xcode workspace or project found under ios/ or macos/");
+}
+async function findIpa(directory) {
+    const files = await readdir(directory, { withFileTypes: true });
+    const ipa = files.find((file) => file.isFile() && file.name.endsWith(".ipa"));
+    if (!ipa)
+        throw new Error(`xcodebuild exported no IPA in ${directory}`);
+    return join(directory, ipa.name);
+}
+export async function runRealIosBuild(job, options) {
+    assert(process.platform === "darwin", "IOS_MACOS_REQUIRED", "iOS builds require macOS with Xcode");
+    assert(commandExists("xcodebuild"), "IOS_XCODE_REQUIRED", "xcodebuild was not found. Install Xcode and select its command-line tools.");
+    assert(commandExists("xcrun"), "IOS_XCRUN_REQUIRED", "xcrun was not found. Install Xcode command-line tools.");
+    const project = findProject(options.root, options.profile);
+    assert(existsSync(project), "IOS_PROJECT_REQUIRED", `Configured Xcode project was not found: ${project}`);
+    const ios = options.profile.ios ?? {};
+    const scheme = ios.scheme;
+    assert(scheme, "IOS_SCHEME_REQUIRED", "Configure build.<profile>.ios.scheme in lynxship.json");
+    const exportOptions = ios.exportOptionsPlist;
+    assert(exportOptions, "IOS_EXPORT_OPTIONS_REQUIRED", "Configure build.<profile>.ios.exportOptionsPlist for a signed IPA export");
+    const exportOptionsPath = resolve(options.root, exportOptions);
+    assert(existsSync(exportOptionsPath), "IOS_EXPORT_OPTIONS_REQUIRED", `Export options file was not found: ${exportOptionsPath}`);
+    const projectFlag = project.endsWith(".xcworkspace")
+        ? "-workspace"
+        : "-project";
+    const configuration = ios.configuration ?? "Release";
+    const archiveDirectory = join(options.root, ".lynxship", "ios", job.id);
+    const archivePath = join(archiveDirectory, `${job.id}.xcarchive`);
+    const exportPath = join(archiveDirectory, "export");
+    const step = (message, progress) => {
+        options.onEvent?.(message);
+        options.onProgress?.(progress, message);
+    };
+    try {
+        await loadR2(options.root);
+        await mkdir(archiveDirectory, { recursive: true });
+        transitionBuild(job, "uploading_source", "iOS source prepared");
+        step("Building Lynx bundle with Rspeedy…", 5);
+        const packageManager = packageManagerScriptCommand(options.root, "build");
+        await runProcess(packageManager.command, packageManager.args, {
+            cwd: options.root,
+            quiet: options.quiet,
+            onOutput: options.onEvent,
+        });
+        if (ios.bundleScript) {
+            step("Syncing bundle into the iOS host…", 8);
+            await runProcess(process.execPath, [resolve(options.root, ios.bundleScript)], {
+                cwd: options.root,
+                quiet: options.quiet,
+                onOutput: options.onEvent,
+            });
+        }
+        step("Preparing Xcode archive…", 10);
+        await runProcess("xcodebuild", [
+            projectFlag,
+            project,
+            "-scheme",
+            scheme,
+            "-configuration",
+            configuration,
+            "-sdk",
+            "iphoneos",
+            "-archivePath",
+            archivePath,
+            "archive",
+        ], { cwd: options.root, quiet: options.quiet, onOutput: options.onEvent });
+        transitionBuild(job, "queued", "iOS build queued locally");
+        transitionBuild(job, "provisioning", "Xcode signing configuration selected");
+        step("Exporting signed IPA…", 55);
+        await runProcess("xcodebuild", [
+            "-exportArchive",
+            "-archivePath",
+            archivePath,
+            "-exportOptionsPlist",
+            exportOptionsPath,
+            "-exportPath",
+            exportPath,
+        ], { cwd: options.root, quiet: options.quiet, onOutput: options.onEvent });
+        transitionBuild(job, "installing_dependencies", "iOS archive exported");
+        transitionBuild(job, "building", "IPA package created");
+        const exportedIpa = await findIpa(exportPath);
+        transitionBuild(job, "signing", "Xcode signed the IPA");
+        step("Verifying IPA signature…", 75);
+        await verifyIpa(options.root, exportedIpa, archiveDirectory);
+        transitionBuild(job, "uploading_artifacts", "iOS artifact collected");
+        const artifactName = nativeArtifactName("ipa");
+        const artifactPath = join(options.root, ".lynxship", "artifacts", artifactName);
+        await mkdir(join(options.root, ".lynxship", "artifacts"), {
+            recursive: true,
+        });
+        await copyFile(exportedIpa, artifactPath);
+        const content = await readFile(artifactPath);
+        const hash = sha256(content);
+        const uploaded = await uploadR2Artifact(options.root, job.projectId, job.id, artifactPath, "application/octet-stream", undefined, {
+            onProgress: (uploadedBytes, totalBytes) => {
+                const transfer = totalBytes === 0 ? 1 : uploadedBytes / totalBytes;
+                options.onProgress?.(80 + transfer * 19, `Uploading signed artifact to Cloudflare R2… ${Math.round(transfer * 10000) / 100}%`);
+            },
+        });
+        assert(uploaded.hash === hash, "BUILD_ARTIFACT_HASH", "R2 artifact hash mismatch");
+        job.attempts += 1;
+        job.artifact = {
+            name: artifactName,
+            hash,
+            path: artifactPath,
+            key: uploaded.key,
+            size: uploaded.size,
+            contentType: uploaded.contentType,
+            url: uploaded.url,
+            expiresAt: uploaded.expiresAt,
+        };
+        step(`Artifact ready: ${artifactName}`, 100);
+        return transitionBuild(job, "success", "real iOS artifact created");
+    }
+    catch (error) {
+        if (!["success", "failed", "canceled", "timed_out"].includes(job.state))
+            transitionBuild(job, "failed", error instanceof Error ? error.message : "iOS build failed");
+        job.logs.push({
+            level: "error",
+            message: error instanceof Error ? error.message : "iOS build failed",
+            at: new Date().toISOString(),
+        });
+        throw error;
+    }
+}
+async function verifyIpa(root, ipa, directory) {
+    const extracted = join(directory, "verified-payload");
+    await mkdir(extracted, { recursive: true });
+    await runProcess("unzip", ["-q", ipa, "-d", extracted], {
+        cwd: root,
+        quiet: true,
+    });
+    const payload = join(extracted, "Payload");
+    const app = (await readdir(payload, { withFileTypes: true })).find((file) => file.isDirectory() && file.name.endsWith(".app"));
+    assert(app, "IOS_SIGNATURE_INVALID", "The exported IPA does not contain an app bundle");
+    await runProcess("codesign", ["--verify", "--deep", "--strict", join(payload, app.name)], { cwd: root, quiet: true });
+}

package/dist/ota-assets.d.ts

@@ -0,0 +1,3 @@
+export declare function otaAssetPaths(root: string, explicit: string | null): Promise<string[]>;
+export declare function otaAssetName(root: string, file: string): string;
+//# sourceMappingURL=ota-assets.d.ts.map

package/dist/ota-assets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ota-assets.d.ts","sourceRoot":"","sources":["../src/ota-assets.ts"],"names":[],"mappings":"AA8BA,wBAAsB,aAAa,CACjC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,GAAG,IAAI,GACtB,OAAO,CAAC,MAAM,EAAE,CAAC,CAYnB;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAM/D"}

package/dist/ota-assets.js

@@ -0,0 +1,48 @@
+import { readdir } from "node:fs/promises";
+import { basename, extname, join, relative, resolve, sep } from "node:path";
+function normalized(value) {
+    return value.split(sep).join("/");
+}
+async function discover(directory, result) {
+    let entries;
+    try {
+        entries = await readdir(directory, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        if ([".rsbuild", ".rspeedy", "node_modules"].includes(entry.name))
+            continue;
+        const file = join(directory, entry.name);
+        if (entry.isDirectory()) {
+            await discover(file, result);
+            continue;
+        }
+        if (entry.isFile() &&
+            [".bundle"].includes(extname(entry.name)) &&
+            entry.name.includes("lynx"))
+            result.push(file);
+    }
+}
+export async function otaAssetPaths(root, explicit) {
+    if (explicit)
+        return explicit
+            .split(",")
+            .map((value) => value.trim())
+            .filter(Boolean)
+            .map((value) => resolve(root, value));
+    const dist = join(root, "dist");
+    const discovered = [];
+    await discover(dist, discovered);
+    if (discovered.length > 0)
+        return discovered.sort();
+    return [join(dist, "main.lynx.bundle")];
+}
+export function otaAssetName(root, file) {
+    const dist = resolve(root, "dist");
+    const relativePath = relative(dist, resolve(file));
+    if (!relativePath || relativePath.startsWith(`..${sep}`))
+        return basename(file);
+    return normalized(relativePath);
+}

package/dist/ota-doctor.d.ts

@@ -0,0 +1,10 @@
+import { type Platform } from "@lynxship/contracts";
+export interface OtaHostStatus {
+    platform: Platform;
+    detected: boolean;
+    files: string[];
+    missing: string[];
+}
+export declare function inspectOtaHost(root: string, platform: Platform): Promise<OtaHostStatus>;
+export declare function requireOtaHost(root: string, platform: Platform): Promise<OtaHostStatus>;
+//# sourceMappingURL=ota-doctor.d.ts.map

package/dist/ota-doctor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ota-doctor.d.ts","sourceRoot":"","sources":["../src/ota-doctor.ts"],"names":[],"mappings":"AAEA,OAAO,EAAU,KAAK,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAE5D,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,QAAQ,CAAC;IACnB,QAAQ,EAAE,OAAO,CAAC;IAClB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAmCD,wBAAsB,cAAc,CAClC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,QAAQ,GACjB,OAAO,CAAC,aAAa,CAAC,CAkBxB;AAED,wBAAsB,cAAc,CAClC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,QAAQ,GACjB,OAAO,CAAC,aAAa,CAAC,CASxB"}

package/dist/ota-doctor.js

@@ -0,0 +1,53 @@
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { assert } from "@lynxship/contracts";
+const sourceExtensions = new Set([".java", ".kt", ".swift", ".m", ".mm"]);
+async function sourceFiles(root, platform) {
+    const files = [];
+    const directory = join(root, platform);
+    async function visit(current) {
+        let entries;
+        try {
+            entries = await readdir(current, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (["build", "Pods", "DerivedData", ".gradle"].includes(entry.name))
+                continue;
+            const file = join(current, entry.name);
+            if (entry.isDirectory()) {
+                await visit(file);
+                continue;
+            }
+            const extension = entry.name.slice(entry.name.lastIndexOf("."));
+            if (entry.isFile() && sourceExtensions.has(extension))
+                files.push(file);
+        }
+    }
+    await visit(directory);
+    return files;
+}
+export async function inspectOtaHost(root, platform) {
+    const files = await sourceFiles(root, platform);
+    const contents = await Promise.all(files.map(async (file) => readFile(file, "utf8").catch(() => "")));
+    const text = contents.join("\n");
+    const required = [
+        "LynxShipOtaClient",
+        "beginLaunch",
+        "markLaunchSuccess",
+        "openActiveAsset",
+    ];
+    return {
+        platform,
+        detected: files.length > 0,
+        files,
+        missing: required.filter((value) => !text.includes(value)),
+    };
+}
+export async function requireOtaHost(root, platform) {
+    const status = await inspectOtaHost(root, platform);
+    assert(status.detected && status.missing.length === 0, "OTA_HOST_INTEGRATION_REQUIRED", `The ${platform} native host is not integrated with the LynxShip OTA client. Missing: ${status.missing.join(", ") || "native host source"}`, status);
+    return status;
+}

package/dist/paths.d.ts

@@ -0,0 +1,2 @@
+export declare function globalLynxShipDirectory(): string;
+//# sourceMappingURL=paths.d.ts.map

package/dist/paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../src/paths.ts"],"names":[],"mappings":"AAGA,wBAAgB,uBAAuB,IAAI,MAAM,CAYhD"}

package/dist/paths.js

@@ -0,0 +1,12 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+export function globalLynxShipDirectory() {
+    if (process.env.LYNXSHIP_CONFIG_DIR)
+        return process.env.LYNXSHIP_CONFIG_DIR;
+    const home = homedir();
+    if (process.platform === "win32")
+        return join(process.env.APPDATA ?? join(home, "AppData", "Roaming"), "LynxShip");
+    if (process.platform === "darwin")
+        return join(home, "Library", "Application Support", "LynxShip");
+    return join(process.env.XDG_CONFIG_HOME ?? join(home, ".config"), "lynxship");
+}

package/dist/process-runner.d.ts

@@ -0,0 +1,18 @@
+export interface ProcessOptions {
+    cwd: string;
+    env?: NodeJS.ProcessEnv;
+    quiet?: boolean;
+    onOutput?: (line: string) => void;
+}
+export declare function packageManagerCommand(root: string): {
+    command: string;
+    prefix: string[];
+};
+export declare function packageManagerScriptCommand(root: string, script: string, args?: string[]): {
+    command: string;
+    args: string[];
+};
+export declare function runProcess(command: string, args: string[], options: ProcessOptions): Promise<void>;
+export declare function runRspeedy(root: string, subcommand: string, args: string[], options: Omit<ProcessOptions, "cwd">): Promise<void>;
+export declare function commandExists(command: string): boolean;
+//# sourceMappingURL=process-runner.d.ts.map

package/dist/process-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"process-runner.d.ts","sourceRoot":"","sources":["../src/process-runner.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,cAAc;IAC7B,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IACxB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CACnC;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG;IACnD,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAcA;AAED,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,IAAI,GAAE,MAAM,EAAO,GAClB;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,EAAE,CAAA;CAAE,CAGrC;AAsBD,wBAAgB,UAAU,CACxB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EAAE,EACd,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,IAAI,CAAC,CA8Cf;AAED,wBAAsB,UAAU,CAC9B,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,MAAM,EAAE,EACd,OAAO,EAAE,IAAI,CAAC,cAAc,EAAE,KAAK,CAAC,GACnC,OAAO,CAAC,IAAI,CAAC,CAOf;AAED,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAWtD"}

package/dist/process-runner.js

@@ -0,0 +1,97 @@
+import { execFileSync } from "node:child_process";
+import { spawn } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+export function packageManagerCommand(root) {
+    const configured = process.env.LYNXSHIP_PACKAGE_MANAGER ?? process.env.LYNXSHIP_PNPM_PATH;
+    const packageManager = configured ?? detectPackageManager(root);
+    const command = process.platform === "win32" && !/\.(?:cmd|bat|exe)$/i.test(packageManager)
+        ? `${packageManager}.cmd`
+        : packageManager;
+    const normalized = packageManager.split(/[\\/]/).at(-1)?.toLowerCase();
+    return normalized === "yarn" || normalized === "yarn.cmd"
+        ? { command, prefix: [] }
+        : normalized === "npm" || normalized === "npm.cmd"
+            ? { command, prefix: ["exec", "--"] }
+            : { command, prefix: ["exec"] };
+}
+export function packageManagerScriptCommand(root, script, args = []) {
+    const manager = packageManagerCommand(root);
+    return { command: manager.command, args: ["run", script, ...args] };
+}
+function detectPackageManager(root) {
+    try {
+        const packageJson = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
+        if (packageJson.packageManager?.startsWith("npm@"))
+            return "npm";
+        if (packageJson.packageManager?.startsWith("yarn@"))
+            return "yarn";
+        if (packageJson.packageManager?.startsWith("pnpm@"))
+            return "pnpm";
+    }
+    catch {
+        // Lockfiles below are the next reliable signal.
+    }
+    try {
+        if (existsSync(join(root, "package-lock.json")))
+            return "npm";
+        if (existsSync(join(root, "yarn.lock")))
+            return "yarn";
+    }
+    catch {
+        // Default to pnpm for this workspace.
+    }
+    return "pnpm";
+}
+export function runProcess(command, args, options) {
+    const windowsCommand = process.platform === "win32" && /\.(?:bat|cmd)$/i.test(command);
+    const commandLine = [command, ...args]
+        .map((value) => /[\s"]/.test(value) ? `"${value.replaceAll('"', '\\"')}"` : value)
+        .join(" ");
+    return new Promise((resolve, reject) => {
+        const child = spawn(windowsCommand ? "cmd.exe" : command, windowsCommand ? ["/d", "/s", "/c", commandLine] : args, {
+            cwd: options.cwd,
+            env: options.env ?? process.env,
+            shell: false,
+            stdio: ["ignore", "pipe", "pipe"],
+            windowsHide: true,
+        });
+        let pending = "";
+        let output = "";
+        const forward = (chunk) => {
+            output += chunk.toString();
+            pending += chunk.toString().replace(/\r(?!\n)/g, "\n");
+            const lines = pending.split(/\r?\n/);
+            pending = lines.pop() ?? "";
+            for (const line of lines) {
+                const clean = line.replace(/\u001b\[[0-?]*[ -/]*[@-~]/g, "").trim();
+                if (clean && !options.quiet)
+                    options.onOutput?.(clean);
+            }
+        };
+        child.stdout?.on("data", forward);
+        child.stderr?.on("data", forward);
+        child.once("error", reject);
+        child.once("exit", (code, signal) => {
+            if (pending.trim() && !options.quiet)
+                options.onOutput?.(pending.trim());
+            if (code === 0)
+                return resolve();
+            const lastLine = output.trim().split(/\r?\n/).at(-1) ?? "";
+            reject(new Error(`${command} ${args.join(" ")} failed (${signal ?? `exit ${code}`})${lastLine ? `: ${lastLine}` : ""}`));
+        });
+    });
+}
+export async function runRspeedy(root, subcommand, args, options) {
+    const manager = packageManagerCommand(root);
+    await runProcess(manager.command, [...manager.prefix, "rspeedy", subcommand, ...args], { ...options, cwd: root });
+}
+export function commandExists(command) {
+    try {
+        execFileSync(process.platform === "win32" ? "where.exe" : "which", [command], { stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/prompt.d.ts

@@ -0,0 +1,3 @@
+export declare function prompt(label: string, defaultValue?: string): Promise<string>;
+export declare function secret(label: string): Promise<string>;
+//# sourceMappingURL=prompt.d.ts.map

package/dist/prompt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt.d.ts","sourceRoot":"","sources":["../src/prompt.ts"],"names":[],"mappings":"AAGA,wBAAsB,MAAM,CAC1B,KAAK,EAAE,MAAM,EACb,YAAY,CAAC,EAAE,MAAM,GACpB,OAAO,CAAC,MAAM,CAAC,CAYjB;AAED,wBAAsB,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CA2C3D"}

package/dist/prompt.js

@@ -0,0 +1,58 @@
+import { createInterface } from "node:readline/promises";
+import { c } from "./ui/state.js";
+export async function prompt(label, defaultValue) {
+    const readline = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    try {
+        const suffix = defaultValue ? ` [${defaultValue}]` : "";
+        const value = await readline.question(`${c.brand(label)}${suffix}: `);
+        return value.trim() || defaultValue || "";
+    }
+    finally {
+        readline.close();
+    }
+}
+export async function secret(label) {
+    if (!process.stdin.isTTY || !process.stdin.setRawMode)
+        throw new Error("Secret input requires an interactive terminal; use environment variables in CI");
+    process.stdout.write(`${c.brand(label)}: `);
+    const input = process.stdin;
+    const previousEncoding = input.readableEncoding;
+    input.setRawMode(true);
+    input.setEncoding("utf8");
+    input.resume();
+    return new Promise((resolve, reject) => {
+        let value = "";
+        const cleanup = () => {
+            input.setRawMode?.(false);
+            input.pause();
+            input.removeListener("data", onData);
+            if (previousEncoding)
+                input.setEncoding(previousEncoding);
+            process.stdout.write("\n");
+        };
+        const onData = (chunk) => {
+            for (const character of chunk) {
+                if (character === "\u0003") {
+                    cleanup();
+                    reject(new Error("Input cancelled"));
+                    return;
+                }
+                if (character === "\r" || character === "\n") {
+                    cleanup();
+                    resolve(value);
+                    return;
+                }
+                if (character === "\u007f" || character === "\b") {
+                    value = value.slice(0, -1);
+                    continue;
+                }
+                if (character >= " ")
+                    value += character;
+            }
+        };
+        input.on("data", onData);
+    });
+}

package/dist/r2.d.ts

@@ -0,0 +1,32 @@
+import { S3Client } from "@aws-sdk/client-s3";
+import { type StoredCredentials } from "./secure-store.js";
+export interface R2Config {
+    accountId: string;
+    bucket: string;
+    endpoint: string;
+    expiresIn: number;
+}
+export interface R2Artifact {
+    key: string;
+    hash: string;
+    size: number;
+    contentType: string;
+    url: string;
+    expiresAt: string;
+}
+export interface R2UploadOptions {
+    onProgress?: (uploadedBytes: number, totalBytes: number) => void;
+}
+declare function defaultEndpoint(accountId: string): string;
+export declare function loadR2(root: string): Promise<{
+    config: R2Config;
+    credentials: NonNullable<StoredCredentials["r2"]>;
+}>;
+export declare function createR2Client(config: R2Config, credentials: NonNullable<StoredCredentials["r2"]>): S3Client;
+export declare function verifyR2(config: R2Config, credentials: NonNullable<StoredCredentials["r2"]>): Promise<void>;
+export declare function uploadR2Artifact(root: string, projectId: string, buildId: string, file: string, contentType: string, objectName?: string, options?: R2UploadOptions): Promise<R2Artifact>;
+export declare function writeR2Config(root: string, config: R2Config, options?: {
+    global?: boolean;
+}): Promise<void>;
+export { defaultEndpoint };
+//# sourceMappingURL=r2.d.ts.map

package/dist/r2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"r2.d.ts","sourceRoot":"","sources":["../src/r2.ts"],"names":[],"mappings":"AAEA,OAAO,EAGL,QAAQ,EACT,MAAM,oBAAoB,CAAC;AAI5B,OAAO,EAAmB,KAAK,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAG5E,MAAM,WAAW,QAAQ;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,UAAU;IACzB,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,eAAe;IAC9B,UAAU,CAAC,EAAE,CAAC,aAAa,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,KAAK,IAAI,CAAC;CAClE;AAYD,iBAAS,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAElD;AA0BD,wBAAsB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IAClD,MAAM,EAAE,QAAQ,CAAC;IACjB,WAAW,EAAE,WAAW,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC,CAAC;CACnD,CAAC,CA0CD;AAED,wBAAgB,cAAc,CAC5B,MAAM,EAAE,QAAQ,EAChB,WAAW,EAAE,WAAW,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC,GAChD,QAAQ,CAMV;AAED,wBAAsB,QAAQ,CAC5B,MAAM,EAAE,QAAQ,EAChB,WAAW,EAAE,WAAW,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC,GAChD,OAAO,CAAC,IAAI,CAAC,CAOf;AAED,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,MAAM,EACnB,UAAU,CAAC,EAAE,MAAM,EACnB,OAAO,GAAE,eAAoB,GAC5B,OAAO,CAAC,UAAU,CAAC,CAkDrB;AAED,wBAAsB,aAAa,CACjC,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,QAAQ,EAChB,OAAO,GAAE;IAAE,MAAM,CAAC,EAAE,OAAO,CAAA;CAAO,GACjC,OAAO,CAAC,IAAI,CAAC,CAYf;AAED,OAAO,EAAE,eAAe,EAAE,CAAC"}