zipy-mobile-cli 1.0.0

package/README.md

@@ -0,0 +1,157 @@
+# zipy-mobile-cli
+
+CLI to integrate [Zipy](https://zipy.ai) with mobile apps. When you build your app (e.g. React Native Android), it uploads sourcemaps so Zipy can symbolicate errors.
+
+## Install
+
+**Recommended (for Gradle apply-from, like Sentry):** add as a devDependency in your React Native project so `require.resolve('zipy-mobile-cli/package.json')` finds it when Gradle runs:
+
+```bash
+npm install zipy-mobile-cli --save-dev
+```
+
+Then run init with `npx zipy-mobile-cli -i react-native`.
+
+**Alternatively**, install globally:
+
+```bash
+npm install -g zipy-mobile-cli
+```
+
+If you install globally, the init still adds the same `apply from: ... zipy.gradle` line; Gradle will resolve the package from `node_modules` when building, so you should also have `zipy-mobile-cli` as a devDependency for the apply to work.
+
+## Usage
+
+### 1. Initialize in your React Native project
+
+From your **React Native project root** (where `package.json` and `android/` live):
+
+```bash
+zipy-mobile-cli -i react-native
+```
+
+or:
+
+```bash
+zipy-mobile-cli init react-native
+```
+
+This will:
+
+- **Ask for the path to your sourcemaps** (with sensible defaults):
+  - Release: `android/app/build/generated/sourcemaps/react/release/index.android.bundle.map`
+  - Debug: `android/app/build/generated/sourcemaps/react/debug/index.android.bundle.map`
+- Create a config file **`.zipy-mobile.json`** in the project root with those paths.
+- **Add an `apply from:` line to `android/app/build.gradle`** (Sentry-style) that applies `zipy.gradle`. That script hooks into **`react/release`** (the task that bundles JS and generates the source map). When that task finishes, it runs `npx zipy-mobile-cli upload-sourcemaps release`; the paths in `.zipy-mobile.json` match this task’s outputs. Debug is not hooked.
+
+So whenever a new build is made, sourcemaps are uploaded automatically; you don’t need to run a separate command.
+
+### 2. Configure upload (from init)
+
+Init prompts for (or use env): **Upload API base URL**, **API key**, **Customer ID**, **Framework**. These are stored in `.zipy-mobile.json` and used to call:
+
+`POST {uploadBaseUrl}/v1/upload/{apiKey}/{customerId}` with multipart form: `bundle_id`, `release_version`, `framework`, `platform`, `files`. When the upload runs from `gradlew assembleRelease`, `platform` is set to `android` and `bundle_id`/`release_version` come from the build.
+
+### 3. Build as usual
+
+From project root:
+
+```bash
+cd android && ./gradlew assembleRelease
+```
+
+or:
+
+```bash
+./gradlew -p android assembleRelease
+```
+
+After the build finishes, the CLI will upload the sourcemap for that variant.
+
+### 4. Zipy bundle id (release builds)
+
+Each release build generates a **new Zipy bundle id** (UUID) when the **source map** is new or changed, injects it into the release (and packager) source map files under `zipyBundleId` / `zipy_bundle_id`, then uploads. No extra folder or assets are created; the ID lives only in the map files and in the upload payload.
+
+- **When it runs:** The inject task uses the source map as input, so it re-runs whenever the bundle produces a new or changed map (e.g. after code changes). You get a new ID for each such build.
+- **BuildConfig.ZIPY_BUNDLE_ID** is still set to the application ID for use in the app.
+
+## Config file (`.zipy-mobile.json`)
+
+Example (created by init; API key and customer ID are set at init):
+
+```json
+{
+  "projectRoot": "/path/to/your/rn-app",
+  "framework": "react-native",
+  "uploadBaseUrl": "http://localhost:8900",
+  "apiKey": "abc123key",
+  "customerId": "99",
+  "sourcemaps": {
+    "android": {
+      "release": "android/app/build/generated/sourcemaps/react/release/index.android.bundle.map",
+      "debug": "android/app/build/generated/sourcemaps/react/debug/index.android.bundle.map"
+    }
+  },
+  "bundle": {
+    "android": {
+      "release": "android/app/build/generated/assets/react/release/index.android.bundle"
+    }
+  }
+}
+```
+
+Upload is sent as: `POST {uploadBaseUrl}/sourcemaps-mobile-service//v1/upload/{apiKey}/{customerId}` with form fields `bundle_id` (app id from build), `release_version` (version name), `framework`, `platform` (android when from Gradle), and `files` (sourcemap + bundle).
+
+## Manual upload
+
+You can also trigger upload manually (e.g. for CI):
+
+```bash
+zipy-mobile-cli upload-sourcemaps release
+zipy-mobile-cli upload-sourcemaps debug
+```
+
+Run this from the project root (or any directory under it that has `.zipy-mobile.json` above it).
+
+## Requirements
+
+- Node.js >= 14
+- React Native project with Android (`android/app/build.gradle`).
+- `zipy-mobile-cli` either as a project devDependency or installed globally (`npm install -g zipy-mobile-cli`). Gradle resolves `zipy.gradle` from node_modules first, then from global npm root.
+
+## Command to add in your RN app (manual)
+
+If you prefer to add the Zipy Gradle integration by hand, add this at the end of **`android/app/build.gradle`** (after the `android` and `dependencies` blocks):
+
+```groovy
+def zipyProjectRoot = project.rootProject.projectDir.parentFile
+def zipyGradleFile = null
+try {
+  def zipyPackageJson = ["node", "--print", "require.resolve('zipy-mobile-cli/package.json')"].execute(null, zipyProjectRoot).text.trim()
+  if (zipyPackageJson) {
+    def dir = new File(zipyPackageJson).parentFile
+    if (dir != null) zipyGradleFile = new File(dir, "zipy.gradle")
+  }
+} catch (Throwable ignored) {}
+if (zipyGradleFile == null || !zipyGradleFile.exists()) {
+  def npmGlobalRoot = ["npm", "root", "-g"].execute(null, zipyProjectRoot).text.trim()
+  if (npmGlobalRoot) zipyGradleFile = new File(npmGlobalRoot, "zipy-mobile-cli/zipy.gradle")
+}
+if (zipyGradleFile != null && zipyGradleFile.exists()) {
+  apply from: zipyGradleFile
+}
+```
+
+This resolves `zipy.gradle` from **project node_modules** (if `zipy-mobile-cli` is a devDependency) or from **global install** (`npm root -g` + `zipy-mobile-cli`). It then applies `zipy.gradle`, which:
+
+- Hooks into release bundle tasks (`createBundle*JsAndAssets`, non-debug)
+- For each such task: registers **ZipyUpload** (runs `npx zipy-mobile-cli upload-sourcemaps release` with `ZIPY_RELEASE`, `ZIPY_DIST`, `ZIPY_BUILD_ID` from the build) and **ZipyCleanup**
+- Chain: bundle task → ZipyUpload → ZipyCleanup
+
+Set `ZIPY_DISABLE_AUTO_UPLOAD=true` in the environment to skip upload (e.g. for local builds).
+
+## Uninstall / remove integration
+
+1. Remove the `apply from: ... zipy.gradle` line from `android/app/build.gradle` (search for `zipy-mobile-cli`).
+2. Delete `.zipy-mobile.json`.
+3. Optionally: `npm uninstall zipy-mobile-cli` (or `npm uninstall -g zipy-mobile-cli` if you installed globally).

package/bin/zipy-mobile-cli.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+
+/**
+ * Global entry point for zipy-mobile-cli.
+ * Forwards to the main CLI so the package can be installed globally (npm i -g zipy-mobile-cli).
+ */
+require('../dist/cli').run(process.argv.slice(2));

package/dist/cli.d.ts

@@ -0,0 +1,5 @@
+export declare function run(argv: string[]): void;
+/**
+ * Find directory containing .zipy-mobile.json (walk up from cwd).
+ */
+export declare function findProjectRoot(cwd: string, configName: string): string | null;

package/dist/cli.js

@@ -0,0 +1,160 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = run;
+exports.findProjectRoot = findProjectRoot;
+/**
+ * Main CLI router for zipy-mobile-cli.
+ * Supports: zipy-mobile-cli -i react-native | init react-native | upload-sourcemaps <variant>
+ */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const init_react_native_1 = require("./init-react-native");
+const upload_sourcemaps_1 = require("./upload-sourcemaps");
+const types_1 = require("./types");
+function run(argv) {
+    const args = argv.slice();
+    let command = null;
+    let platform = null;
+    // Parse -i / --init (e.g. zipy-mobile-cli -i react-native)
+    const initIndex = args.findIndex((a) => a === '-i' || a === '--init');
+    if (initIndex !== -1) {
+        command = 'init';
+        platform = args[initIndex + 1] ?? null;
+    }
+    // Parse init <platform> (e.g. zipy-mobile-cli init react-native)
+    if (!command && (args[0] === 'init' || args[0] === 'initialize')) {
+        command = 'init';
+        platform = args[1] ?? null;
+    }
+    // Internal command used by Gradle after assembleRelease/assembleDebug
+    if (args[0] === 'upload-sourcemaps') {
+        command = 'upload-sourcemaps';
+        platform = null;
+    }
+    if (command === 'init') {
+        if (platform !== 'react-native') {
+            console.error('zipy-mobile-cli: Only "react-native" is supported. Use: zipy-mobile-cli -i react-native');
+            process.exit(1);
+        }
+        const initOptions = parseInitOptions(args);
+        (0, init_react_native_1.initReactNative)(process.cwd(), initOptions).then(() => process.exit(0), (err) => {
+            console.error('zipy-mobile-cli:', err.message || err);
+            process.exit(1);
+        });
+        return;
+    }
+    if (command === 'upload-sourcemaps') {
+        const variant = args[1]; // release | debug
+        if (!variant || !['release', 'debug'].includes(variant)) {
+            console.error('zipy-mobile-cli: Usage: zipy-mobile-cli upload-sourcemaps <release|debug>');
+            process.exit(1);
+        }
+        const projectRoot = findProjectRoot(process.cwd(), types_1.CONFIG_FILENAME);
+        if (!projectRoot) {
+            console.error('zipy-mobile-cli: No .zipy-mobile.json found. Run zipy-mobile-cli -i react-native first.');
+            process.exit(1);
+        }
+        (0, upload_sourcemaps_1.uploadSourcemaps)(projectRoot, variant).then(() => process.exit(0), (err) => {
+            console.error('zipy-mobile-cli:', err.message || err);
+            process.exit(1);
+        });
+        return;
+    }
+    // No recognized command → show help
+    printHelp();
+    process.exit(args.includes('--help') || args.includes('-h') ? 0 : 1);
+}
+/** Parse --apikey, --customerId, --authkey from argv for init command. */
+function parseInitOptions(args) {
+    const options = {};
+    const getVal = (name) => {
+        const i = args.findIndex((a) => a === name || a.startsWith(name + '='));
+        if (i === -1)
+            return undefined;
+        const arg = args[i];
+        if (arg == null)
+            return undefined;
+        if (arg.includes('='))
+            return arg.split('=')[1]?.trim();
+        return args[i + 1];
+    };
+    const apiKey = getVal('--apikey');
+    const customerId = getVal('--customerId');
+    const authKey = getVal('--authkey');
+    if (apiKey)
+        options.apiKey = apiKey;
+    if (customerId)
+        options.customerId = customerId;
+    if (authKey)
+        options.authKey = authKey;
+    return options;
+}
+/**
+ * Find directory containing .zipy-mobile.json (walk up from cwd).
+ */
+function findProjectRoot(cwd, configName) {
+    let dir = path.resolve(cwd);
+    const root = path.parse(dir).root;
+    while (dir !== root) {
+        const configPath = path.join(dir, configName);
+        try {
+            fs.accessSync(configPath);
+            return dir;
+        }
+        catch {
+            dir = path.dirname(dir);
+        }
+    }
+    return null;
+}
+function printHelp() {
+    console.log(`
+zipy-mobile-cli — Zipy mobile integration (sourcemap uploads on build)
+
+Usage:
+  zipy-mobile-cli -i react-native [--apikey KEY] [--customerId ID] [--authkey KEY]
+  zipy-mobile-cli init react-native [--apikey KEY] [--customerId ID] [--authkey KEY]
+
+  If --apikey and --customerId are provided, init will not ask for them.
+  Only sourcemap/bundle paths are prompted (or use defaults).
+
+Options:
+  --apikey KEY       API key (skips prompt if set)
+  --customerId ID    Customer ID (skips prompt if set)
+  --authkey KEY      Auth key, sent in upload payload (skips prompt if set)
+  -h, --help         Show this help
+`);
+}

package/dist/init-react-native.d.ts

@@ -0,0 +1,32 @@
+/** Default paths: outputs of react/release (same task Sentry hooks into). */
+export declare const DEFAULT_SOURCEMAP_PATHS: {
+    readonly release: "android/app/build/generated/sourcemaps/react/release/index.android.bundle.map";
+    readonly debug: "android/app/build/generated/sourcemaps/react/debug/index.android.bundle.map";
+};
+/** Default release bundle path: react/release output. */
+export declare const DEFAULT_BUNDLE_PATH_RELEASE = "android/app/build/generated/assets/react/release/index.android.bundle";
+/** Fixed upload API base URL (not prompted). */
+export declare const FIXED_UPLOAD_BASE_URL = "https://app.zipy.ai/api";
+export interface InitOptions {
+    sourcemapPathRelease?: string;
+    sourcemapPathDebug?: string;
+    bundlePathRelease?: string;
+    apiKey?: string;
+    customerId?: string;
+    authKey?: string;
+}
+/**
+ * Create .zipy-mobile.json with API config and sourcemap/bundle paths. Uses fixed upload URL and framework=react-native.
+ */
+export declare function writeConfig(projectRoot: string, options: InitOptions): string;
+/**
+ * Add apply from: zipy.gradle to android/app/build.gradle.
+ * Resolves zipy.gradle from global npm (npm root -g), with Windows fallback; falls back to projectDir/zipy.gradle.
+ */
+export declare function patchGradle(projectRoot: string): void;
+/**
+ * Add a Run Script Build Phase to the iOS app target that runs the Zipy iOS upload script on every build/run.
+ * Same role as zipy.gradle on Android. Patches ios/*.xcodeproj/project.pbxproj.
+ */
+export declare function patchIosProject(projectRoot: string): boolean;
+export declare function initReactNative(projectRoot: string, options?: InitOptions): Promise<void>;

package/dist/init-react-native.js

@@ -0,0 +1,246 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FIXED_UPLOAD_BASE_URL = exports.DEFAULT_BUNDLE_PATH_RELEASE = exports.DEFAULT_SOURCEMAP_PATHS = void 0;
+exports.writeConfig = writeConfig;
+exports.patchGradle = patchGradle;
+exports.patchIosProject = patchIosProject;
+exports.initReactNative = initReactNative;
+/**
+ * Initialize a React Native project for Zipy: create config with sourcemap paths
+ * and patch Android Gradle to run sourcemap upload after assembleRelease/assembleDebug.
+ */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const readline = __importStar(require("readline"));
+const types_1 = require("./types");
+const ANDROID_APP_BUILD_GRADLE = 'android/app/build.gradle';
+const IOS_XCODEPROJ_REL = 'ios';
+/** Unique string in the Zipy Gradle block; used to avoid applying twice. */
+const GRADLE_PATCH_MARKER = 'zipy-mobile-cli/zipy.gradle';
+/** Unique string in the iOS Run Script phase; used to avoid adding twice. */
+const IOS_ZIPY_PHASE_MARKER = 'ZipySourcemapsUpload';
+/** Default paths: outputs of react/release (same task Sentry hooks into). */
+exports.DEFAULT_SOURCEMAP_PATHS = {
+    release: 'android/app/build/generated/sourcemaps/react/release/index.android.bundle.map',
+    debug: 'android/app/build/generated/sourcemaps/react/debug/index.android.bundle.map',
+};
+/** Default release bundle path: react/release output. */
+exports.DEFAULT_BUNDLE_PATH_RELEASE = 'android/app/build/generated/assets/react/release/index.android.bundle';
+/** Fixed upload API base URL (not prompted). */
+exports.FIXED_UPLOAD_BASE_URL = 'https://app.zipy.ai/api';
+function prompt(question, defaultAnswer) {
+    return new Promise((resolve) => {
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        const def = defaultAnswer ? ` (${defaultAnswer})` : '';
+        rl.question(`${question}${def}: `, (answer) => {
+            rl.close();
+            resolve(typeof answer === 'string' && answer.trim() !== '' ? answer.trim() : defaultAnswer);
+        });
+    });
+}
+/** Check if stdin is TTY so we can prompt; otherwise use defaults or env. */
+function isInteractive() {
+    return process.stdin.isTTY === true;
+}
+const CONFIG_COMMENT = 'To change sourcemap or bundle paths: edit sourcemaps.android.release, sourcemaps.android.debug, and bundle.android.release (paths are relative to project root).';
+/**
+ * Create .zipy-mobile.json with API config and sourcemap/bundle paths. Uses fixed upload URL and framework=react-native.
+ */
+function writeConfig(projectRoot, options) {
+    const configPath = path.join(projectRoot, types_1.CONFIG_FILENAME);
+    const config = {
+        _comment: CONFIG_COMMENT,
+        projectRoot,
+        framework: 'react-native',
+        uploadBaseUrl: exports.FIXED_UPLOAD_BASE_URL,
+        apiKey: options.apiKey ?? process.env.ZIPY_API_KEY ?? '',
+        customerId: options.customerId ?? process.env.ZIPY_CUSTOMER_ID ?? '',
+        authKey: options.authKey ?? process.env.ZIPY_AUTH_KEY ?? '',
+        sourcemaps: {
+            android: {
+                release: options.sourcemapPathRelease ?? exports.DEFAULT_SOURCEMAP_PATHS.release,
+                debug: options.sourcemapPathDebug ?? exports.DEFAULT_SOURCEMAP_PATHS.debug,
+            },
+        },
+        bundle: {
+            android: {
+                release: options.bundlePathRelease ?? exports.DEFAULT_BUNDLE_PATH_RELEASE,
+            },
+        },
+    };
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf8');
+    return configPath;
+}
+/**
+ * Add apply from: zipy.gradle to android/app/build.gradle.
+ * Resolves zipy.gradle from global npm (npm root -g), with Windows fallback; falls back to projectDir/zipy.gradle.
+ */
+function patchGradle(projectRoot) {
+    const buildGradlePath = path.join(projectRoot, ANDROID_APP_BUILD_GRADLE);
+    if (!fs.existsSync(buildGradlePath)) {
+        throw new Error(`Android app build.gradle not found at ${ANDROID_APP_BUILD_GRADLE}. Is this a React Native project?`);
+    }
+    const content = fs.readFileSync(buildGradlePath, 'utf8');
+    if (content.includes(GRADLE_PATCH_MARKER)) {
+        return; // Already patched
+    }
+    const applyBlock = `
+// Apply Zipy Gradle script from current project node_modules (requires zipy-mobile-cli in package.json).
+apply from: new File(project.rootProject.projectDir.parentFile, "node_modules/zipy-mobile-cli/zipy.gradle")
+`;
+    fs.appendFileSync(buildGradlePath, applyBlock, 'utf8');
+}
+/**
+ * Add a Run Script Build Phase to the iOS app target that runs the Zipy iOS upload script on every build/run.
+ * Same role as zipy.gradle on Android. Patches ios/*.xcodeproj/project.pbxproj.
+ */
+function patchIosProject(projectRoot) {
+    const iosDir = path.join(projectRoot, IOS_XCODEPROJ_REL);
+    if (!fs.existsSync(iosDir))
+        return false;
+    const xcodeprojDir = fs.readdirSync(iosDir).find((f) => f.endsWith('.xcodeproj'));
+    if (!xcodeprojDir)
+        return false;
+    const pbxPath = path.join(iosDir, xcodeprojDir, 'project.pbxproj');
+    if (!fs.existsSync(pbxPath))
+        return false;
+    let content = fs.readFileSync(pbxPath, 'utf8');
+    if (content.includes(IOS_ZIPY_PHASE_MARKER))
+        return true; // Already patched
+    // 24-char hex ID (Xcode style)
+    const phaseId = Array.from({ length: 24 }, () => Math.floor(Math.random() * 16).toString(16)).join('').toUpperCase();
+    // Script: run zipy-ios-upload.sh from project root (SRCROOT = ios/)
+    const scriptBody = 'cd "${SRCROOT}/.." && [ -f node_modules/zipy-mobile-cli/zipy-ios-upload.sh ] && sh node_modules/zipy-mobile-cli/zipy-ios-upload.sh || true';
+    const escapedScript = scriptBody.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+    const phaseBlock = `
+		${phaseId} /* ZipySourcemapsUpload */ = {
+			isa = PBXShellScriptBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			inputPaths = (
+			);
+			name = "ZipySourcemapsUpload";
+			outputPaths = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+			shellPath = /bin/sh;
+			shellScript = "${escapedScript}\\n";
+		};
+`;
+    // Insert phase into PBXShellScriptBuildPhase section
+    const shellSectionEnd = '/* End PBXShellScriptBuildPhase section */';
+    const shellSectionBegin = '/* Begin PBXShellScriptBuildPhase section */';
+    if (content.includes(shellSectionEnd)) {
+        content = content.replace(shellSectionEnd, phaseBlock + '\t' + shellSectionEnd);
+    }
+    else if (content.includes(shellSectionBegin)) {
+        content = content.replace(shellSectionBegin, shellSectionBegin + phaseBlock);
+    }
+    else {
+        // No section yet: add before End PBXProject section
+        const endProject = '/* End PBXProject section */';
+        const newSection = `\n\t/* Begin PBXShellScriptBuildPhase section */\n${phaseBlock}\t/* End PBXShellScriptBuildPhase section */\n`;
+        content = content.replace(endProject, newSection + endProject);
+    }
+    // Add our phase ID to the first target's buildPhases (main app target; first buildPhases = ( in file)
+    const buildPhasesRegex = /(buildPhases = \(\s*\n)(\s+)([A-Fa-f0-9]{24})(.*)/;
+    const buildPhasesMatch = content.match(buildPhasesRegex);
+    if (!buildPhasesMatch)
+        return false;
+    const indent = buildPhasesMatch[2];
+    content = content.replace(buildPhasesRegex, `$1${indent}${phaseId} /* ZipySourcemapsUpload */,\n${indent}$3$4`);
+    fs.writeFileSync(pbxPath, content, 'utf8');
+    return true;
+}
+/** Resolve project root: directory that contains android/ and package.json (React Native). */
+function ensureReactNativeProject(projectRoot) {
+    const androidDir = path.join(projectRoot, 'android');
+    const packageJson = path.join(projectRoot, 'package.json');
+    if (!fs.existsSync(androidDir) || !fs.existsSync(packageJson)) {
+        throw new Error('Current directory does not look like a React Native project (missing android/ or package.json). Run this from the project root.');
+    }
+}
+async function initReactNative(projectRoot, options) {
+    projectRoot = path.resolve(projectRoot);
+    ensureReactNativeProject(projectRoot);
+    let sourcemapPathRelease = exports.DEFAULT_SOURCEMAP_PATHS.release;
+    let sourcemapPathDebug = exports.DEFAULT_SOURCEMAP_PATHS.debug;
+    let bundlePathRelease = exports.DEFAULT_BUNDLE_PATH_RELEASE;
+    let apiKey = options?.apiKey ?? process.env.ZIPY_API_KEY ?? '';
+    let customerId = options?.customerId ?? process.env.ZIPY_CUSTOMER_ID ?? '';
+    let authKey = options?.authKey ?? process.env.ZIPY_AUTH_KEY ?? '';
+    if (isInteractive()) {
+        console.log('Zipy Mobile CLI — React Native setup\n');
+        if (!apiKey)
+            apiKey = await prompt('API key (e.g. abc123key)', '');
+        if (!customerId)
+            customerId = await prompt('Customer ID (e.g. 99)', '');
+        if (!authKey)
+            authKey = await prompt('Auth key (optional)', '');
+        console.log('\nDefault paths (relative to project root):');
+        console.log('  sourcemaps.android.release:', sourcemapPathRelease);
+        console.log('  sourcemaps.android.debug: ', sourcemapPathDebug);
+        console.log('  bundle.android.release:   ', bundlePathRelease);
+        const useDefaults = await prompt('Use these paths? (Y/n)', 'Y');
+        if (useDefaults && useDefaults.toLowerCase() === 'n') {
+            sourcemapPathRelease = await prompt('Path to release sourcemap', sourcemapPathRelease);
+            sourcemapPathDebug = await prompt('Path to debug sourcemap', sourcemapPathDebug);
+            bundlePathRelease = await prompt('Path to release bundle', bundlePathRelease);
+        }
+    }
+    else {
+        sourcemapPathRelease = process.env.ZIPY_SOURCEMAP_RELEASE ?? sourcemapPathRelease;
+        sourcemapPathDebug = process.env.ZIPY_SOURCEMAP_DEBUG ?? sourcemapPathDebug;
+        bundlePathRelease = process.env.ZIPY_BUNDLE_RELEASE ?? bundlePathRelease;
+    }
+    const configPath = writeConfig(projectRoot, {
+        sourcemapPathRelease,
+        sourcemapPathDebug,
+        bundlePathRelease,
+        apiKey,
+        customerId,
+        authKey,
+    });
+    console.log('Created config:', configPath);
+    patchGradle(projectRoot);
+    console.log('Patched', ANDROID_APP_BUILD_GRADLE, '— sourcemaps will upload after assembleRelease (debug not hooked).');
+    const iosPatched = patchIosProject(projectRoot);
+    if (iosPatched) {
+        console.log('Patched iOS project — added "ZipySourcemapsUpload" Run Script phase (runs on every build/run).');
+    }
+    console.log('\nDone. Next: run ./gradlew assembleRelease from android/ (or from root with -p android); for iOS, build/run from Xcode or react-native run-ios.');
+}

package/dist/types.d.ts

@@ -0,0 +1,34 @@
+/** Config file name in project root. */
+export declare const CONFIG_FILENAME = ".zipy-mobile.json";
+/**
+ * Config file (.zipy-mobile.json) shape used by init and upload-sourcemaps.
+ * Upload API: POST {uploadBaseUrl}/sourcemaps-mobile-service/v1/upload/{apiKey}/{customerId} (multipart form).
+ */
+export interface ZipyConfig {
+    projectRoot?: string;
+    /** Framework name sent as form field (e.g. react-native, flutter). */
+    framework: string;
+    /** Base URL for upload API (e.g. http://localhost:8900). */
+    uploadBaseUrl: string;
+    /** API key; used in URL path. */
+    apiKey: string;
+    /** Customer ID; used in URL path. */
+    customerId: string;
+    /** Optional auth key; sent in upload payload as form field "key". */
+    authKey?: string;
+    sourcemaps: {
+        android: {
+            release: string;
+            debug: string;
+        };
+    };
+    bundle?: {
+        android: {
+            release: string;
+            debug?: string;
+        };
+    };
+    /** Ignored at runtime; explains how to edit paths (JSON does not support comments). */
+    _comment?: string;
+}
+export type BuildVariant = 'release' | 'debug';

package/dist/types.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONFIG_FILENAME = void 0;
+/** Config file name in project root. */
+exports.CONFIG_FILENAME = '.zipy-mobile.json';

package/dist/upload-sourcemaps.d.ts

@@ -0,0 +1,5 @@
+import type { ZipyConfig, BuildVariant } from './types';
+export declare function loadConfig(projectRoot: string): ZipyConfig;
+export declare function getSourcemapPath(projectRoot: string, variant: BuildVariant, config: ZipyConfig): string;
+export declare function getBundlePath(projectRoot: string, variant: BuildVariant, config: ZipyConfig): string | null;
+export declare function uploadSourcemaps(projectRoot: string, variant: BuildVariant): Promise<void>;

package/dist/upload-sourcemaps.js

@@ -0,0 +1,284 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfig = loadConfig;
+exports.getSourcemapPath = getSourcemapPath;
+exports.getBundlePath = getBundlePath;
+exports.uploadSourcemaps = uploadSourcemaps;
+/**
+ * Upload sourcemaps (and bundle) via multipart form to the Zipy upload API.
+ * POST {uploadBaseUrl}/sourcemaps-mobile-service/v1/upload/{apiKey}/{customerId}
+ * Form: key (auth), bundle_id, release_version, framework, platform, files (sourcemap + optional bundle).
+ */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const https = __importStar(require("https"));
+const http = __importStar(require("http"));
+const types_1 = require("./types");
+/** Upload path (no leading slash on uploadBaseUrl). Single source of truth for request and logs. */
+const UPLOAD_PATH = '/sourcemaps-mobile-service/v1/upload';
+function loadConfig(projectRoot) {
+    const configPath = path.join(projectRoot, types_1.CONFIG_FILENAME);
+    if (!fs.existsSync(configPath)) {
+        throw new Error(`Config not found: ${configPath}. Run zipy-mobile-cli -i react-native first.`);
+    }
+    const raw = fs.readFileSync(configPath, 'utf8');
+    try {
+        const parsedValue = JSON.parse(raw);
+        if (parsedValue == null || typeof parsedValue !== 'object') {
+            throw new Error(`${types_1.CONFIG_FILENAME} must contain a JSON object`);
+        }
+        const parsed = parsedValue;
+        if (!parsed.uploadBaseUrl && parsed.uploadUrl) {
+            parsed.uploadBaseUrl = parsed.uploadUrl;
+        }
+        return parsed;
+    }
+    catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        throw new Error(`Invalid ${types_1.CONFIG_FILENAME}: ${message}`);
+    }
+}
+function getSourcemapPath(projectRoot, variant, config) {
+    const relativePath = config.sourcemaps?.android?.[variant];
+    if (!relativePath) {
+        throw new Error(`No sourcemap path configured for android variant "${variant}". Check .zipy-mobile.json "sourcemaps.android".`);
+    }
+    const absolutePath = path.resolve(projectRoot, relativePath);
+    if (!fs.existsSync(absolutePath)) {
+        throw new Error(`Sourcemap file not found: ${absolutePath}. Build may not have generated it yet.`);
+    }
+    return absolutePath;
+}
+function getBundlePath(projectRoot, variant, config) {
+    const relativePath = config.bundle?.android?.[variant];
+    if (!relativePath)
+        return null;
+    const absolutePath = path.resolve(projectRoot, relativePath);
+    if (!fs.existsSync(absolutePath))
+        return null;
+    return absolutePath;
+}
+/**
+ * Extract Bundle ID and Zipy bundle id from source map JSON.
+ * Zipy bundle id is our per-build UUID, stored under zipyBundleId/zipy_bundle_id (and legacy debugId keys)
+ * so we can reliably correlate uploads even when the app bundle id stays the same.
+ */
+function extractIdsFromSourcemap(sourcemapPath) {
+    const out = {};
+    try {
+        const raw = fs.readFileSync(sourcemapPath, 'utf8');
+        const parsedValue = JSON.parse(raw);
+        if (parsedValue == null || typeof parsedValue !== 'object') {
+            return out;
+        }
+        const map = parsedValue;
+        const meta = (map.x_metadata ?? map.metadata);
+        if (meta && typeof meta === 'object') {
+            const bid = meta.bundleId ?? meta.bundle_id;
+            // Prefer new Zipy bundle id keys, but still read legacy debugId keys for older builds.
+            const did = meta.zipyBundleId ??
+                meta.zipy_bundle_id ??
+                meta.zipyDebugId ??
+                meta.zipy_debug_id ??
+                meta.debugId ??
+                meta.debug_id;
+            if (typeof bid === 'string')
+                out.bundleId = bid;
+            if (typeof did === 'string')
+                out.debugId = did;
+        }
+        const m = map;
+        if (!out.debugId) {
+            out.debugId =
+                m.zipyBundleId ??
+                    m.zipy_bundle_id ??
+                    m.zipyDebugId ??
+                    m.zipy_debug_id ??
+                    m.debugId;
+        }
+        if (!out.bundleId && typeof m.bundleId === 'string')
+            out.bundleId = m.bundleId;
+    }
+    catch (_) {
+        /* ignore */
+    }
+    return out;
+}
+/**
+ * Packager source map path (Metro writes this first; it contains the Debug ID before Hermes/Sentry compose).
+ * Derived from the final map path: generated/sourcemaps -> intermediates/sourcemaps, and .map -> .packager.map
+ */
+function getPackagerSourcemapPath(finalSourcemapPath) {
+    const normalized = finalSourcemapPath.replace(/\\/g, '/');
+    if (normalized.includes('/generated/sourcemaps/')) {
+        return normalized
+            .replace('/generated/sourcemaps/', '/intermediates/sourcemaps/')
+            .replace(/\.map$/, '.packager.map');
+    }
+    const dir = path.dirname(finalSourcemapPath);
+    const base = path.basename(finalSourcemapPath, '.map');
+    return path.join(dir, base + '.packager.map');
+}
+/**
+ * Get Zipy bundle id from our own build output: try final source map first, then packager map (Metro writes it there).
+ * This is our primary way to discover the Zipy bundle id when Gradle has already injected it.
+ */
+function getZipyBundleIdFromBuild(sourcemapPath) {
+    let ids = extractIdsFromSourcemap(sourcemapPath);
+    if (ids.debugId)
+        return ids.debugId;
+    const packagerPath = getPackagerSourcemapPath(sourcemapPath);
+    if (fs.existsSync(packagerPath)) {
+        ids = extractIdsFromSourcemap(packagerPath);
+        if (ids.debugId)
+            return ids.debugId;
+    }
+    return undefined;
+}
+/**
+ * Build multipart/form-data body for upload API.
+ * Matches: -F "key=..." -F "bundle_id=..." -F "release_version=..." -F "framework=..." -F "platform=..." -F "files=@..."
+ */
+function buildMultipartBody(fields, filePaths) {
+    const boundary = '----ZipyMobile' + Math.random().toString(36).slice(2) + Date.now();
+    const crlf = '\r\n';
+    const parts = [];
+    const append = (s) => parts.push(Buffer.from(s, 'utf8'));
+    const appendField = (name, value) => {
+        append(`--${boundary}${crlf}`);
+        append(`Content-Disposition: form-data; name="${name}"${crlf}${crlf}`);
+        append(`${value}${crlf}`);
+    };
+    if (fields.key)
+        appendField('key', fields.key);
+    appendField('bundle_id', fields.bundle_id);
+    appendField('release_version', fields.release_version);
+    appendField('framework', fields.framework);
+    appendField('platform', fields.platform);
+    for (const f of filePaths) {
+        append(`--${boundary}${crlf}`);
+        append(`Content-Disposition: form-data; name="${f.fieldName}"; filename="${f.filename}"${crlf}`);
+        append(`Content-Type: application/octet-stream${crlf}${crlf}`);
+        parts.push(fs.readFileSync(f.path));
+        append(crlf);
+    }
+    append(`--${boundary}--${crlf}`);
+    return { body: Buffer.concat(parts), boundary };
+}
+/**
+ * POST multipart form to uploadBaseUrl + UPLOAD_PATH + apiKey/customerId.
+ */
+function uploadMultipart(uploadBaseUrl, apiKey, customerId, uploadPath, fields, filePaths) {
+    return new Promise((resolve, reject) => {
+        if (!uploadBaseUrl || !apiKey || !customerId) {
+            console.warn('zipy-mobile-cli: uploadBaseUrl, apiKey and customerId are required in .zipy-mobile.json. Skipping upload.');
+            return resolve();
+        }
+        const pathname = `${uploadPath}/${encodeURIComponent(apiKey)}/${encodeURIComponent(customerId)}`;
+        const url = new URL(uploadBaseUrl.startsWith('http') ? uploadBaseUrl : 'http://' + uploadBaseUrl);
+        const isHttps = url.protocol === 'https:';
+        const mod = isHttps ? https : http;
+        const portNum = url.port ? parseInt(url.port, 10) : (isHttps ? 443 : 80);
+        const { body, boundary } = buildMultipartBody(fields, filePaths);
+        const options = {
+            hostname: url.hostname,
+            port: portNum,
+            path: pathname + (url.search || ''),
+            method: 'POST',
+            headers: {
+                'Content-Type': `multipart/form-data; boundary=${boundary}`,
+                'Content-Length': String(body.length),
+            },
+        };
+        const req = mod.request(options, (res) => {
+            let data = '';
+            res.on('data', (ch) => (data += ch));
+            res.on('end', () => {
+                const status = res.statusCode ?? 0;
+                if (status >= 200 && status < 300)
+                    resolve();
+                else
+                    reject(new Error(`Upload failed: ${status} ${data || res.statusMessage || ''}`));
+            });
+        });
+        req.on('error', reject);
+        req.write(body);
+        req.end();
+    });
+}
+async function uploadSourcemaps(projectRoot, variant) {
+    const config = loadConfig(projectRoot);
+    const uploadBaseUrl = (config.uploadBaseUrl ?? process.env.ZIPY_UPLOAD_BASE_URL ?? '').replace(/\/$/, '');
+    const apiKey = config.apiKey ?? process.env.ZIPY_API_KEY ?? '';
+    const customerId = config.customerId ?? process.env.ZIPY_CUSTOMER_ID ?? '';
+    const authKey = config.authKey ?? process.env.ZIPY_AUTH_KEY ?? '';
+    const framework = config.framework ?? process.env.ZIPY_FRAMEWORK ?? 'react-native';
+    const platform = process.env.ZIPY_PLATFORM ?? 'android';
+    const releaseName = process.env.ZIPY_RELEASE ?? process.env.ZIPY_RELEASE_VERSION ?? '';
+    const sourcemapPath = getSourcemapPath(projectRoot, variant, config);
+    const ids = extractIdsFromSourcemap(sourcemapPath);
+    const zipyBundleIdFromGradle = process.env.ZIPY_DEBUG_ID;
+    // Prefer the value coming from Gradle (sentinel file), then what we can read from the map(s).
+    const zipyBundleId = zipyBundleIdFromGradle ?? ids.debugId;
+    if (ids.bundleId)
+        console.log('> Bundle ID from map (if present):', ids.bundleId);
+    if (zipyBundleId)
+        console.log('> Zipy bundle id for the build:', zipyBundleId);
+    const filePaths = [
+        { path: sourcemapPath, fieldName: 'files', filename: path.basename(sourcemapPath) },
+    ];
+    const bundlePath = getBundlePath(projectRoot, variant, config);
+    if (bundlePath)
+        filePaths.push({ path: bundlePath, fieldName: 'files', filename: path.basename(bundlePath) });
+    // Form fields matching API: key (auth), bundle_id, release_version, framework, platform; then files
+    // We send the Zipy bundle id as bundle_id so errors can be grouped per build on the backend.
+    // Older builds used debugId naming, but the semantics are the same (per-build UUID), so we just
+    // standardize the name here while still reading legacy keys above for compatibility.
+    const fields = {
+        ...(authKey ? { key: authKey } : {}),
+        bundle_id: zipyBundleId ?? process.env.ZIPY_APP_ID ?? process.env.ZIPY_BUNDLE_ID ?? 'unknown',
+        release_version: releaseName || '1.0.0',
+        framework,
+        platform,
+    };
+    const baseUrl = uploadBaseUrl.replace(/\/$/, '');
+    const fullUrl = `${baseUrl}${UPLOAD_PATH}/${encodeURIComponent(apiKey)}/${encodeURIComponent(customerId)}`;
+    console.log('zipy-mobile-cli: Request URL:', fullUrl);
+    console.log('zipy-mobile-cli: Form fields:', JSON.stringify(fields, null, 2));
+    console.log('zipy-mobile-cli: Files:', filePaths.map((f) => ({ path: f.path, filename: f.filename })));
+    await uploadMultipart(uploadBaseUrl, apiKey, customerId, UPLOAD_PATH, fields, filePaths);
+    console.log('zipy-mobile-cli: Upload done.');
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "zipy-mobile-cli",
+  "version": "1.0.0",
+  "description": "CLI to integrate Zipy with mobile apps — uploads sourcemaps when building (e.g. React Native Android).",
+  "main": "dist/cli.js",
+  "bin": {
+    "zipy-mobile-cli": "bin/zipy-mobile-cli.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepare": "npm run build",
+    "prepublishOnly": "npm run build",
+    "test": "node -e \"require('./dist/cli').run(['--help'])\""
+  },
+  "keywords": [
+    "zipy",
+    "sourcemaps",
+    "react-native",
+    "android",
+    "cli"
+  ],
+  "author": "",
+  "license": "ISC",
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "files": [
+    "bin",
+    "dist",
+    "zipy.gradle",
+    "zipy-ios-upload.sh"
+  ],
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "typescript": "^5.3.0"
+  },
+  "dependencies": {
+    "undici-types": "^6.21.0"
+  },
+  "types": "./dist/cli.d.ts"
+}

