@bipopush/cli 0.2.0 → 0.3.0-beta.3

package/README.md

@@ -46,7 +46,7 @@ Published iOS 1.0 v7 to production.
 
 - The signing key is saved at `~/.config/bipopush/keys/<appId>.pem`. Keep it private — whoever has it can ship code to your users.
 - In CI set `BIPOPUSH_TOKEN` (a CLI token) and `BIPOPUSH_SIGNING_KEY` (the PEM, or its base64).
-- `bsdiff-nodejs` is an optional native dependency; without it releases still work, just without patches.
+- Patches are made by `bsdiff-wasm` (Debian's bsdiff 4.3 compiled to WebAssembly, BSDIFF40): nothing is compiled on install.
 
 ## Environment
 

package/dist/commands.js

@@ -155,7 +155,11 @@ export async function release(token, opts) {
         throw new Error(`No ${PROJECT_FILE} here. Run: bipopush init`);
     const project = detectProject(opts.cwd);
     const privateKey = loadSigningKey(config.appId);
-    const { app } = await request(`/apps/${config.appId}`, { token });
+    const { app, plan } = await request(`/apps/${config.appId}`, { token });
+    // Same answer the API gives, before spending time on bundling and uploads.
+    if (opts.rollout !== undefined && opts.rollout < 100 && plan?.gradualRollouts === false) {
+        throw new Error("Gradual rollouts are on Plus and above. Release to everyone (no --rollout), or upgrade in the dashboard: Subscription.");
+    }
     const wanted = opts.platform === "all" ? ["ios", "android"] : [opts.platform];
     const platforms = wanted.filter((p) => project[p].id && project[p].version);
     if (platforms.length === 0)
@@ -197,9 +201,11 @@ export async function release(token, opts) {
             channel: opts.channel,
             message: opts.message,
             mandatory: Boolean(opts.mandatory),
+            ...(opts.rollout !== undefined && opts.rollout < 100 ? { rolloutPercent: opts.rollout } : {}),
             artifacts: packed.map((a) => ({
                 platform: a.platform,
                 appVersion: a.appVersion,
+                ...(project[a.platform].build ? { nativeBuild: project[a.platform].build } : {}),
                 sha256: a.sha256,
                 signature: a.signature,
                 bundleSize: a.bundleSize,
@@ -217,7 +223,10 @@ export async function release(token, opts) {
     }
     const { release: published, usage } = await waitingForBurst(() => request(`/releases/${created.releaseId}/publish`, { method: "POST", token }));
     const labels = published.artifacts.map((a) => `${a.platform === "ios" ? "iOS" : "Android"} ${a.appVersion} v${a.version}`);
-    console.log(`\nPublished ${labels.join(", ")} to ${opts.channel}${opts.mandatory ? " (mandatory)" : ""}.`);
+    const rolling = opts.rollout !== undefined && opts.rollout < 100 ? `, to ${opts.rollout}% of devices` : "";
+    console.log(`\nPublished ${labels.join(", ")} to ${opts.channel}${opts.mandatory ? " (mandatory)" : ""}${rolling}.`);
+    if (rolling)
+        console.log(`Raise it later with: bipopush rollout <percent> -c ${opts.channel} (or 100 to finish)`);
     console.log(`${usage.used} release${usage.used === 1 ? "" : "s"} of this app in the last 24h.`);
 }
 /** Waits out a release pause (going over the plan's releases per 10 minutes) instead of failing, e.g. in CI. */
@@ -270,6 +279,57 @@ export async function listApps(token) {
         }
     }
 }
+/** The newest live version per platform and native version in a channel (or the given --number). */
+async function newestLive(token, opts) {
+    const config = loadProjectConfig(opts.cwd);
+    if (!config)
+        throw new Error(`No ${PROJECT_FILE} here. Run: bipopush init`);
+    const { releases } = await request(`/apps/${config.appId}/releases`, { token });
+    const picked = new Map();
+    for (const a of releases.filter((r) => r.channel === opts.channel).flatMap((r) => r.artifacts)) {
+        if (a.disabled || a.fileDeleted || (opts.platform !== "all" && a.platform !== opts.platform))
+            continue;
+        if (opts.version !== undefined && a.version !== opts.version)
+            continue;
+        const key = `${a.platform}/${a.appVersion}`;
+        if (!picked.has(key) || picked.get(key).version < a.version)
+            picked.set(key, a);
+    }
+    if (picked.size === 0)
+        throw new Error(`No live ${opts.version ? `v${opts.version} ` : ""}version in ${opts.channel}`);
+    return { appId: config.appId, picked: [...picked.values()] };
+}
+const label = (a) => `${a.platform === "ios" ? "iOS" : "Android"} ${a.appVersion} v${a.version}`;
+function patchArtifact(token, appId, artifactId, body) {
+    return request(`/apps/${appId}/artifacts/${artifactId}`, { method: "PATCH", token, headers: { "content-type": "application/json" }, body: JSON.stringify(body) });
+}
+/** Changes how many devices get the newest version (100 finishes the rollout). */
+export async function rollout(token, opts) {
+    const { appId, picked } = await newestLive(token, opts);
+    for (const a of picked) {
+        await patchArtifact(token, appId, a.id, { rolloutPercent: opts.percent });
+        console.log(`${label(a)} on ${opts.channel}: ${a.rolloutPercent}% → ${opts.percent}% of devices${opts.percent === 100 ? " (rollout complete)" : ""}`);
+    }
+}
+/** Disables the newest version of a channel (or --number): devices get the newest enabled one. */
+export async function disable(token, opts) {
+    const { appId, picked } = await newestLive(token, opts);
+    for (const a of picked) {
+        await patchArtifact(token, appId, a.id, { disabled: true });
+        console.log(`Disabled ${label(a)} on ${opts.channel}. Devices get the newest enabled version on their next check.`);
+    }
+}
+/** Marks the newest version mandatory (or optional) and/or changes its rollout, like CodePush's patch. */
+export async function patchRelease(token, opts) {
+    const { appId, picked } = await newestLive(token, opts);
+    for (const a of picked) {
+        if (opts.mandatory !== undefined)
+            await patchArtifact(token, appId, a.id, { mandatory: opts.mandatory });
+        if (opts.percent !== undefined)
+            await patchArtifact(token, appId, a.id, { rolloutPercent: opts.percent });
+        console.log(`Updated ${label(a)} on ${opts.channel}.`);
+    }
+}
 /**
  * Re-publishes the newest live version of a channel (or a given --version) in another channel,
  * e.g. staging → production after testing. Same bundle and signature; does not use the daily quota.

package/dist/compat.js

@@ -0,0 +1,96 @@
+import { parseArgs } from "node:util";
+/** CodePush deployments are "Staging" and "Production"; BipoPush channels are lower-case. */
+const channelOf = (deployment) => deployment.trim().toLowerCase();
+export function percent(value, flag) {
+    if (value === undefined)
+        return undefined;
+    const n = Number(value.replace(/%$/, ""));
+    if (!Number.isInteger(n) || n < 1 || n > 100)
+        throw new Error(`${flag} must be a whole number from 1 to 100`);
+    return n;
+}
+const platformOf = (value) => {
+    const p = (value ?? "all").toLowerCase();
+    if (p !== "ios" && p !== "android" && p !== "all")
+        throw new Error("Platform must be ios, android or all");
+    return p;
+};
+/** Returns the mapped command, or null when `args` isn't a CodePush / EAS command line. */
+export function parseCompat(argv) {
+    const args = argv[0] === "codepush" ? argv.slice(1) : argv;
+    const codepush = argv[0] === "codepush";
+    const command = args[0];
+    if (command === "release-react") {
+        const { positionals, values } = parseArgs({
+            args: args.slice(1),
+            allowPositionals: true,
+            strict: false,
+            options: {
+                deploymentName: { type: "string", short: "d" },
+                description: { type: "string" },
+                des: { type: "string" },
+                mandatory: { type: "boolean", short: "m" },
+                rollout: { type: "string", short: "r" },
+                app: { type: "string", short: "a" },
+                targetBinaryVersion: { type: "string", short: "t" },
+            },
+        });
+        // code-push release-react <app> <platform>; appcenter codepush release-react -a owner/app (platform from the project).
+        const platform = codepush ? positionals[1] ?? positionals[0] : positionals[1];
+        return {
+            kind: "release",
+            platform: platformOf(platform === undefined || /\//.test(platform) ? undefined : platform),
+            channel: channelOf(typeof values.deploymentName === "string" ? values.deploymentName : "Staging"),
+            message: (typeof values.description === "string" ? values.description : undefined) ?? (typeof values.des === "string" ? values.des : undefined),
+            mandatory: values.mandatory === true,
+            rollout: percent(typeof values.rollout === "string" ? values.rollout : undefined, "--rollout"),
+        };
+    }
+    if (command === "promote" || command === "rollback" || command === "patch") {
+        const { positionals, values } = parseArgs({
+            args: args.slice(1),
+            allowPositionals: true,
+            strict: false,
+            options: { mandatory: { type: "string", short: "m" }, rollout: { type: "string", short: "r" }, app: { type: "string", short: "a" } },
+        });
+        // BipoPush's own promote / rollback use flags; the CodePush forms are positional (<app> <deployment>…).
+        const names = typeof values.app === "string" ? positionals : positionals.slice(1);
+        if (command === "promote" && names.length >= 2)
+            return { kind: "promote", from: channelOf(names[0]), to: channelOf(names[1]) };
+        if (command === "rollback" && names.length >= 1)
+            return { kind: "rollback", channel: channelOf(names[0]) };
+        if (command === "patch" && names.length >= 1) {
+            const m = typeof values.mandatory === "string" ? values.mandatory : undefined;
+            return {
+                kind: "patch",
+                channel: channelOf(names[0]),
+                mandatory: m === undefined ? undefined : m !== "false",
+                rollout: percent(typeof values.rollout === "string" ? values.rollout : undefined, "--rollout"),
+            };
+        }
+        return null;
+    }
+    if (command === "update" || command === "update:edit") {
+        const { values } = parseArgs({
+            args: args.slice(1),
+            strict: false,
+            options: {
+                channel: { type: "string" },
+                branch: { type: "string" },
+                message: { type: "string", short: "m" },
+                platform: { type: "string", short: "p" },
+                "rollout-percentage": { type: "string" },
+            },
+        });
+        const str = (v) => (typeof v === "string" ? v : undefined);
+        const channel = channelOf(str(values.channel) ?? str(values.branch) ?? "production");
+        const rollout = percent(str(values["rollout-percentage"]), "--rollout-percentage");
+        if (command === "update:edit") {
+            if (rollout === undefined)
+                throw new Error("update:edit needs --rollout-percentage");
+            return { kind: "rollout", channel, platform: platformOf(str(values.platform)), percent: rollout };
+        }
+        return { kind: "release", platform: platformOf(str(values.platform)), channel, message: str(values.message), mandatory: false, rollout };
+    }
+    return null;
+}

package/dist/index.js

@@ -1,6 +1,9 @@
 #!/usr/bin/env node
+import { createRequire } from "node:module";
 import { parseArgs } from "node:util";
-import { init, listApps, promote, release } from "./commands.js";
+import { disable, init, listApps, patchRelease, promote, release, rollout } from "./commands.js";
+import { parseCompat, percent } from "./compat.js";
+import { migrate } from "./migrate.js";
 import { API_URL, CREDENTIALS_FILE, clearCredentials, loadCredentials } from "./config.js";
 import { ApiError, request } from "./http.js";
 import { login } from "./login.js";
@@ -20,14 +23,26 @@ Usage:
       -c, --channel <name>       production (default), staging, beta… — created if the plan allows
       -m, --message <text>       Release note
       --mandatory                Devices install it right away (critical fix)
+      --rollout <percent>        Only this share of devices gets it at first (e.g. 10; Plus and above)
       --dry-run                  Build and show sizes without uploading
+  bipopush rollout <percent>     Change how many devices get the newest version (100 finishes; Plus and above)
+      -c, --channel <name>  -p, --platform ios|android|all  --number <n>
+  bipopush disable               Disable the newest version (or --number); devices get the newest enabled one
+      -c, --channel <name>  -p, --platform ios|android|all  --number <n>
   bipopush promote               Re-publish a tested version in another channel (same bundle)
       --from <channel> --to <channel>  (default: staging → production)
       -p, --platform ios|android|all   (default: all)
       --number <n>               Version to promote, e.g. 3 for v3 (default: newest live one)
   bipopush apps                  List your apps by organization
+  bipopush migrate               Steps to move this project from CodePush, RevoPush or expo-updates
   bipopush logout                Revoke this CLI's token and forget it
 
+Coming from CodePush, RevoPush or Expo? Their commands work too, e.g.
+  bipopush release-react MyApp ios -d Production --description "Fix" -m -r 25
+  bipopush promote MyApp Staging Production      bipopush rollback MyApp Production
+  bipopush patch MyApp Production -m true -r 50
+  bipopush update --channel production --message "Fix" --rollout-percentage 10
+
 Environment:
   BIPOPUSH_API_URL      API base URL (default https://api.bipopush.com)
   BIPOPUSH_SIGN_URL     Sign-in URL  (default https://sign.bipopush.com)
@@ -77,7 +92,26 @@ function oneOf(value, allowed, fallback, flag) {
         throw new Error(`${flag} must be one of: ${allowed.join(", ")}`);
     return value;
 }
+async function runCompat(compat) {
+    const cwd = process.cwd();
+    const token = await requireToken();
+    switch (compat.kind) {
+        case "release":
+            return release(token, { cwd, platform: compat.platform, channel: compat.channel, message: compat.message, mandatory: compat.mandatory, rollout: compat.rollout });
+        case "promote":
+            return promote(token, { cwd, from: compat.from, to: compat.to, platform: "all" });
+        case "rollback":
+            return disable(token, { cwd, channel: compat.channel, platform: "all" });
+        case "patch":
+            return patchRelease(token, { cwd, channel: compat.channel, platform: "all", mandatory: compat.mandatory, percent: compat.rollout });
+        case "rollout":
+            return rollout(token, { cwd, channel: compat.channel, platform: compat.platform, percent: compat.percent });
+    }
+}
 async function main() {
+    const compat = parseCompat(process.argv.slice(2));
+    if (compat)
+        return runCompat(compat);
     const { positionals, values } = parseArgs({
         allowPositionals: true,
         options: {
@@ -96,11 +130,12 @@ async function main() {
             from: { type: "string" },
             to: { type: "string" },
             number: { type: "string" },
+            rollout: { type: "string" },
         },
     });
     const [command] = positionals;
     if (values.version)
-        return console.log("0.2.0");
+        return console.log(createRequire(import.meta.url)("../package.json").version);
     if (values.help || !command)
         return console.log(HELP);
     const cwd = process.cwd();
@@ -125,8 +160,29 @@ async function main() {
                 channel: channelArg(values.channel, "production", "--channel"),
                 message: values.message,
                 mandatory: values.mandatory,
+                rollout: percent(values.rollout, "--rollout"),
                 dryRun: values["dry-run"],
             });
+        case "rollout": {
+            const share = percent(positionals[1], "rollout <percent>");
+            if (share === undefined)
+                throw new Error("Usage: bipopush rollout <percent> [-c channel]");
+            return rollout(await requireToken(), {
+                cwd,
+                channel: channelArg(values.channel, "production", "--channel"),
+                platform: oneOf(values.platform, ["ios", "android", "all"], "all", "--platform"),
+                version: values.number ? Number(values.number.replace(/^v/i, "")) : undefined,
+                percent: share,
+            });
+        }
+        case "disable":
+        case "rollback": // CodePush's name for it
+            return disable(await requireToken(), {
+                cwd,
+                channel: channelArg(values.channel, "production", "--channel"),
+                platform: oneOf(values.platform, ["ios", "android", "all"], "all", "--platform"),
+                version: values.number ? Number(values.number.replace(/^v/i, "")) : undefined,
+            });
         case "promote":
             return promote(await requireToken(), {
                 cwd,
@@ -137,6 +193,8 @@ async function main() {
             });
         case "apps":
             return listApps(await requireToken());
+        case "migrate":
+            return migrate(cwd);
         case "logout":
             return logout();
         default:

package/dist/migrate.js

@@ -0,0 +1,65 @@
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import path from "node:path";
+/** OTA libraries BipoPush replaces, by package name. */
+const SOURCES = {
+    "react-native-code-push": "CodePush",
+    "@revopush/react-native-code-push": "RevoPush",
+    "@code-push-next/react-native-code-push": "CodePush (code-push-next)",
+    "expo-updates": "Expo Updates",
+};
+/** Files under src-like folders that import the old library (at most 20, for the summary). */
+function importers(cwd, names) {
+    const found = [];
+    const walk = (dir) => {
+        for (const entry of readdirSync(dir)) {
+            if (found.length >= 20 || entry === "node_modules" || entry.startsWith(".") || entry === "ios" || entry === "android")
+                continue;
+            const full = path.join(dir, entry);
+            if (statSync(full).isDirectory())
+                walk(full);
+            else if (/\.(jsx?|tsx?)$/.test(entry) && names.some((n) => readFileSync(full, "utf8").includes(`"${n}"`) || readFileSync(full, "utf8").includes(`'${n}'`))) {
+                found.push(path.relative(cwd, full));
+            }
+        }
+    };
+    walk(cwd);
+    return found;
+}
+/** Prints what to change to move this project from CodePush, RevoPush or expo-updates to BipoPush. */
+export function migrate(cwd) {
+    const pkgFile = path.join(cwd, "package.json");
+    if (!existsSync(pkgFile))
+        throw new Error("Run this in your React Native / Expo project folder (no package.json here)");
+    const pkg = JSON.parse(readFileSync(pkgFile, "utf8"));
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    const present = Object.keys(SOURCES).filter((name) => deps[name]);
+    if (present.length === 0) {
+        console.log("No CodePush, RevoPush or expo-updates in this project. Start with: npx @bipopush/cli init");
+        return;
+    }
+    const codePush = present.filter((n) => n !== "expo-updates");
+    const expo = present.includes("expo-updates");
+    console.log(`Found ${present.map((n) => SOURCES[n]).join(" and ")}. To move to BipoPush:\n`);
+    let step = 1;
+    const say = (text) => console.log(`${step++}. ${text}`);
+    say(`Install the SDK: npm install @bipopush/react-native${expo ? "   (Expo: npx expo install @bipopush/react-native)" : ""}`);
+    say(`Remove ${present.join(", ")} (npm uninstall), and its native setup:`);
+    if (codePush.length) {
+        console.log("   iOS: CodePush.bundleURL() in AppDelegate and CodePushDeploymentKey in Info.plist");
+        console.log("   Android: CodePush in MainApplication and CodePushDeploymentKey in strings.xml");
+    }
+    if (expo)
+        console.log('   app.json: the "updates" block and "runtimeVersion" (expo-updates); keep your other plugins');
+    say("Register the app and write its keys into the native project: npx @bipopush/cli init");
+    const files = importers(cwd, present);
+    const subpath = codePush.length ? "codepush" : "expo-updates";
+    say(`Keep your code: change the import to "@bipopush/react-native/${subpath}"${files.length ? ` (${files.length} file${files.length === 1 ? "" : "s"}: ${files.slice(0, 5).join(", ")}${files.length > 5 ? "…" : ""})` : ""},`);
+    console.log(`   or leave imports alone and in metro.config.js: module.exports = require("@bipopush/react-native/metro").withBipoPush(config, { ${codePush.length ? "codePush: true" : "expoUpdates: true"} })`);
+    say("Rebuild the native app once (it now embeds BipoPush), then ship updates: npx @bipopush/cli release");
+    if (codePush.length) {
+        console.log("\nYour CodePush scripts keep working: bipopush release-react <app> <platform> -d Production, promote, rollback and patch.");
+        console.log("Deployments become channels: Production → production, Staging → staging.");
+    }
+    if (expo)
+        console.log("\nYour EAS commands map too: bipopush update --channel production --message \"…\" --rollout-percentage 10.");
+}

package/dist/pack.js

@@ -5,6 +5,7 @@ import { createRequire } from "node:module";
 import { tmpdir } from "node:os";
 import path from "node:path";
 import { brotliCompressSync, brotliDecompressSync, constants } from "node:zlib";
+import { loadBsdiff } from "bsdiff-wasm";
 import { signDigest } from "./keys.js";
 /** A patch is only worth shipping when it is clearly smaller than the compressed full bundle. */
 export const PATCH_RATIO = 0.6;
@@ -45,22 +46,15 @@ export function compress(data) {
 export function decompress(data) {
     return brotliDecompressSync(data);
 }
-/** BSDIFF40 patch (old → new), or null when the optional native addon is unavailable. */
-export async function makePatch(oldData, newData, workDir) {
-    let bsdiff;
-    try {
-        bsdiff = localRequire("bsdiff-nodejs");
-    }
-    catch {
-        return null;
-    }
-    const oldFile = path.join(workDir, "base.hbc");
-    const newFile = path.join(workDir, "new.hbc");
-    const patchFile = path.join(workDir, "bundle.bspatch");
-    writeFileSync(oldFile, oldData);
-    writeFileSync(newFile, newData);
-    await bsdiff.diff(oldFile, newFile, patchFile);
-    return readFileSync(patchFile);
+/** BSDIFF40 patch (old → new), the format the SDK's bspatch applies. WebAssembly: nothing to compile on install. */
+export async function makePatch(oldData, newData) {
+    const bsdiff = await loadBsdiff();
+    bsdiff.FS.writeFile("/base.hbc", oldData);
+    bsdiff.FS.writeFile("/new.hbc", newData);
+    const code = bsdiff.callMain(["/base.hbc", "/new.hbc", "/bundle.bspatch"]);
+    if (code)
+        throw new Error(`bsdiff failed (exit ${code})`);
+    return Buffer.from(bsdiff.FS.readFile("/bundle.bspatch"));
 }
 /**
  * Canonical manifest digest (same in the API and the native SDK):
@@ -148,10 +142,8 @@ async function packIn(work, opts) {
     let patch = null;
     let patchNote = "no previous release for this channel and version";
     if (opts.base) {
-        const data = await makePatch(opts.base.hbc, hbc, work);
-        if (!data)
-            patchNote = "bsdiff-nodejs not installed";
-        else if (data.length >= full.length * PATCH_RATIO)
+        const data = await makePatch(opts.base.hbc, hbc);
+        if (data.length >= full.length * PATCH_RATIO)
             patchNote = `patch ${data.length} B is not smaller than ${PATCH_RATIO * 100}% of full`;
         else {
             patch = { baseArtifactId: opts.base.artifactId, data };

package/dist/project.js

@@ -32,7 +32,7 @@ function plistValue(file, keyPath) {
 }
 function readIos(root) {
     const iosDir = path.join(root, "ios");
-    const empty = { info: { id: null, version: null, scheme: null }, plist: null };
+    const empty = { info: { id: null, version: null, build: null, scheme: null }, plist: null };
     if (!existsSync(iosDir))
         return empty;
     const proj = readdirSync(iosDir).find((f) => f.endsWith(".xcodeproj"));
@@ -50,7 +50,10 @@ function readIos(root) {
     // "$(MARKETING_VERSION)" in bare React Native projects.
     const plistVersion = plist ? plistValue(plist, "CFBundleShortVersionString") : null;
     const version = plistVersion && !plistVersion.includes("$(") ? plistVersion : pbxSetting(pbx, "MARKETING_VERSION");
-    return { info: { id, version, scheme }, plist: plist && existsSync(plist) ? plist : null };
+    // Same for the build: CFBundleVersion, "$(CURRENT_PROJECT_VERSION)" in bare projects.
+    const plistBuild = plist ? plistValue(plist, "CFBundleVersion") : null;
+    const build = plistBuild && !plistBuild.includes("$(") ? plistBuild : pbxSetting(pbx, "CURRENT_PROJECT_VERSION");
+    return { info: { id, version, build, scheme }, plist: plist && existsSync(plist) ? plist : null };
 }
 function androidManifestFile(root) {
     const file = path.join(root, "android", "app", "src", "main", "AndroidManifest.xml");
@@ -59,14 +62,15 @@ function androidManifestFile(root) {
 function readAndroid(root) {
     const gradleFile = ["build.gradle", "build.gradle.kts"].map((f) => path.join(root, "android", "app", f)).find(existsSync);
     if (!gradleFile)
-        return { id: null, version: null, scheme: null };
+        return { id: null, version: null, build: null, scheme: null };
     const gradle = readFileSync(gradleFile, "utf8");
     const id = gradle.match(/applicationId\s*=?\s*["']([^"']+)["']/)?.[1] ?? null;
     const version = gradle.match(/versionName\s*=?\s*["']([^"']+)["']/)?.[1] ?? null;
+    const build = gradle.match(/versionCode\s*=?\s*(\d+)/)?.[1] ?? null;
     const manifestFile = path.join(root, "android", "app", "src", "main", "AndroidManifest.xml");
     const manifest = existsSync(manifestFile) ? readFileSync(manifestFile, "utf8") : "";
     const scheme = manifest.match(/<data[^>]*android:scheme="([^"]+)"/)?.[1] ?? null;
-    return { id, version, scheme };
+    return { id, version, build, scheme };
 }
 /** Detects Expo vs bare React Native and reads native identifiers, versions and URL scheme. */
 export function detectProject(root) {
@@ -88,8 +92,18 @@ export function detectProject(root) {
             type: "expo",
             name: expo.name ?? pkg.name ?? "app",
             entryFile,
-            ios: { id: expo.ios?.bundleIdentifier ?? null, version: expo.ios?.version ?? expo.version ?? null, scheme },
-            android: { id: expo.android?.package ?? null, version: expo.version ?? null, scheme },
+            ios: {
+                id: expo.ios?.bundleIdentifier ?? null,
+                version: expo.ios?.version ?? expo.version ?? null,
+                build: expo.ios?.buildNumber != null ? String(expo.ios.buildNumber) : null,
+                scheme,
+            },
+            android: {
+                id: expo.android?.package ?? null,
+                version: expo.version ?? null,
+                build: expo.android?.versionCode != null ? String(expo.android.versionCode) : null,
+                scheme,
+            },
             iosInfoPlist: null,
             androidManifest: null,
         };

package/package.json

@@ -1,11 +1,16 @@
 {
   "name": "@bipopush/cli",
-  "version": "0.2.0",
+  "version": "0.3.0-beta.3",
   "description": "BipoPush CLI — log in and publish releases",
   "type": "module",
   "license": "MIT",
   "author": "BipoPush <contact@bipopush.com> (https://bipopush.com)",
   "homepage": "https://bipopush.com",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bipopush/bipopush.git",
+    "directory": "cli"
+  },
   "bugs": {
     "email": "contact@bipopush.com"
   },
@@ -35,10 +40,10 @@
     "@types/node": "^26.6.3",
     "typescript": "^6.0.3"
   },
-  "optionalDependencies": {
-    "bsdiff-nodejs": "^2.2.0"
-  },
   "publishConfig": {
     "access": "public"
+  },
+  "dependencies": {
+    "bsdiff-wasm": "0.1.4"
   }
 }