@lynxship/cli 0.1.0

package/README.md

@@ -0,0 +1,122 @@
+# @lynxship/cli
+
+Build, sign, store, submit and update LynxJS applications from the terminal.
+
+LynxShip connects a real Rspeedy bundle to the native Android or iOS build
+toolchain, verifies the resulting signature, uploads immutable artifacts to
+Cloudflare R2 and exposes an expiring download URL with a compact terminal QR
+code.
+
+> LynxShip is currently beta software. Android local builds are exercised
+> end-to-end. iOS builds require macOS and Xcode. Store submission still uses
+> the developer's own Google Play or App Store Connect credentials.
+
+## Install
+
+```bash
+npm install --global @lynxship/cli
+```
+
+Or run it without a global install:
+
+```bash
+npx @lynxship/cli doctor --project-dir ./my-lynx-app
+```
+
+The package exposes the `lynxship` executable.
+
+## Requirements
+
+- Node.js 22 LTS or newer; Node.js 24 LTS is the recommended production
+  baseline.
+- A LynxJS project using Rspeedy.
+- Android builds: JDK 17, Android SDK, `adb`, build tools and the project's
+  Gradle wrapper.
+- iOS builds: macOS, Xcode and Xcode command-line tools.
+- Cloudflare R2 credentials for artifact storage.
+
+## First configuration
+
+Run these once on each development or CI machine:
+
+```bash
+lynxship storage configure
+lynxship android configure
+lynxship store configure --platform android
+```
+
+Secret inputs are hidden. Credentials are stored outside the project using the
+OS-specific secure storage path. They are never written to `lynxship.json`.
+
+The project itself is initialized automatically by `build` when needed, or
+explicitly with:
+
+```bash
+lynxship init --project-dir ./my-lynx-app
+```
+
+## Build a signed Android artifact
+
+```bash
+lynxship build \
+  --project-dir ./my-lynx-app \
+  --platform android \
+  --profile production
+```
+
+The interactive build journal follows the real pipeline:
+
+```text
+Rspeedy bundle
+  -> Android asset synchronization
+  -> Android SDK and Gradle
+  -> release APK or AAB
+  -> signature verification
+  -> UUID artifact name
+  -> Cloudflare R2 upload
+  -> expiring download URL and QR code
+```
+
+Progress percentages are shown only when LynxShip has a real measurement. Long
+Rspeedy, Gradle and Xcode operations remain visible in the event journal until
+their completion checkpoint is known; no timer-based percentage is invented.
+
+## Main commands
+
+```text
+init                 Initialize or link a project
+doctor               Check the local toolchain and project
+dev                  Run the Rspeedy development server
+preview              Preview the production bundle locally
+build                Build, sign and upload an artifact
+submit               Submit the latest successful artifact
+update               Publish a signed OTA update
+run                  Install an artifact on a target
+logs                 Stream native logs
+autolink check       Check Lynx native-library wiring
+autolink codegen     Run native-module codegen
+ota doctor           Check native OTA host integration
+storage configure    Configure Cloudflare R2
+android configure   Configure Android signing
+store configure      Configure store submission credentials
+```
+
+Use `lynxship --help` or `lynxship <command> --help` for the complete option
+list. `--json`, `--quiet`, `--no-color` and `--non-interactive` are available
+for automation.
+
+## OTA safety
+
+OTA updates are for JavaScript and assets compatible with the installed native
+runtime. If native code, permissions, autolinked modules or other runtime
+inputs change, LynxShip blocks the OTA and requires a new signed binary build.
+
+## Package layout
+
+The CLI is backed by the public `@lynxship/*` runtime packages in this
+workspace. They are published with the same version and must be available in
+the configured npm scope before installing the CLI package.
+
+## License
+
+MIT

package/dist/android-build.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"android-build.d.ts","sourceRoot":"","sources":["../src/android-build.ts"],"names":[],"mappings":"AAIA,OAAO,EAAkB,KAAK,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAEpE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAUhD,UAAU,mBAAmB;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,YAAY,CAAC;IACtB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACnC,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;AAoID,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAU7D;AAED,wBAAsB,mBAAmB,CACvC,GAAG,EAAE,QAAQ,EACb,OAAO,EAAE,mBAAmB,GAC3B,OAAO,CAAC,QAAQ,CAAC,CAoInB"}

package/dist/android-build.js