package/zipy-ios-upload.sh

@@ -0,0 +1,11 @@
+#!/bin/sh
+# Zipy iOS upload hook — runs in Xcode Run Script Build Phase on every build/run.
+# Same role as zipy.gradle on Android: run Zipy task after bundle.
+# For now just logs; later can call: cd "$PROJECT_ROOT" && npx zipy-mobile-cli upload-sourcemaps release
+set -e
+echo "[Zipy] iOS upload task ran (ZipySourcemapsUpload)"
+# Optional: skip when env is set (mirror Android ZIPY_DISABLE_AUTO_UPLOAD)
+if [ -n "$ZIPY_DISABLE_AUTO_UPLOAD" ]; then
+  echo "[Zipy] Skipped (ZIPY_DISABLE_AUTO_UPLOAD is set)"
+  exit 0
+fi

package/zipy.gradle

@@ -0,0 +1,215 @@
+/**
+ * Zipy Mobile CLI — Gradle integration (Sentry-style).
+ * Flow: Generate bundle id first -> write it into debugid.cjs (before Metro) -> Metro bundles -> inject id into source maps -> upload.
+ */
+import org.apache.tools.ant.taskdefs.condition.Os
+import java.util.UUID
+
+def zipyProjectRoot = project.rootProject.projectDir.parentFile
+
+project.ext.shouldZipyAutoUpload = { ->
+  return System.getenv('ZIPY_DISABLE_AUTO_UPLOAD') != 'true'
+}
+
+plugins.withId('com.android.application') {
+  try {
+    project.android.buildFeatures.buildConfig = true
+  } catch (Throwable ignored) {}
+
+  try {
+    project.android.applicationVariants.all { variant ->
+      if (variant.buildType.name.equalsIgnoreCase("debug")) return
+      variant.buildConfigField "String", "ZIPY_BUNDLE_ID", "\"${variant.applicationId}\""
+    }
+  } catch (Throwable t) {
+    logger.warn("Zipy: could not add BuildConfig.ZIPY_BUNDLE_ID: ${t.message}")
+  }
+
+  def androidComponents = extensions.getByName("androidComponents")
+  androidComponents.onVariants(androidComponents.selector().all()) { v ->
+    if (v.name.toLowerCase().contains("debug")) return
+
+    def appId = v.applicationId.get()
+
+    def bundleTasks = tasks.findAll { task ->
+      (task.name.startsWith("createBundle") || task.name.startsWith("bundle")) &&
+      task.name.endsWith("JsAndAssets") &&
+      !task.name.contains("Debug") &&
+      task.enabled
+    }
+    bundleTasks.each { bundleTask ->
+      def reactRoot = zipyProjectRoot
+      try {
+        def props = bundleTask.getProperties()
+        if (props.get("workingDir") != null) {
+          reactRoot = props.get("workingDir") as File
+        } else if (props.get("root") != null) {
+          reactRoot = props.get("root").get() as File
+        }
+      } catch (Throwable ignored) {}
+      def _reactRoot = reactRoot
+
+      def output = v.outputs.isEmpty() ? null : v.outputs.first()
+      if (output == null) return
+      def versionCode = output.versionCode.getOrElse(0)
+      def versionName = output.versionName.getOrElse("1.0")
+      def releaseName = "${appId}@${versionName}+${versionCode}"
+      def buildId = System.getenv('ZIPY_BUILD_ID') ?: "${releaseName}_${versionCode}"
+      def zipyInjectTaskName = "${bundleTask.name}_ZipyInjectDebugId_${releaseName}_${versionCode}"
+      def zipyUploadTaskName = "${bundleTask.name}_ZipySourcemapsUpload_${releaseName}_${versionCode}"
+      def zipyCleanupTaskName = "${bundleTask.name}_ZipyFullCleanup_${releaseName}_${versionCode}"
+
+      try { tasks.named(zipyUploadTaskName); return } catch (Exception e) {}
+
+      def configFile = new File(_reactRoot, ".zipy-mobile.json")
+      def releasePath = "android/app/build/generated/sourcemaps/react/release/index.android.bundle.map"
+      if (configFile.exists()) {
+        try {
+          def config = new groovy.json.JsonSlurper().parse(configFile)
+          if (config.sourcemaps?.android?.release) releasePath = config.sourcemaps.android.release
+        } catch (Throwable ignored) {}
+      }
+      def mapFile = new File(_reactRoot, releasePath.replace('\\\\', '/'))
+      def zipySentinelFile = project.file("${project.buildDir}/zipy_injected_${v.name}.txt")
+
+      // Generate bundle id first, then write it into debugid.cjs so Metro inlines it when creating the bundle.
+      bundleTask.doFirst {
+        def zipyBundleId = UUID.randomUUID().toString()
+        zipySentinelFile.text = zipyBundleId
+        def nodeModulesRoot = _reactRoot
+        def debugIdFiles = [
+          new File(nodeModulesRoot, "node_modules/zipy-react-native/lib/commonjs/utils/debugid.cjs"),
+          new File(nodeModulesRoot, "node_modules/zipyai-react-native/lib/commonjs/utils/debugid.cjs")
+        ]
+        debugIdFiles.each { File f ->
+          if (f.exists()) {
+            try {
+              def content = "\"use strict\";Object.defineProperty(exports,\"__esModule\",{value:!0}),exports.BUNDLE_ID=void 0;const BUNDLE_ID=exports.BUNDLE_ID=\"${zipyBundleId}\";"
+              f.text = content
+              logger.lifecycle("Zipy: wrote bundle id into ${f.name} (before Metro)")
+            } catch (Throwable e) {
+              logger.warn("Zipy: could not write bundle id into ${f.absolutePath}: ${e.message}")
+            }
+          } else {
+            logger.info("Zipy: debugid.cjs not found at ${f.absolutePath}, skipping")
+          }
+        }
+        logger.lifecycle("Zipy: generated bundle id and set in debugid.cjs; Metro will use it when bundling")
+      }
+
+      def zipyInjectTask = tasks.register(zipyInjectTaskName) { t ->
+        t.dependsOn(bundleTask)
+        t.inputs.file(mapFile).optional(true)
+        t.inputs.file(zipySentinelFile).optional(true)
+        t.outputs.file(mapFile).optional(true)
+        t.doLast {
+          if (!zipySentinelFile.exists()) {
+            logger.warn("Zipy: sentinel not found (expected from bundle task doFirst)")
+            return
+          }
+          def zipyBundleId = zipySentinelFile.text.trim()
+          if (!zipyBundleId) return
+          if (!mapFile.exists()) {
+            logger.warn("Zipy: source map not found at ${mapFile.absolutePath}, skipping inject")
+            return
+          }
+          try {
+            def json = new groovy.json.JsonSlurper().parse(mapFile)
+            if (json.x_metadata == null) json.x_metadata = [:]
+            // Store Zipy bundle id under Zipy-specific keys and generic bundle keys for compatibility.
+            json.x_metadata.zipyBundleId = zipyBundleId
+            json.x_metadata.zipy_bundle_id = zipyBundleId
+            json.x_metadata.bundleId = zipyBundleId
+            json.x_metadata.bundle_id = zipyBundleId
+            if (json.metadata == null) json.metadata = [:]
+            json.metadata.zipyBundleId = zipyBundleId
+            json.metadata.zipy_bundle_id = zipyBundleId
+            json.metadata.bundleId = zipyBundleId
+            json.metadata.bundle_id = zipyBundleId
+            json.zipyBundleId = zipyBundleId
+            json.zipy_bundle_id = zipyBundleId
+            mapFile.text = groovy.json.JsonOutput.toJson(json)
+            logger.lifecycle("Zipy: injected Zipy bundle id into ${mapFile.name}")
+          } catch (Throwable e) {
+            logger.warn("Zipy: could not inject into source map: ${e.message}")
+          }
+          def packagerPath = mapFile.absolutePath.replace("/generated/sourcemaps/", "/intermediates/sourcemaps/").replaceAll(/\\.map$/, ".packager.map")
+          def packagerFile = new File(packagerPath)
+          if (packagerFile.exists()) {
+            try {
+              def pjson = new groovy.json.JsonSlurper().parse(packagerFile)
+              if (pjson.x_metadata == null) pjson.x_metadata = [:]
+              // Mirror the same Zipy bundle id into the packager map so both maps stay in sync.
+              pjson.x_metadata.zipyBundleId = zipyBundleId
+              pjson.x_metadata.zipy_bundle_id = zipyBundleId
+              pjson.x_metadata.bundleId = zipyBundleId
+              pjson.x_metadata.bundle_id = zipyBundleId
+              if (pjson.metadata == null) pjson.metadata = [:]
+              pjson.metadata.zipyBundleId = zipyBundleId
+              pjson.metadata.zipy_bundle_id = zipyBundleId
+              pjson.metadata.bundleId = zipyBundleId
+              pjson.metadata.bundle_id = zipyBundleId
+              pjson.zipyBundleId = zipyBundleId
+              pjson.zipy_bundle_id = zipyBundleId
+              packagerFile.text = groovy.json.JsonOutput.toJson(pjson)
+            } catch (Throwable ignored) {}
+          }
+        }
+      }
+
+      def zipyUploadTask = tasks.register(zipyUploadTaskName, Exec) {
+        onlyIf { shouldZipyAutoUpload() }
+        dependsOn(zipyInjectTask)
+        description = "upload sourcemaps and bundle to Zipy"
+        group = "zipy"
+        workingDir _reactRoot
+        ignoreExitValue = true
+        environment("ZIPY_PLATFORM", "android")
+        environment("ZIPY_APP_ID", appId)
+        environment("ZIPY_RELEASE_VERSION", releaseName)
+        environment("ZIPY_BUILD_ID", buildId)
+        // When inject task is skipped (same map rebuild), Gradle marks it UP-TO-DATE. The map gets
+        // overwritten by bundleTask with raw Metro output (no debugId). Pass ZIPY_DEBUG_ID from
+        // zipySentinelFile so the CLI uses it instead of falling back to bundle_id (app id).
+        doFirst {
+          if (zipySentinelFile.exists()) {
+            def sentinelId = zipySentinelFile.text.trim()
+            if (sentinelId) {
+              environment("ZIPY_DEBUG_ID", sentinelId)
+              logger.lifecycle("Zipy: passing ZIPY_DEBUG_ID from sentinel for upload")
+            }
+          }
+        }
+        commandLine(Os.isFamily(Os.FAMILY_WINDOWS) ? ['cmd', '/c', 'npx', 'zipy-mobile-cli', 'upload-sourcemaps', 'release'] : ['npx', 'zipy-mobile-cli', 'upload-sourcemaps', 'release'])
+      }
+
+      def zipyCleanupTask = tasks.register(zipyCleanupTaskName) {
+        onlyIf { shouldZipyAutoUpload() }
+        description = "Zipy post-upload cleanup; resets debugid.cjs to empty after build"
+        group = "zipy"
+        doLast {
+          def nodeModulesRoot = _reactRoot
+          def debugIdFiles = [
+            new File(nodeModulesRoot, "node_modules/zipy-react-native/lib/commonjs/utils/debugid.cjs"),
+            new File(nodeModulesRoot, "node_modules/zipyai-react-native/lib/commonjs/utils/debugid.cjs")
+          ]
+          def emptyContent = "\"use strict\";Object.defineProperty(exports,\"__esModule\",{value:!0}),exports.BUNDLE_ID=void 0;const BUNDLE_ID=exports.BUNDLE_ID=\"\";"
+          debugIdFiles.each { File f ->
+            if (f.exists()) {
+              try {
+                f.text = emptyContent
+                logger.lifecycle("Zipy: cleared debugid.cjs (${f.name}) after build")
+              } catch (Throwable e) {
+                logger.warn("Zipy: could not clear ${f.absolutePath}: ${e.message}")
+              }
+            }
+          }
+          logger.lifecycle("Zipy upload done for ${releaseName}")
+        }
+      }
+
+      bundleTask.configure { it.finalizedBy(zipyUploadTask) }
+      zipyUploadTask.configure { it.finalizedBy(zipyCleanupTask) }
+    }
+  }
+}