@@ -0,0 +1,201 @@
+import { access, copyFile, mkdir, readFile } from "node:fs/promises";
+import { execFileSync } from "node:child_process";
+import { existsSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { assert, sha256 } from "@lynxship/contracts";
+import { transitionBuild } from "@lynxship/build-orchestrator";
+import { loadR2, uploadR2Artifact } from "./r2.js";
+import { loadCredentials } from "./secure-store.js";
+import { nativeArtifactName } from "./artifact-name.js";
+import { commandExists, packageManagerScriptCommand, runProcess, } from "./process-runner.js";
+async function projectBuildCommand(root) {
+    try {
+        const packageJson = JSON.parse(await readFile(join(root, "package.json"), "utf8"));
+        if (packageJson.scripts?.["build:mobile"])
+            return ["run", "build:mobile"];
+    }
+    catch {
+        // The package manager will report the useful project error below.
+    }
+    return ["run", "build"];
+}
+async function signingEnvironment(root) {
+    const android = (await loadCredentials(root)).android;
+    const values = {
+        LYNXSHIP_KEYSTORE_PATH: process.env.LYNXSHIP_KEYSTORE_PATH ?? android?.keystorePath,
+        LYNXSHIP_KEY_ALIAS: process.env.LYNXSHIP_KEY_ALIAS ?? android?.keyAlias,
+        LYNXSHIP_KEYSTORE_PASSWORD: process.env.LYNXSHIP_KEYSTORE_PASSWORD ?? android?.keystorePassword,
+        LYNXSHIP_KEY_PASSWORD: process.env.LYNXSHIP_KEY_PASSWORD ?? android?.keyPassword,
+    };
+    const missing = Object.entries(values)
+        .filter(([, value]) => !value)
+        .map(([name]) => name);
+    assert(missing.length === 0, "BUILD_SIGNING_REQUIRED", `Signed Android builds require configuration. Missing: ${missing.join(", ")}. Run \`lynxship android configure\`.`);
+    return { ...process.env, ...values };
+}
+async function verifySignedArtifact(root, artifactPath, options) {
+    if (artifactPath.endsWith(".apk")) {
+        const apksigner = androidTool("apksigner");
+        assert(apksigner, "ANDROID_APKSIGNER_REQUIRED", "apksigner was not found in PATH. Install the Android SDK Build Tools.");
+        await runProcess(apksigner, ["verify", "--verbose", artifactPath], {
+            cwd: root,
+            ...options,
+        });
+        return;
+    }
+    const jarsigner = commandExists("jarsigner") ? "jarsigner" : undefined;
+    assert(jarsigner, "ANDROID_JARSIGNER_REQUIRED", "jarsigner was not found in PATH. Install JDK 17.");
+    await runProcess(jarsigner, ["-verify", "-verbose", "-certs", artifactPath], {
+        cwd: root,
+        ...options,
+    });
+}
+function androidTool(name) {
+    if (commandExists(name)) {
+        if (process.platform !== "win32")
+            return name;
+        try {
+            return execFileSync("where.exe", [name], { encoding: "utf8" })
+                .split(/\r?\n/)
+                .map((value) => value.trim())
+                .find(Boolean);
+        }
+        catch {
+            return name;
+        }
+    }
+    const sdk = process.env.ANDROID_SDK_ROOT ?? process.env.ANDROID_HOME ?? undefined;
+    if (!sdk)
+        return undefined;
+    const executable = process.platform === "win32" ? `${name}.bat` : name;
+    try {
+        return readdirSync(join(sdk, "build-tools"))
+            .sort()
+            .reverse()
+            .map((version) => join(sdk, "build-tools", version, executable))
+            .find((candidate) => existsSync(candidate));
+    }
+    catch {
+        return undefined;
+    }
+}
+function artifactDetails(root, profile) {
+    const artifact = profile.android?.artifact ?? "apk";
+    assert(artifact === "apk" || artifact === "aab", "BUILD_ARTIFACT_INVALID", "Android artifact must be apk or aab");
+    return artifact === "aab"
+        ? {
+            task: "bundleRelease",
+            path: join(root, "android", "app", "build", "outputs", "bundle", "release", "app-release.aab"),
+        }
+        : {
+            task: "assembleRelease",
+            path: join(root, "android", "app", "build", "outputs", "apk", "release", "app-release.apk"),
+        };
+}
+export function hasAndroidHost(root) {
+    return access(join(root, "android", process.platform === "win32" ? "gradlew.bat" : "gradlew"))
+        .then(() => true)
+        .catch(() => false);
+}
+export async function runRealAndroidBuild(job, options) {
+    const android = join(options.root, "android");
+    const wrapper = process.platform === "win32" ? "gradlew.bat" : "./gradlew";
+    const artifact = artifactDetails(options.root, options.profile);
+    await loadR2(options.root);
+    const environment = {
+        ...(await signingEnvironment(options.root)),
+        LYNXSHIP_RUNTIME_VERSION: process.env.LYNXSHIP_RUNTIME_VERSION ?? job.runtimeVersion ?? "",
+    };
+    const step = (message, progress) => {
+        options.onStep?.(message);
+        options.onEvent?.(message);
+        if (progress !== undefined)
+            options.onProgress?.(progress, message);
+    };
+    const processOptions = {
+        quiet: options.quiet ?? false,
+        onOutput: options.onEvent,
+    };
+    try {
+        transitionBuild(job, "uploading_source", "local Android source prepared");
+        job.logs.push({
+            level: "info",
+            message: "rspeedy:build",
+            at: new Date().toISOString(),
+        });
+        step("Building Lynx bundle with Rspeedy…");
+        const packageManager = packageManagerScriptCommand(options.root, (await projectBuildCommand(options.root))[1] ?? "build");
+        await runProcess(packageManager.command, packageManager.args, {
+            cwd: options.root,
+            env: environment,
+            ...processOptions,
+        });
+        step("Rspeedy bundle ready", 20);
+        transitionBuild(job, "queued", "Android build queued locally");
+        step("Build queued…");
+        transitionBuild(job, "provisioning", "local Android toolchain selected");
+        step("Checking Android SDK and Gradle toolchain…");
+        transitionBuild(job, "installing_dependencies", "syncing Lynx bundle into Android assets");
+        step("Syncing bundle into the Android host…");
+        await runProcess(process.execPath, [join("android", "sync-bundle.mjs")], {
+            cwd: options.root,
+            env: environment,
+            ...processOptions,
+        });
+        step("Android host synchronized", 40);
+        transitionBuild(job, "building", `Gradle ${artifact.task}`);
+        step(`Running real Gradle task ${artifact.task}…`);
+        await runProcess(wrapper, [artifact.task], {
+            cwd: android,
+            env: environment,
+            ...processOptions,
+        });
+        step(`Gradle ${artifact.task} completed`, 60);
+        transitionBuild(job, "signing", "Gradle release signing completed");
+        step("Verifying Android release signature…");
+        await verifySignedArtifact(options.root, artifact.path, processOptions);
+        step("Android release signature verified", 75);
+        transitionBuild(job, "uploading_artifacts", "local artifact collected");
+        const artifactName = nativeArtifactName(artifact.path.endsWith(".aab") ? "aab" : "apk");
+        const artifactDirectory = join(options.root, ".lynxship", "artifacts");
+        const artifactPath = join(artifactDirectory, artifactName);
+        await mkdir(artifactDirectory, { recursive: true });
+        await copyFile(artifact.path, artifactPath);
+        const content = await readFile(artifactPath);
+        const hash = sha256(content);
+        job.attempts += 1;
+        step("Uploading signed artifact to Cloudflare R2…", 80);
+        const uploaded = await uploadR2Artifact(options.root, job.projectId, job.id, artifactPath, artifactName.endsWith(".aab")
+            ? "application/octet-stream"
+            : "application/vnd.android.package-archive", 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.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 Android artifact created");
+    }
+    catch (error) {
+        if (!["success", "failed", "canceled", "timed_out"].includes(job.state)) {
+            transitionBuild(job, "failed", error instanceof Error ? error.message : "Android build failed");
+        }
+        job.logs.push({
+            level: "error",
+            message: error instanceof Error ? error.message : "Android build failed",
+            at: new Date().toISOString(),
+        });
+        throw error;
+    }
+}

package/dist/artifact-name.d.ts

@@ -0,0 +1,3 @@
+export type NativeArtifactExtension = "apk" | "aab" | "ipa";
+export declare function nativeArtifactName(extension: NativeArtifactExtension): string;
+//# sourceMappingURL=artifact-name.d.ts.map

package/dist/artifact-name.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"artifact-name.d.ts","sourceRoot":"","sources":["../src/artifact-name.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,uBAAuB,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,CAAC;AAE5D,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,uBAAuB,GAAG,MAAM,CAE7E"}

package/dist/artifact-name.js

@@ -0,0 +1,4 @@
+import { randomUUID } from "node:crypto";
+export function nativeArtifactName(extension) {
+    return `${randomUUID()}.${extension}`;
+}

package/dist/autolink.d.ts

@@ -0,0 +1,14 @@
+import { type Platform } from "@lynxship/contracts";
+export interface AutolinkPlatformStatus {
+    required: boolean;
+    ready: boolean;
+    manifests: string[];
+    reason: string;
+}
+export interface AutolinkStatus {
+    android: AutolinkPlatformStatus;
+    ios: AutolinkPlatformStatus;
+}
+export declare function inspectAutolink(root: string): Promise<AutolinkStatus>;
+export declare function requireAutolinkReady(root: string, platform: Platform): Promise<AutolinkPlatformStatus>;
+//# sourceMappingURL=autolink.d.ts.map

package/dist/autolink.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"autolink.d.ts","sourceRoot":"","sources":["../src/autolink.ts"],"names":[],"mappings":"AAGA,OAAO,EAAU,KAAK,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAM5D,MAAM,WAAW,sBAAsB;IACrC,QAAQ,EAAE,OAAO,CAAC;IAClB,KAAK,EAAE,OAAO,CAAC;IACf,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,sBAAsB,CAAC;IAChC,GAAG,EAAE,sBAAsB,CAAC;CAC7B;AAqID,wBAAsB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,CAM3E;AAED,wBAAsB,oBAAoB,CACxC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,QAAQ,GACjB,OAAO,CAAC,sBAAsB,CAAC,CAWjC"}

package/dist/autolink.js

@@ -0,0 +1,144 @@
+import { existsSync } from "node:fs";
+import { readdir, readFile, realpath, stat } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { assert } from "@lynxship/contracts";
+const emptyStatus = () => ({
+    required: false,
+    ready: true,
+    manifests: [],
+    reason: "No Lynx native-library manifest found",
+});
+function findNodeModuleRoots(root) {
+    const roots = [];
+    let current = root;
+    while (true) {
+        roots.push(join(current, "node_modules"));
+        const parent = dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    return roots;
+}
+async function findManifests(root) {
+    const result = new Set();
+    const visited = new Set();
+    async function visit(current, depth) {
+        if (depth > 7)
+            return;
+        let directory;
+        try {
+            if (!(await stat(current)).isDirectory())
+                return;
+            directory = await realpath(current);
+        }
+        catch {
+            return;
+        }
+        if (visited.has(directory))
+            return;
+        visited.add(directory);
+        let entries;
+        try {
+            entries = await readdir(current, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const file = join(current, entry.name);
+            if (entry.isFile() && entry.name === "lynx.lib.json") {
+                result.add(file);
+                continue;
+            }
+            if (entry.name === ".cache")
+                continue;
+            if (entry.isDirectory()) {
+                await visit(file, depth + 1);
+                continue;
+            }
+            if (entry.isSymbolicLink()) {
+                try {
+                    if ((await stat(file)).isDirectory())
+                        await visit(file, depth + 1);
+                }
+                catch {
+                    // Broken package links are ignored; the package manager reports them.
+                }
+            }
+        }
+    }
+    for (const moduleRoot of findNodeModuleRoots(root))
+        await visit(moduleRoot, 0);
+    return [...result].sort();
+}
+async function hasFile(file) {
+    return existsSync(file);
+}
+async function platformStatus(root, platform, manifests) {
+    const relevant = [];
+    for (const file of manifests) {
+        try {
+            const manifest = JSON.parse(await readFile(file, "utf8"));
+            if (manifest.platforms?.[platform] !== undefined)
+                relevant.push(file);
+        }
+        catch {
+            relevant.push(file);
+        }
+    }
+    if (relevant.length === 0)
+        return emptyStatus();
+    if (platform === "android") {
+        const settingsFile = [
+            join(root, "android", "settings.gradle"),
+            join(root, "android", "settings.gradle.kts"),
+        ].find((file) => existsSync(file));
+        const appFile = [
+            join(root, "android", "app", "build.gradle"),
+            join(root, "android", "app", "build.gradle.kts"),
+        ].find((file) => existsSync(file));
+        const settingsText = settingsFile
+            ? await readFile(settingsFile, "utf8")
+            : "";
+        const appText = appFile ? await readFile(appFile, "utf8") : "";
+        const ready = settingsText.includes("org.lynxsdk.library-settings") &&
+            appText.includes("org.lynxsdk.library-build");
+        return {
+            required: true,
+            ready,
+            manifests: relevant,
+            reason: ready
+                ? "Lynx Android Autolink plugins are enabled"
+                : "Enable org.lynxsdk.library-settings in settings.gradle and org.lynxsdk.library-build in app/build.gradle",
+        };
+    }
+    const podfile = join(root, "ios", "Podfile");
+    const podfileText = (await hasFile(podfile))
+        ? await readFile(podfile, "utf8")
+        : "";
+    const ready = podfileText.includes("cocoapods-lynx-library") &&
+        podfileText.includes("use_lynx_library!");
+    return {
+        required: true,
+        ready,
+        manifests: relevant,
+        reason: ready
+            ? "Lynx iOS Autolink CocoaPods integration is enabled"
+            : "Add cocoapods-lynx-library and use_lynx_library! to ios/Podfile",
+    };
+}
+export async function inspectAutolink(root) {
+    const manifests = await findManifests(root);
+    return {
+        android: await platformStatus(root, "android", manifests),
+        ios: await platformStatus(root, "ios", manifests),
+    };
+}
+export async function requireAutolinkReady(root, platform) {
+    const status = (await inspectAutolink(root))[platform];
+    assert(!status.required || status.ready, platform === "android"
+        ? "LYNX_AUTOLINK_ANDROID_REQUIRED"
+        : "LYNX_AUTOLINK_IOS_REQUIRED", status.reason, { platform, manifests: status.manifests });
+    return status;
+}

package/dist/config.d.ts

@@ -0,0 +1,51 @@
+import { type Platform } from "@lynxship/contracts";
+export interface BuildProfile {
+    distribution?: string;
+    channel?: string;
+    environment?: string;
+    android?: {
+        artifact?: string;
+    };
+    ios?: {
+        configuration?: string;
+        distribution?: string;
+        workspace?: string;
+        project?: string;
+        scheme?: string;
+        exportOptionsPlist?: string;
+        bundleScript?: string;
+    };
+}
+export interface LynxShipConfig {
+    projectId?: string;
+    cli?: {
+        apiUrl?: string;
+        organizationId?: string;
+        token?: string;
+    };
+    runtimeVersion?: {
+        policy: "fingerprint" | "manual";
+        value?: string;
+    };
+    build?: Record<string, BuildProfile>;
+    update?: {
+        protocolVersion?: number;
+        channel?: string;
+        rollout?: {
+            defaultPercentage?: number;
+        };
+    };
+    [key: string]: unknown;
+}
+export declare const DEFAULT_CONFIG: LynxShipConfig;
+export declare function validateConfig(config: unknown, options?: {
+    ci?: boolean;
+}): LynxShipConfig;
+export declare function loadConfig(root: string, options?: {
+    ci?: boolean;
+}): Promise<LynxShipConfig>;
+export declare function resolveProfile(config: LynxShipConfig, name?: string): BuildProfile & {
+    name: string;
+};
+export declare function platformValue(value: string): Platform;
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAEA,OAAO,EAAU,KAAK,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAE5D,MAAM,WAAW,YAAY;IAC3B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAChC,GAAG,CAAC,EAAE;QACJ,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,kBAAkB,CAAC,EAAE,MAAM,CAAC;QAC5B,YAAY,CAAC,EAAE,MAAM,CAAC;KACvB,CAAC;CACH;AAED,MAAM,WAAW,cAAc;IAC7B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,GAAG,CAAC,EAAE;QACJ,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,KAAK,CAAC,EAAE,MAAM,CAAC;KAChB,CAAC;IACF,cAAc,CAAC,EAAE;QAAE,MAAM,EAAE,aAAa,GAAG,QAAQ,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACtE,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IACrC,MAAM,CAAC,EAAE;QACP,eAAe,CAAC,EAAE,MAAM,CAAC;QACzB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,OAAO,CAAC,EAAE;YAAE,iBAAiB,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC;KAC1C,CAAC;IACF,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,eAAO,MAAM,cAAc,EAAE,cAU5B,CAAC;AAaF,wBAAgB,cAAc,CAC5B,MAAM,EAAE,OAAO,EACf,OAAO,GAAE;IAAE,EAAE,CAAC,EAAE,OAAO,CAAA;CAAO,GAC7B,cAAc,CAyChB;AAED,wBAAsB,UAAU,CAC9B,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE;IAAE,EAAE,CAAC,EAAE,OAAO,CAAA;CAAO,GAC7B,OAAO,CAAC,cAAc,CAAC,CAazB;AAED,wBAAgB,cAAc,CAC5B,MAAM,EAAE,cAAc,EACtB,IAAI,SAAe,GAClB,YAAY,GAAG;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAIjC;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,QAAQ,CAOrD"}

package/dist/config.js

@@ -0,0 +1,62 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { assert } from "@lynxship/contracts";
+export const DEFAULT_CONFIG = {
+    runtimeVersion: { policy: "fingerprint" },
+    build: {
+        production: {
+            distribution: "store",
+            channel: "production",
+            environment: "production",
+        },
+    },
+    update: { protocolVersion: 1, channel: "production" },
+};
+const allowedRootKeys = new Set([
+    "$schema",
+    "projectId",
+    "cli",
+    "runtimeVersion",
+    "build",
+    "submit",
+    "update",
+    "artifacts",
+]);
+export function validateConfig(config, options = {}) {
+    assert(config && typeof config === "object" && !Array.isArray(config), "CONFIG_INVALID", "lynxship.json must contain an object");
+    const value = config;
+    const unknown = Object.keys(value).filter((key) => !allowedRootKeys.has(key));
+    assert(!options.ci || unknown.length === 0, "CONFIG_UNKNOWN_KEY", `Unknown configuration key(s): ${unknown.join(", ")}`, { unknown });
+    if (value.projectId !== undefined)
+        assert(typeof value.projectId === "string" && value.projectId.length > 0, "CONFIG_PROJECT_ID", "projectId must be a non-empty string");
+    assert(value.runtimeVersion?.policy === undefined ||
+        ["fingerprint", "manual"].includes(value.runtimeVersion.policy), "CONFIG_RUNTIME_POLICY", "runtimeVersion.policy must be fingerprint or manual");
+    if (value.runtimeVersion?.policy === "manual")
+        assert(typeof value.runtimeVersion.value === "string" &&
+            value.runtimeVersion.value.length > 0, "CONFIG_RUNTIME_VALUE", "runtimeVersion.value is required when runtimeVersion.policy is manual");
+    const percentage = value.update?.rollout?.defaultPercentage;
+    if (percentage !== undefined)
+        assert(Number.isInteger(percentage) && percentage >= 0 && percentage <= 100, "CONFIG_ROLLOUT", "rollout percentage must be an integer between 0 and 100");
+    return value;
+}
+export async function loadConfig(root, options = {}) {
+    try {
+        return validateConfig(JSON.parse(await readFile(join(root, "lynxship.json"), "utf8")), options);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return validateConfig(DEFAULT_CONFIG, options);
+        if (error instanceof SyntaxError)
+            throw new Error(`Invalid JSON in ${join(root, "lynxship.json")}`);
+        throw error;
+    }
+}
+export function resolveProfile(config, name = "production") {
+    const profile = config.build?.[name];
+    assert(profile, "PROFILE_NOT_FOUND", `Build profile '${name}' was not found`);
+    return { name, ...profile };
+}
+export function platformValue(value) {
+    assert(value === "android" || value === "ios", "PLATFORM_INVALID", "Platform must be android or ios");
+    return value;
+}

package/dist/configure.d.ts

@@ -0,0 +1,11 @@
+import { type R2Config } from "./r2.js";
+export declare function configureR2(root: string): Promise<R2Config>;
+interface AndroidConfigurationResult {
+    keystorePath: string;
+    generated: boolean;
+}
+export declare function configureGooglePlay(root: string): Promise<void>;
+export declare function configureAppStoreConnect(root: string): Promise<void>;
+export declare function configureAndroid(root: string): Promise<AndroidConfigurationResult>;
+export {};
+//# sourceMappingURL=configure.d.ts.map

package/dist/configure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"configure.d.ts","sourceRoot":"","sources":["../src/configure.ts"],"names":[],"mappings":"AAMA,OAAO,EAIL,KAAK,QAAQ,EACd,MAAM,SAAS,CAAC;AAQjB,wBAAsB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC,CA2BjE;AAED,UAAU,0BAA0B;IAClC,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,OAAO,CAAC;CACpB;AAED,wBAAsB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CA6CrE;AAED,wBAAsB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAuC1E;AA+ED,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,0BAA0B,CAAC,CAoCrC"}