zipy-mobile-cli 1.0.0 → 1.0.2

package/README.md

@@ -1,10 +1,14 @@
 # zipy-mobile-cli
 
+<<<<<<< HEAD
+CLI to integrate [Zipy](https://zipy.ai) with mobile apps. When you build your app, it uploads Android sourcemaps/bundles and iOS dSYMs so Zipy can symbolicate errors.
+=======
 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.
+>>>>>>> origin/main
 
 ## 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:
+**Recommended (for Gradle apply-from):** 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
@@ -42,9 +46,10 @@ This will:
   - 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.
+- **Add an `apply from:` line to `android/app/build.gradle`** 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.
+- **Add an iOS Run Script Build Phase** named `ZipySourcemapsUpload` that detects the generated `.dSYM` from Xcode build variables and uploads it automatically on each build/run.
 
-So whenever a new build is made, sourcemaps are uploaded automatically; you don’t need to run a separate command.
+So whenever a new build is made, Android sourcemaps or iOS dSYMs are uploaded automatically; you don’t need to run a separate command.
 
 ### 2. Configure upload (from init)
 
@@ -96,11 +101,14 @@ Example (created by init; API key and customer ID are set at init):
     "android": {
       "release": "android/app/build/generated/assets/react/release/index.android.bundle"
     }
+  },
+  "dsym": {
+    "ios": {}
   }
 }
 ```
 
-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).
+Upload is sent as: `POST {uploadBaseUrl}/sourcemaps-mobile-service//v1/upload/{apiKey}/{customerId}` with form fields `bundle_id`, `release_version`, `framework`, `platform`, and `files`. Android uploads the sourcemap plus bundle when present; iOS uploads the build dSYM and archives the `.dSYM` bundle to `.zip` automatically before sending it.
 
 ## Manual upload
 
@@ -113,10 +121,17 @@ zipy-mobile-cli upload-sourcemaps debug
 
 Run this from the project root (or any directory under it that has `.zipy-mobile.json` above it).
 
+For manual iOS uploads, pass the dSYM path and platform explicitly:
+
+```bash
+ZIPY_PLATFORM=ios ZIPY_DSYM_PATH=/path/to/MyApp.app.dSYM npx zipy-mobile-cli upload-sourcemaps release
+```
+
 ## Requirements
 
 - Node.js >= 14
 - React Native project with Android (`android/app/build.gradle`).
+- macOS/Xcode for iOS dSYM auto-upload (`ditto` is used to archive the `.dSYM` bundle before upload).
 - `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)

package/dist/cli.d.ts

@@ -1,3 +1,4 @@
+/** Route CLI arguments to init, upload, or help flows. */
 export declare function run(argv: string[]): void;
 /**
  * Find directory containing .zipy-mobile.json (walk up from cwd).

package/dist/cli.js

@@ -44,6 +44,8 @@ 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");
+const LOG_PREFIX = '[zipy]';
+/** Route CLI arguments to init, upload, or help flows. */
 function run(argv) {
     const args = argv.slice();
     let command = null;
@@ -66,12 +68,12 @@ function run(argv) {
     }
     if (command === 'init') {
         if (platform !== 'react-native') {
-            console.error('zipy-mobile-cli: Only "react-native" is supported. Use: zipy-mobile-cli -i react-native');
+            console.error(`${LOG_PREFIX} 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);
+            console.error(LOG_PREFIX, err.message || err);
             process.exit(1);
         });
         return;
@@ -79,16 +81,16 @@ function run(argv) {
     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>');
+            console.error(`${LOG_PREFIX} 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.');
+            console.error(`${LOG_PREFIX} 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);
+            console.error(LOG_PREFIX, err.message || err);
             process.exit(1);
         });
         return;
@@ -140,9 +142,10 @@ function findProjectRoot(cwd, configName) {
     }
     return null;
 }
+/** Print the top-level CLI usage and option summary. */
 function printHelp() {
     console.log(`
-zipy-mobile-cli — Zipy mobile integration (sourcemap uploads on build)
+zipy-mobile-cli — Zipy mobile integration (Android sourcemap uploads and iOS archive bundle/map uploads)
 
 Usage:
   zipy-mobile-cli -i react-native [--apikey KEY] [--customerId ID] [--authkey KEY]

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

@@ -1,10 +1,16 @@
-/** Default paths: outputs of react/release (same task Sentry hooks into). */
+/** Default paths: outputs of the standard react/release bundle task. */
 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";
+/** Stable iOS Zipy output folder shared by the RN bundle phase and later upload phase. */
+export declare const DEFAULT_IOS_OUTPUT_DIR = "ios/build/zipy/Sourcemaps";
+/** Default iOS release bundle path: written by the patched RN Xcode bundle phase. */
+export declare const DEFAULT_IOS_BUNDLE_PATH_RELEASE = "ios/build/zipy/Sourcemaps/main.jsbundle";
+/** Default iOS release sourcemap path: emitted by the patched RN Xcode bundle phase. */
+export declare const DEFAULT_IOS_SOURCEMAP_PATH_RELEASE = "ios/build/zipy/Sourcemaps/main.jsbundle.map";
 /** Fixed upload API base URL (not prompted). */
 export declare const FIXED_UPLOAD_BASE_URL = "https://app.zipy.ai/api";
 export interface InitOptions {
@@ -25,8 +31,10 @@ export declare function writeConfig(projectRoot: string, options: InitOptions):
  */
 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.
+ * Add Run Script Build Phases to the iOS app target for Zipy's archive upload flow.
+ * The phase stays attached to the app target, but the script itself uploads only during archive/install actions.
+ * We also patch the RN bundle phase so main.jsbundle.map is emitted to a stable ios/build/zipy/... path.
  */
 export declare function patchIosProject(projectRoot: string): boolean;
+/** Create config and patch Android/iOS build hooks for a React Native app. */
 export declare function initReactNative(projectRoot: string, options?: InitOptions): Promise<void>;

package/dist/init-react-native.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FIXED_UPLOAD_BASE_URL = exports.DEFAULT_BUNDLE_PATH_RELEASE = exports.DEFAULT_SOURCEMAP_PATHS = void 0;
+exports.FIXED_UPLOAD_BASE_URL = exports.DEFAULT_IOS_SOURCEMAP_PATH_RELEASE = exports.DEFAULT_IOS_BUNDLE_PATH_RELEASE = exports.DEFAULT_IOS_OUTPUT_DIR = exports.DEFAULT_BUNDLE_PATH_RELEASE = exports.DEFAULT_SOURCEMAP_PATHS = void 0;
 exports.writeConfig = writeConfig;
 exports.patchGradle = patchGradle;
 exports.patchIosProject = patchIosProject;
@@ -52,15 +52,103 @@ const IOS_XCODEPROJ_REL = 'ios';
 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). */
+/** Pre-bundle iOS phase that prepares the per-build Zipy bundle id before RN bundling starts. */
+const IOS_ZIPY_PREPARE_MARKER = 'ZipyBundleIdPrepare';
+/** Marker injected into the RN Xcode bundle phase so init can safely re-run without duplicating exports. */
+const IOS_RN_SOURCEMAP_PATCH_MARKER = 'ZIPY_IOS_SOURCEMAP_PHASE=1';
+/** Default paths: outputs of the standard react/release bundle task. */
 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';
+/** Stable iOS Zipy output folder shared by the RN bundle phase and later upload phase. */
+exports.DEFAULT_IOS_OUTPUT_DIR = 'ios/build/zipy/Sourcemaps';
+/** Default iOS release bundle path: written by the patched RN Xcode bundle phase. */
+exports.DEFAULT_IOS_BUNDLE_PATH_RELEASE = `${exports.DEFAULT_IOS_OUTPUT_DIR}/main.jsbundle`;
+/** Default iOS release sourcemap path: emitted by the patched RN Xcode bundle phase. */
+exports.DEFAULT_IOS_SOURCEMAP_PATH_RELEASE = `${exports.DEFAULT_IOS_OUTPUT_DIR}/main.jsbundle.map`;
 /** Fixed upload API base URL (not prompted). */
 exports.FIXED_UPLOAD_BASE_URL = 'https://app.zipy.ai/api';
+const LOG_PREFIX = '[zipy]';
+/** Print `[zipy]`-prefixed setup logs. */
+function logInfo(...args) {
+    console.log(LOG_PREFIX, ...args);
+}
+/** Find an existing PBX phase reference line by marker name. */
+function getPhaseReferenceLine(content, marker) {
+    const phaseMatch = content.match(new RegExp(`^\\s*([A-Fa-f0-9]{24} /\\* ${marker} \\*/,)\\s*$`, 'm'));
+    return phaseMatch ? phaseMatch[1] : null;
+}
+/** Rewrite the first native target's build phase list while preserving indentation. */
+function updateFirstTargetBuildPhases(content, updateLines) {
+    const buildPhasesRegex = /(buildPhases = \(\s*\n)([\s\S]*?)(\s*\);)/;
+    const match = content.match(buildPhasesRegex);
+    if (!match)
+        return content;
+    const body = match[2];
+    const bodyLines = body.split('\n').filter((line) => line.trim() !== '');
+    const indent = bodyLines.map((line) => line.match(/^(\s+)/)?.[1]).find((value) => typeof value === 'string') ?? '\t\t\t\t';
+    const closingIndent = match[3].match(/([ \t]*)\);\s*$/)?.[1] ?? '\t\t\t';
+    const updatedBody = updateLines(bodyLines, indent).join('\n');
+    return content.replace(buildPhasesRegex, `${match[1]}${updatedBody}\n${closingIndent});`);
+}
+/** Move a phase to the end so it runs after bundling and packaging. */
+function movePhaseToEndOfFirstTarget(content, phaseReferenceLine, marker) {
+    return updateFirstTargetBuildPhases(content, (bodyLines, indent) => {
+        const nonPhaseLines = bodyLines.filter((line) => !line.includes(marker));
+        // Keep the upload phase at the end so Xcode has already produced the archive bundle + sourcemap before we upload them.
+        return [...nonPhaseLines, `${indent}${phaseReferenceLine}`];
+    });
+}
+/** Place a phase immediately before the RN bundle phase in the first target. */
+function movePhaseBeforeBundleTask(content, phaseReferenceLine, marker) {
+    return updateFirstTargetBuildPhases(content, (bodyLines, indent) => {
+        const nonPhaseLines = bodyLines.filter((line) => !line.includes(marker));
+        const bundleIndex = nonPhaseLines.findIndex((line) => line.includes('Bundle React Native code and images'));
+        const phaseLine = `${indent}${phaseReferenceLine}`;
+        if (bundleIndex === -1) {
+            return [phaseLine, ...nonPhaseLines];
+        }
+        return [...nonPhaseLines.slice(0, bundleIndex), phaseLine, ...nonPhaseLines.slice(bundleIndex)];
+    });
+}
+/** Build a PBX shell phase block with escaped script contents. */
+function buildIosShellPhaseBlock(phaseId, marker, scriptBody) {
+    const escapedScript = scriptBody.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+    return `
+		${phaseId} /* ${marker} */ = {
+			isa = PBXShellScriptBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			inputPaths = (
+			);
+			name = "${marker}";
+			outputPaths = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+			shellPath = /bin/sh;
+			shellScript = "${escapedScript}\\n";
+		};
+`;
+}
+/** Insert a shell phase block into the PBX shell phase section. */
+function insertShellPhaseBlock(content, phaseBlock) {
+    const shellSectionEnd = '/* End PBXShellScriptBuildPhase section */';
+    const shellSectionBegin = '/* Begin PBXShellScriptBuildPhase section */';
+    if (content.includes(shellSectionEnd)) {
+        return content.replace(shellSectionEnd, phaseBlock + '\t' + shellSectionEnd);
+    }
+    if (content.includes(shellSectionBegin)) {
+        return content.replace(shellSectionBegin, shellSectionBegin + phaseBlock);
+    }
+    const endProject = '/* End PBXProject section */';
+    const newSection = `\n\t/* Begin PBXShellScriptBuildPhase section */\n${phaseBlock}\t/* End PBXShellScriptBuildPhase section */\n`;
+    return content.replace(endProject, newSection + endProject);
+}
+/** Prompt for a setup value and fall back to the provided default. */
 function prompt(question, defaultAnswer) {
     return new Promise((resolve) => {
         const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
@@ -75,7 +163,30 @@ function prompt(question, defaultAnswer) {
 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).';
+const CONFIG_COMMENT = 'To change Android upload paths, edit sourcemaps.android.release, sourcemaps.android.debug, and bundle.android.release. iOS archive uploads auto-discover main.jsbundle and main.jsbundle.map from common ios/build, archive, and DerivedData locations, or you can override sourcemaps.ios.release/debug and bundle.ios.release/debug for manual uploads.';
+/** Build the prefix injected into the RN iOS bundle phase. */
+function buildZipyIosBundlePhasePrefix() {
+    return (`export ${IOS_RN_SOURCEMAP_PATCH_MARKER}\\n` +
+        `# Stage the React Native bundle artifacts in a stable path so the later Zipy upload phase can locate them reliably during archives.\\n` +
+        `export BUNDLE_FILE=\\"${'${PROJECT_DIR}'}/build/zipy/Sourcemaps/main.jsbundle\\"\\n` +
+        `export SOURCEMAP_FILE=\\"${'${PROJECT_DIR}'}/build/zipy/Sourcemaps/main.jsbundle.map\\"\\n` +
+        `mkdir -p \\"$(dirname \\"$BUNDLE_FILE\\")\\"\\n` +
+        `set -e\\n`);
+}
+/** Patch the RN bundle phase so iOS bundle artifacts land in Zipy's stable output path. */
+function patchReactNativeIosBundlePhase(content) {
+    const bundlePhaseRegex = /(\/\* Bundle React Native code and images \*\/ = \{[\s\S]*?shellScript = ")([\s\S]*?react-native-xcode\.sh[\s\S]*?)(";\n[\s\S]*?\};)/;
+    const match = content.match(bundlePhaseRegex);
+    if (!match) {
+        return content;
+    }
+    const currentScript = match[2];
+    const desiredPrefix = buildZipyIosBundlePhasePrefix();
+    const setEIndex = currentScript.indexOf('set -e\\n');
+    const suffix = setEIndex >= 0 ? currentScript.slice(setEIndex + 'set -e\\n'.length) : currentScript;
+    const normalizedScript = desiredPrefix + suffix.replace(/^\n+/, '');
+    return content.replace(bundlePhaseRegex, `$1${normalizedScript}$3`);
+}
 /**
  * Create .zipy-mobile.json with API config and sourcemap/bundle paths. Uses fixed upload URL and framework=react-native.
  */
@@ -94,11 +205,19 @@ function writeConfig(projectRoot, options) {
                 release: options.sourcemapPathRelease ?? exports.DEFAULT_SOURCEMAP_PATHS.release,
                 debug: options.sourcemapPathDebug ?? exports.DEFAULT_SOURCEMAP_PATHS.debug,
             },
+            // Keep explicit iOS release defaults so .zipy-mobile.json documents the staged archive output.
+            ios: {
+                release: exports.DEFAULT_IOS_SOURCEMAP_PATH_RELEASE,
+            },
         },
         bundle: {
             android: {
                 release: options.bundlePathRelease ?? exports.DEFAULT_BUNDLE_PATH_RELEASE,
             },
+            // Keep explicit iOS release defaults so .zipy-mobile.json documents the staged archive output.
+            ios: {
+                release: exports.DEFAULT_IOS_BUNDLE_PATH_RELEASE,
+            },
         },
     };
     fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf8');
@@ -124,8 +243,9 @@ apply from: new File(project.rootProject.projectDir.parentFile, "node_modules/zi
     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.
+ * Add Run Script Build Phases to the iOS app target for Zipy's archive upload flow.
+ * The phase stays attached to the app target, but the script itself uploads only during archive/install actions.
+ * We also patch the RN bundle phase so main.jsbundle.map is emitted to a stable ios/build/zipy/... path.
  */
 function patchIosProject(projectRoot) {
     const iosDir = path.join(projectRoot, IOS_XCODEPROJ_REL);
@@ -138,51 +258,40 @@ function patchIosProject(projectRoot) {
     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);
+    const prepareScriptBody = 'cd "${SRCROOT}/.." && [ -f node_modules/zipy-mobile-cli/zipy-ios-prepare.sh ] && sh node_modules/zipy-mobile-cli/zipy-ios-prepare.sh || true';
+    const uploadScriptBody = 'cd "${SRCROOT}/.." && [ -f node_modules/zipy-mobile-cli/zipy-ios-upload.sh ] && sh node_modules/zipy-mobile-cli/zipy-ios-upload.sh || true';
+    if (content.includes(IOS_ZIPY_PHASE_MARKER)) {
+        const existingPrepareReference = getPhaseReferenceLine(content, IOS_ZIPY_PREPARE_MARKER);
+        const existingUploadReference = getPhaseReferenceLine(content, IOS_ZIPY_PHASE_MARKER);
+        let updatedContent = patchReactNativeIosBundlePhase(content);
+        if (!existingPrepareReference) {
+            const preparePhaseId = Array.from({ length: 24 }, () => Math.floor(Math.random() * 16).toString(16)).join('').toUpperCase();
+            updatedContent = insertShellPhaseBlock(updatedContent, buildIosShellPhaseBlock(preparePhaseId, IOS_ZIPY_PREPARE_MARKER, prepareScriptBody));
+            updatedContent = movePhaseBeforeBundleTask(updatedContent, `${preparePhaseId} /* ${IOS_ZIPY_PREPARE_MARKER} */,`, IOS_ZIPY_PREPARE_MARKER);
+        }
+        else {
+            updatedContent = movePhaseBeforeBundleTask(updatedContent, existingPrepareReference, IOS_ZIPY_PREPARE_MARKER);
+        }
+        if (!existingUploadReference) {
+            if (updatedContent !== content) {
+                fs.writeFileSync(pbxPath, updatedContent, 'utf8');
+            }
+            return true;
+        }
+        updatedContent = movePhaseToEndOfFirstTarget(updatedContent, existingUploadReference, IOS_ZIPY_PHASE_MARKER);
+        if (updatedContent !== content) {
+            fs.writeFileSync(pbxPath, updatedContent, 'utf8');
+        }
+        return true;
     }
-    // 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`);
+    // 24-char hex IDs (Xcode style)
+    const preparePhaseId = Array.from({ length: 24 }, () => Math.floor(Math.random() * 16).toString(16)).join('').toUpperCase();
+    const uploadPhaseId = Array.from({ length: 24 }, () => Math.floor(Math.random() * 16).toString(16)).join('').toUpperCase();
+    content = insertShellPhaseBlock(content, buildIosShellPhaseBlock(preparePhaseId, IOS_ZIPY_PREPARE_MARKER, prepareScriptBody));
+    content = insertShellPhaseBlock(content, buildIosShellPhaseBlock(uploadPhaseId, IOS_ZIPY_PHASE_MARKER, uploadScriptBody));
+    content = patchReactNativeIosBundlePhase(content);
+    content = movePhaseBeforeBundleTask(content, `${preparePhaseId} /* ${IOS_ZIPY_PREPARE_MARKER} */,`, IOS_ZIPY_PREPARE_MARKER);
+    content = movePhaseToEndOfFirstTarget(content, `${uploadPhaseId} /* ${IOS_ZIPY_PHASE_MARKER} */,`, IOS_ZIPY_PHASE_MARKER);
     fs.writeFileSync(pbxPath, content, 'utf8');
     return true;
 }
@@ -194,6 +303,7 @@ function ensureReactNativeProject(projectRoot) {
         throw new Error('Current directory does not look like a React Native project (missing android/ or package.json). Run this from the project root.');
     }
 }
+/** Create config and patch Android/iOS build hooks for a React Native app. */
 async function initReactNative(projectRoot, options) {
     projectRoot = path.resolve(projectRoot);
     ensureReactNativeProject(projectRoot);
@@ -204,17 +314,19 @@ async function initReactNative(projectRoot, options) {
     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');
+        logInfo('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);
+        logInfo('\nDefault paths (relative to project root):');
+        logInfo('sourcemaps.android.release:', sourcemapPathRelease);
+        logInfo('sourcemaps.android.debug:', sourcemapPathDebug);
+        logInfo('bundle.android.release:', bundlePathRelease);
+        logInfo('bundle.ios.release:', exports.DEFAULT_IOS_BUNDLE_PATH_RELEASE);
+        logInfo('sourcemaps.ios.release:', exports.DEFAULT_IOS_SOURCEMAP_PATH_RELEASE);
         const useDefaults = await prompt('Use these paths? (Y/n)', 'Y');
         if (useDefaults && useDefaults.toLowerCase() === 'n') {
             sourcemapPathRelease = await prompt('Path to release sourcemap', sourcemapPathRelease);
@@ -235,12 +347,12 @@ async function initReactNative(projectRoot, options) {
         customerId,
         authKey,
     });
-    console.log('Created config:', configPath);
+    logInfo('Created config:', configPath);
     patchGradle(projectRoot);
-    console.log('Patched', ANDROID_APP_BUILD_GRADLE, '— sourcemaps will upload after assembleRelease (debug not hooked).');
+    logInfo(`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).');
+        logInfo('Patched iOS project — added "ZipySourcemapsUpload" Run Script phase and RN sourcemap export (uploads main.jsbundle + main.jsbundle.map for Xcode archives).');
     }
-    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.');
+    logInfo('\nDone. Next: run ./gradlew assembleRelease from android/ (or from root with -p android); for iOS, Archive from Xcode to upload the generated main.jsbundle and main.jsbundle.map.');
 }

package/dist/types.d.ts

@@ -21,12 +21,20 @@ export interface ZipyConfig {
             release: string;
             debug: string;
         };
+        ios?: {
+            release?: string;
+            debug?: string;
+        };
     };
     bundle?: {
         android: {
             release: string;
             debug?: string;
         };
+        ios?: {
+            release?: string;
+            debug?: string;
+        };
     };
     /** Ignored at runtime; explains how to edit paths (JSON does not support comments). */
     _comment?: string;

package/dist/upload-sourcemaps.d.ts

@@ -1,5 +1,9 @@
 import type { ZipyConfig, BuildVariant } from './types';
+type SupportedPlatform = 'android' | 'ios';
+/** Load and validate the project's Zipy config file. */
 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 getSourcemapPath(projectRoot: string, platform: SupportedPlatform, variant: BuildVariant, config: ZipyConfig): string;
+export declare function getBundlePath(projectRoot: string, platform: SupportedPlatform, variant: BuildVariant, config: ZipyConfig): string | null;
+/** Resolve platform-specific artifacts, build fields, and send the upload request. */
 export declare function uploadSourcemaps(projectRoot: string, variant: BuildVariant): Promise<void>;
+export {};

package/dist/upload-sourcemaps.js

@@ -49,6 +49,35 @@ 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';
+const LOG_PREFIX = '[zipy]';
+/** Print `[zipy]` prefix upload logs. */
+function logInfo(...args) {
+    console.log(LOG_PREFIX, ...args);
+}
+/** Print `[zipy]` prefixed upload warnings. */
+function logWarn(...args) {
+    console.warn(LOG_PREFIX, ...args);
+}
+/** Escape a value so the debug curl command stays shell-safe. */
+function shellEscape(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+/** Build a replayable curl command that mirrors the upload request. */
+function buildCurlCommand(fullUrl, fields, filePaths) {
+    const curlParts = ['curl', '-X', 'POST', shellEscape(fullUrl)];
+    if (fields.key)
+        curlParts.push('-F', shellEscape(`key=${fields.key}`));
+    curlParts.push('-F', shellEscape(`bundle_id=${fields.bundle_id}`));
+    curlParts.push('-F', shellEscape(`release_version=${fields.release_version}`));
+    curlParts.push('-F', shellEscape(`framework=${fields.framework}`));
+    curlParts.push('-F', shellEscape(`platform=${fields.platform}`));
+    for (const file of filePaths) {
+        // Keep the printed curl close to the actual multipart payload so uploads are easy to replay locally.
+        curlParts.push('-F', shellEscape(`${file.fieldName}=@${file.path}`));
+    }
+    return curlParts.join(' ');
+}
+/** Load and validate the project's Zipy config file. */
 function loadConfig(projectRoot) {
     const configPath = path.join(projectRoot, types_1.CONFIG_FILENAME);
     if (!fs.existsSync(configPath)) {
@@ -71,24 +100,40 @@ function loadConfig(projectRoot) {
         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);
+/** Resolve an artifact path relative to the project root and assert it exists. */
+function resolveArtifactPath(projectRoot, configuredPath) {
+    const absolutePath = path.isAbsolute(configuredPath) ? configuredPath : path.resolve(projectRoot, configuredPath);
     if (!fs.existsSync(absolutePath)) {
-        throw new Error(`Sourcemap file not found: ${absolutePath}. Build may not have generated it yet.`);
+        throw new Error(`Artifact 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;
+function getSourcemapPath(projectRoot, platform, variant, config) {
+    const configuredPath = platform === 'ios'
+        ? process.env.ZIPY_SOURCEMAP_PATH ?? process.env.SOURCEMAP_FILE ?? config.sourcemaps?.ios?.[variant]
+        : process.env.ZIPY_SOURCEMAP_PATH ?? config.sourcemaps?.android?.[variant];
+    if (!configuredPath) {
+        throw new Error(platform === 'ios'
+            ? `No sourcemap path configured for ios variant "${variant}". Set ZIPY_SOURCEMAP_PATH in the Xcode build phase or add ".zipy-mobile.json" "sourcemaps.ios.${variant}".`
+            : `No sourcemap path configured for android variant "${variant}". Check .zipy-mobile.json "sourcemaps.android".`);
+    }
+    const absolutePath = resolveArtifactPath(projectRoot, configuredPath);
+    if (platform === 'ios') {
+        logInfo('Resolved iOS sourcemap path:', absolutePath);
+    }
+    return absolutePath;
+}
+function getBundlePath(projectRoot, platform, variant, config) {
+    const configuredPath = platform === 'ios'
+        ? process.env.ZIPY_BUNDLE_PATH ?? config.bundle?.ios?.[variant]
+        : process.env.ZIPY_BUNDLE_PATH ?? config.bundle?.android?.[variant];
+    if (!configuredPath) {
+        return platform === 'ios' ? null : null;
+    }
+    const absolutePath = resolveArtifactPath(projectRoot, configuredPath);
+    if (platform === 'ios') {
+        logInfo('Resolved iOS bundle path:', absolutePath);
+    }
     return absolutePath;
 }
 /**
@@ -138,7 +183,7 @@ function extractIdsFromSourcemap(sourcemapPath) {
     return out;
 }
 /**
- * Packager source map path (Metro writes this first; it contains the Debug ID before Hermes/Sentry compose).
+ * Packager source map path (Metro writes this first; it contains the Debug ID before later map composition).
  * Derived from the final map path: generated/sourcemaps -> intermediates/sourcemaps, and .map -> .packager.map
  */
 function getPackagerSourcemapPath(finalSourcemapPath) {
@@ -198,13 +243,39 @@ function buildMultipartBody(fields, filePaths) {
     append(`--${boundary}--${crlf}`);
     return { body: Buffer.concat(parts), boundary };
 }
+function getPlatform(platformEnv) {
+    return platformEnv?.toLowerCase() === 'ios' ? 'ios' : 'android';
+}
+/** Collect the files that should be attached for the current platform upload. */
+function getUploadArtifacts(projectRoot, variant, platform, config) {
+    if (platform === 'ios') {
+        const sourcemapPath = getSourcemapPath(projectRoot, platform, variant, config);
+        const bundlePath = getBundlePath(projectRoot, platform, variant, config);
+        if (!bundlePath) {
+            throw new Error(`No bundle path configured for ios variant "${variant}". Set ZIPY_BUNDLE_PATH in the Xcode build phase or add ".zipy-mobile.json" "bundle.ios.${variant}".`);
+        }
+        // Upload the archived iOS JS bundle together with its source map so Zipy can deobfuscate JS stack traces.
+        return [
+            { path: sourcemapPath, fieldName: 'files', filename: path.basename(sourcemapPath) },
+            { path: bundlePath, fieldName: 'files', filename: path.basename(bundlePath) },
+        ];
+    }
+    const sourcemapPath = getSourcemapPath(projectRoot, platform, variant, config);
+    const artifacts = [
+        { path: sourcemapPath, fieldName: 'files', filename: path.basename(sourcemapPath) },
+    ];
+    const bundlePath = getBundlePath(projectRoot, platform, variant, config);
+    if (bundlePath)
+        artifacts.push({ path: bundlePath, fieldName: 'files', filename: path.basename(bundlePath) });
+    return artifacts;
+}
 /**
  * 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.');
+            logWarn('uploadBaseUrl, apiKey and customerId are required in .zipy-mobile.json. Skipping upload.');
             return resolve();
         }
         const pathname = `${uploadPath}/${encodeURIComponent(apiKey)}/${encodeURIComponent(customerId)}`;
@@ -239,6 +310,7 @@ function uploadMultipart(uploadBaseUrl, apiKey, customerId, uploadPath, fields,
         req.end();
     });
 }
+/** Resolve platform-specific artifacts, build fields, and send the upload request. */
 async function uploadSourcemaps(projectRoot, variant) {
     const config = loadConfig(projectRoot);
     const uploadBaseUrl = (config.uploadBaseUrl ?? process.env.ZIPY_UPLOAD_BASE_URL ?? '').replace(/\/$/, '');
@@ -246,23 +318,31 @@ async function uploadSourcemaps(projectRoot, variant) {
     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 platform = getPlatform(process.env.ZIPY_PLATFORM);
     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) });
+    let zipyBundleId;
+    if (platform === 'android') {
+        const sourcemapPath = getSourcemapPath(projectRoot, platform, variant, config);
+        const ids = extractIdsFromSourcemap(sourcemapPath);
+        const zipyBundleIdFromGradle = process.env.ZIPY_DEBUG_ID;
+        // Android injects the per-build Zipy bundle id into the map, so prefer that over the stable app id.
+        zipyBundleId = zipyBundleIdFromGradle ?? ids.debugId;
+        if (ids.bundleId)
+            logInfo('Bundle ID from map (if present):', ids.bundleId);
+        if (zipyBundleId)
+            logInfo('Zipy bundle id for the build:', zipyBundleId);
+    }
+    else {
+        const sourcemapPath = getSourcemapPath(projectRoot, platform, variant, config);
+        const ids = extractIdsFromSourcemap(sourcemapPath);
+        // The iOS bundle phase writes a per-build Zipy debug id before bundling, so prefer that over the app id.
+        zipyBundleId = process.env.ZIPY_DEBUG_ID ?? ids.debugId;
+        if (ids.bundleId)
+            logInfo('Bundle ID from map (if present):', ids.bundleId);
+        if (zipyBundleId)
+            logInfo('Zipy bundle id for the build:', zipyBundleId);
+    }
+    const filePaths = getUploadArtifacts(projectRoot, variant, platform, config);
     // 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
@@ -276,9 +356,11 @@ async function uploadSourcemaps(projectRoot, variant) {
     };
     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 })));
+    logInfo('Platform:', platform);
+    logInfo('Request URL:', fullUrl);
+    logInfo('Form fields:', JSON.stringify(fields, null, 2));
+    logInfo('Files:', filePaths.map((f) => ({ path: f.path, filename: f.filename })));
+    logInfo('curl request:', buildCurlCommand(fullUrl, fields, filePaths));
     await uploadMultipart(uploadBaseUrl, apiKey, customerId, UPLOAD_PATH, fields, filePaths);
-    console.log('zipy-mobile-cli: Upload done.');
+    logInfo('Upload done.');
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zipy-mobile-cli",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "CLI to integrate Zipy with mobile apps — uploads sourcemaps when building (e.g. React Native Android).",
   "main": "dist/cli.js",
   "bin": {
@@ -12,30 +12,15 @@
     "prepublishOnly": "npm run build",
     "test": "node -e \"require('./dist/cli').run(['--help'])\""
   },
-  "keywords": [
-    "zipy",
-    "sourcemaps",
-    "react-native",
-    "android",
-    "cli"
-  ],
+  "keywords": ["zipy", "sourcemaps", "react-native", "android", "cli"],
   "author": "",
   "license": "ISC",
   "engines": {
     "node": ">=14.0.0"
   },
-  "files": [
-    "bin",
-    "dist",
-    "zipy.gradle",
-    "zipy-ios-upload.sh"
-  ],
+  "files": ["bin", "dist", "zipy.gradle", "zipy-ios-prepare.sh", "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-prepare.sh

@@ -0,0 +1,76 @@
+#!/bin/sh
+# Zipy iOS prepare hook — runs before the RN bundle phase so iOS gets a per-build Zipy bundle id
+# just like Android. The later upload phase reads the sentinel and reverts debugid.cjs after upload.
+set -eu
+
+echo "[zipy] iOS bundle-id prepare phase started (ZipyBundleIdPrepare)"
+
+if [ -n "${ZIPY_DISABLE_AUTO_UPLOAD:-}" ]; then
+  echo "[zipy] Skipped prepare (ZIPY_DISABLE_AUTO_UPLOAD is set)"
+  exit 0
+fi
+
+# Keep the prepare phase aligned with archive/install runs so local simulator builds are unaffected.
+if [ -z "${ARCHIVE_PATH:-}" ] && [ "${ACTION:-}" != "install" ]; then
+  echo "[zipy] Skipped prepare (not an Xcode archive/install action)"
+  exit 0
+fi
+
+PROJECT_ROOT="${SRCROOT}/.."
+cd "$PROJECT_ROOT"
+
+ZIPY_IOS_OUTPUT_DIR="${PROJECT_ROOT}/ios/build/zipy/Sourcemaps"
+ZIPY_IOS_SENTINEL_FILE="${ZIPY_IOS_OUTPUT_DIR}/zipy-debug-id.txt"
+ZIPY_IOS_DEBUGID_META_FILE="${ZIPY_IOS_OUTPUT_DIR}/zipy-debugid-meta.json"
+mkdir -p "$ZIPY_IOS_OUTPUT_DIR"
+
+ZIPY_DEBUG_ID="$(node -e "console.log(require('crypto').randomUUID())")"
+printf %s "$ZIPY_DEBUG_ID" > "$ZIPY_IOS_SENTINEL_FILE"
+echo "[zipy] generated ZIPY_DEBUG_ID for iOS archive"
+
+PROJECT_ROOT="$PROJECT_ROOT" ZIPY_DEBUG_ID="$ZIPY_DEBUG_ID" ZIPY_IOS_DEBUGID_META_FILE="$ZIPY_IOS_DEBUGID_META_FILE" node <<'ZIPYEOF'
+const fs = require('fs');
+const path = require('path');
+
+const projectRoot = process.env.PROJECT_ROOT || '';
+const bundleId = process.env.ZIPY_DEBUG_ID || '';
+const metadataFile = process.env.ZIPY_IOS_DEBUGID_META_FILE || '';
+const debugIdFiles = [
+  path.join(projectRoot, 'node_modules/zipy-react-native/lib/commonjs/utils/debugid.cjs'),
+  path.join(projectRoot, 'node_modules/zipyai-react-native/lib/commonjs/utils/debugid.cjs'),
+];
+const content =
+  '"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.BUNDLE_ID=void 0;const BUNDLE_ID=exports.BUNDLE_ID="' +
+  bundleId +
+  '";';
+const metadata = [];
+
+for (const filePath of debugIdFiles) {
+  if (!fs.existsSync(filePath)) continue;
+  try {
+    const stats = fs.statSync(filePath);
+    const originalMode = stats.mode & 0o777;
+    // Some package managers leave files in node_modules read-only, so temporarily add owner write
+    // permission before rewriting debugid.cjs for this archive build.
+    if ((originalMode & 0o200) === 0) {
+      fs.chmodSync(filePath, originalMode | 0o200);
+      console.log('[zipy] temporarily enabled write permission for debugid.cjs:', filePath);
+    }
+    fs.writeFileSync(filePath, content, 'utf8');
+    console.log('[zipy] wrote bundle id into debugid.cjs before iOS bundling:', filePath);
+    metadata.push({ filePath, originalMode });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn('[zipy] could not write bundle id into debugid.cjs:', filePath, message);
+  }
+}
+
+if (metadataFile && metadata.length > 0) {
+  try {
+    fs.writeFileSync(metadataFile, JSON.stringify(metadata, null, 2), 'utf8');
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn('[zipy] could not persist debugid.cjs metadata:', metadataFile, message);
+  }
+}
+ZIPYEOF

package/zipy-ios-upload.sh

@@ -1,11 +1,337 @@
 #!/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)"
+# Zipy iOS upload hook — runs from an Xcode Run Script Build Phase.
+# Keep the phase archive-focused, but only upload during archive/install actions so local builds stay quiet.
+# We stage main.jsbundle and main.jsbundle.map into ios/build/zipy/... before calling the shared uploader.
+set -eu
+
+echo "[zipy] iOS archive upload phase started (ZipySourcemapsUpload)"
+
+# Mirror Android's opt-out behavior so local builds can skip the network call.
+if [ -n "${ZIPY_DISABLE_AUTO_UPLOAD:-}" ]; then
+  echo "[zipy] Skipped (ZIPY_DISABLE_AUTO_UPLOAD is set)"
   exit 0
 fi
+
+# Match the archive upload flow: only upload the archive-generated JS bundle artifacts, not every simulator/device build.
+if [ -z "${ARCHIVE_PATH:-}" ] && [ "${ACTION:-}" != "install" ]; then
+  echo "[zipy] Skipped (not an Xcode archive/install action)"
+  exit 0
+fi
+
+PROJECT_ROOT="${SRCROOT}/.."
+cd "$PROJECT_ROOT"
+
+ZIPY_IOS_OUTPUT_DIR="${PROJECT_ROOT}/ios/build/zipy/Sourcemaps"
+ZIPY_IOS_SENTINEL_FILE="${ZIPY_IOS_OUTPUT_DIR}/zipy-debug-id.txt"
+ZIPY_IOS_DEBUGID_META_FILE="${ZIPY_IOS_OUTPUT_DIR}/zipy-debugid-meta.json"
+mkdir -p "$ZIPY_IOS_OUTPUT_DIR"
+
+cleanup_debug_id_files() {
+  PROJECT_ROOT="$PROJECT_ROOT" ZIPY_IOS_DEBUGID_META_FILE="$ZIPY_IOS_DEBUGID_META_FILE" node <<'ZIPYEOF'
+const fs = require('fs');
+const path = require('path');
+
+const projectRoot = process.env.PROJECT_ROOT || '';
+const metadataFile = process.env.ZIPY_IOS_DEBUGID_META_FILE || '';
+const debugIdFiles = [
+  path.join(projectRoot, 'node_modules/zipy-react-native/lib/commonjs/utils/debugid.cjs'),
+  path.join(projectRoot, 'node_modules/zipyai-react-native/lib/commonjs/utils/debugid.cjs'),
+];
+const emptyContent =
+  '"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.BUNDLE_ID=void 0;const BUNDLE_ID=exports.BUNDLE_ID="";';
+const metadataByPath = new Map();
+
+if (metadataFile && fs.existsSync(metadataFile)) {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(metadataFile, 'utf8'));
+    if (Array.isArray(parsed)) {
+      for (const entry of parsed) {
+        if (!entry || typeof entry !== 'object') continue;
+        const filePath = entry.filePath;
+        const originalMode = entry.originalMode;
+        if (typeof filePath === 'string' && typeof originalMode === 'number') {
+          metadataByPath.set(filePath, originalMode);
+        }
+      }
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn('[zipy] could not read debugid.cjs metadata:', metadataFile, message);
+  }
+}
+
+for (const filePath of debugIdFiles) {
+  if (!fs.existsSync(filePath)) continue;
+  try {
+    const currentMode = fs.statSync(filePath).mode & 0o777;
+    const originalMode = metadataByPath.get(filePath) ?? currentMode;
+    // Ensure cleanup can always rewrite debugid.cjs even if the package file was originally read-only.
+    if ((currentMode & 0o200) === 0) {
+      fs.chmodSync(filePath, currentMode | 0o200);
+      console.log('[zipy] temporarily enabled write permission for debugid.cjs cleanup:', filePath);
+    }
+    fs.writeFileSync(filePath, emptyContent, 'utf8');
+    if (originalMode !== (fs.statSync(filePath).mode & 0o777)) {
+      fs.chmodSync(filePath, originalMode);
+      console.log('[zipy] restored original permissions for debugid.cjs:', filePath);
+    }
+    console.log('[zipy] cleared debugid.cjs after iOS archive upload:', filePath);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn('[zipy] could not clear debugid.cjs after iOS archive upload:', filePath, message);
+  }
+}
+
+if (metadataFile && fs.existsSync(metadataFile)) {
+  try {
+    fs.unlinkSync(metadataFile);
+    console.log('[zipy] removed iOS debugid metadata:', metadataFile);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn('[zipy] could not remove iOS debugid metadata:', metadataFile, message);
+  }
+}
+ZIPYEOF
+
+  if [ -f "$ZIPY_IOS_SENTINEL_FILE" ]; then
+    rm -f "$ZIPY_IOS_SENTINEL_FILE"
+    echo "[zipy] removed iOS debug-id sentinel ${ZIPY_IOS_SENTINEL_FILE}"
+  fi
+}
+
+# Mirror Android cleanup semantics: once the archive path is done, revert debugid.cjs even if upload fails.
+trap cleanup_debug_id_files EXIT
+
+resolve_artifact_path() {
+  ARTIFACT_NAME="$1"
+  EXPLICIT_PATH="${2:-}"
+  EXTRA_DIRECT_PATH="${3:-}"
+
+  ARTIFACT_NAME="$ARTIFACT_NAME" \
+  EXPLICIT_PATH="$EXPLICIT_PATH" \
+  EXTRA_DIRECT_PATH="$EXTRA_DIRECT_PATH" \
+  PROJECT_ROOT="$PROJECT_ROOT" \
+  ZIPY_IOS_OUTPUT_DIR="$ZIPY_IOS_OUTPUT_DIR" \
+  TARGET_BUILD_DIR="${TARGET_BUILD_DIR:-}" \
+  CONFIGURATION_BUILD_DIR="${CONFIGURATION_BUILD_DIR:-}" \
+  BUILT_PRODUCTS_DIR="${BUILT_PRODUCTS_DIR:-}" \
+  BUILD_DIR="${BUILD_DIR:-}" \
+  DERIVED_FILE_DIR="${DERIVED_FILE_DIR:-}" \
+  UNLOCALIZED_RESOURCES_FOLDER_PATH="${UNLOCALIZED_RESOURCES_FOLDER_PATH:-}" \
+  WRAPPER_NAME="${WRAPPER_NAME:-}" \
+  ARCHIVE_PATH="${ARCHIVE_PATH:-}" \
+  PROJECT_DIR="${PROJECT_DIR:-}" \
+  CONFIGURATION="${CONFIGURATION:-}" \
+  EFFECTIVE_PLATFORM_NAME="${EFFECTIVE_PLATFORM_NAME:-}" \
+  HOME="${HOME:-}" \
+  node <<'NODE'
+const fs = require('fs');
+const path = require('path');
+
+const artifactName = process.env.ARTIFACT_NAME;
+const explicitPath = process.env.EXPLICIT_PATH || '';
+const extraDirectPath = process.env.EXTRA_DIRECT_PATH || '';
+
+function exists(candidate) {
+  if (!candidate) return false;
+  try {
+    fs.accessSync(candidate);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function pushUnique(list, seen, candidate) {
+  if (!candidate || seen.has(candidate)) return;
+  seen.add(candidate);
+  list.push(candidate);
+}
+
+function buildDerivedDataRoots(homeDir) {
+  if (!homeDir) return [];
+  const derivedDataRoot = path.join(homeDir, 'Library', 'Developer', 'Xcode', 'DerivedData');
+  if (!exists(derivedDataRoot)) return [];
+
+  const roots = [];
+  try {
+    for (const entry of fs.readdirSync(derivedDataRoot)) {
+      const buildRoot = path.join(derivedDataRoot, entry, 'Build');
+      if (!exists(buildRoot)) continue;
+      roots.push(buildRoot);
+      roots.push(path.join(buildRoot, 'Products'));
+      roots.push(path.join(buildRoot, 'Intermediates.noindex'));
+    }
+  } catch {
+    return [];
+  }
+  return roots;
+}
+
+function searchTree(root, targetName, maxDepth) {
+  if (!exists(root)) return null;
+  const queue = [{ dir: root, depth: 0 }];
+  const visited = new Set();
+
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (!current || visited.has(current.dir)) continue;
+    visited.add(current.dir);
+
+    let entries = [];
+    try {
+      entries = fs.readdirSync(current.dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+
+    for (const entry of entries) {
+      const fullPath = path.join(current.dir, entry.name);
+      if (entry.isFile() && entry.name === targetName) {
+        return fullPath;
+      }
+      if (!entry.isDirectory() || current.depth >= maxDepth) continue;
+      // Stay focused on likely build output trees so archive uploads do not walk unrelated directories.
+      if (entry.name === 'node_modules' || entry.name === '.git') continue;
+      queue.push({ dir: fullPath, depth: current.depth + 1 });
+    }
+  }
+
+  return null;
+}
+
+if (exists(explicitPath)) {
+  console.log(explicitPath);
+  process.exit(0);
+}
+
+if (exists(extraDirectPath)) {
+  console.log(extraDirectPath);
+  process.exit(0);
+}
+
+const directCandidates = [];
+const directSeen = new Set();
+pushUnique(directCandidates, directSeen, path.join(process.env.ZIPY_IOS_OUTPUT_DIR || '', artifactName));
+pushUnique(directCandidates, directSeen, path.join(process.env.TARGET_BUILD_DIR || '', process.env.UNLOCALIZED_RESOURCES_FOLDER_PATH || '', artifactName));
+pushUnique(directCandidates, directSeen, path.join(process.env.TARGET_BUILD_DIR || '', process.env.WRAPPER_NAME || '', artifactName));
+pushUnique(directCandidates, directSeen, path.join(process.env.CONFIGURATION_BUILD_DIR || '', artifactName));
+pushUnique(directCandidates, directSeen, path.join(process.env.BUILT_PRODUCTS_DIR || '', artifactName));
+pushUnique(directCandidates, directSeen, path.join(process.env.DERIVED_FILE_DIR || '', artifactName));
+pushUnique(directCandidates, directSeen, path.join(process.env.PROJECT_DIR || '', 'build', 'zipy', `${process.env.CONFIGURATION || 'Release'}${process.env.EFFECTIVE_PLATFORM_NAME || ''}`, artifactName));
+
+for (const candidate of directCandidates) {
+  if (exists(candidate)) {
+    console.log(candidate);
+    process.exit(0);
+  }
+}
+
+const searchRoots = [];
+const rootSeen = new Set();
+pushUnique(searchRoots, rootSeen, process.env.TARGET_BUILD_DIR || '');
+pushUnique(searchRoots, rootSeen, process.env.CONFIGURATION_BUILD_DIR || '');
+pushUnique(searchRoots, rootSeen, process.env.BUILT_PRODUCTS_DIR || '');
+pushUnique(searchRoots, rootSeen, process.env.BUILD_DIR || '');
+pushUnique(searchRoots, rootSeen, process.env.DERIVED_FILE_DIR || '');
+pushUnique(searchRoots, rootSeen, path.join(process.env.PROJECT_ROOT || '', 'ios', 'build'));
+if (process.env.ARCHIVE_PATH) {
+  pushUnique(searchRoots, rootSeen, path.join(process.env.ARCHIVE_PATH, 'Products'));
+  pushUnique(searchRoots, rootSeen, path.join(process.env.ARCHIVE_PATH, 'BuildProductsPath'));
+}
+for (const root of buildDerivedDataRoots(process.env.HOME || '')) {
+  pushUnique(searchRoots, rootSeen, root);
+}
+
+for (const root of searchRoots) {
+  const match = searchTree(root, artifactName, 6);
+  if (match) {
+    console.log(match);
+    process.exit(0);
+  }
+}
+
+process.exit(1);
+NODE
+}
+
+if ! BUNDLE_SOURCE_PATH="$(resolve_artifact_path "main.jsbundle" "${ZIPY_BUNDLE_PATH:-}" "")"; then
+  echo "[zipy] Skipped (main.jsbundle not found)"
+  echo "[zipy] TARGET_BUILD_DIR=${TARGET_BUILD_DIR:-unset}"
+  echo "[zipy] CONFIGURATION_BUILD_DIR=${CONFIGURATION_BUILD_DIR:-unset}"
+  echo "[zipy] BUILT_PRODUCTS_DIR=${BUILT_PRODUCTS_DIR:-unset}"
+  echo "[zipy] BUILD_DIR=${BUILD_DIR:-unset}"
+  echo "[zipy] UNLOCALIZED_RESOURCES_FOLDER_PATH=${UNLOCALIZED_RESOURCES_FOLDER_PATH:-unset}"
+  echo "[zipy] ARCHIVE_PATH=${ARCHIVE_PATH:-unset}"
+  echo "[zipy] WRAPPER_NAME=${WRAPPER_NAME:-unset}"
+  exit 0
+fi
+
+if ! SOURCEMAP_SOURCE_PATH="$(resolve_artifact_path "main.jsbundle.map" "${ZIPY_SOURCEMAP_PATH:-}" "${SOURCEMAP_FILE:-}")"; then
+  echo "[zipy] Skipped (main.jsbundle.map not found)"
+  echo "[zipy] SOURCEMAP_FILE=${SOURCEMAP_FILE:-unset}"
+  echo "[zipy] DERIVED_FILE_DIR=${DERIVED_FILE_DIR:-unset}"
+  echo "[zipy] TARGET_BUILD_DIR=${TARGET_BUILD_DIR:-unset}"
+  echo "[zipy] CONFIGURATION_BUILD_DIR=${CONFIGURATION_BUILD_DIR:-unset}"
+  echo "[zipy] BUILT_PRODUCTS_DIR=${BUILT_PRODUCTS_DIR:-unset}"
+  echo "[zipy] BUILD_DIR=${BUILD_DIR:-unset}"
+  echo "[zipy] PROJECT_DIR=${PROJECT_DIR:-unset}"
+  exit 0
+fi
+
+STAGED_BUNDLE_PATH="${ZIPY_IOS_OUTPUT_DIR}/main.jsbundle"
+STAGED_SOURCEMAP_PATH="${ZIPY_IOS_OUTPUT_DIR}/main.jsbundle.map"
+ZIPY_DEBUG_ID_VALUE=""
+if [ -f "$ZIPY_IOS_SENTINEL_FILE" ]; then
+  ZIPY_DEBUG_ID_VALUE="$(tr -d '\n' < "$ZIPY_IOS_SENTINEL_FILE")"
+fi
+
+copy_if_needed() {
+  SOURCE_PATH="$1"
+  DEST_PATH="$2"
+  if [ "$SOURCE_PATH" = "$DEST_PATH" ]; then
+    echo "[zipy] Reusing staged artifact at ${DEST_PATH}"
+    return 0
+  fi
+
+  # If the resolver already found the file inside ios/build/zipy/..., skip the redundant copy.
+  if [ -e "$DEST_PATH" ] && [ "$(cd "$(dirname "$SOURCE_PATH")" && pwd)/$(basename "$SOURCE_PATH")" = "$(cd "$(dirname "$DEST_PATH")" && pwd)/$(basename "$DEST_PATH")" ]; then
+    echo "[zipy] Reusing staged artifact at ${DEST_PATH}"
+    return 0
+  fi
+
+  cp -f "$SOURCE_PATH" "$DEST_PATH"
+}
+
+# Copy both artifacts into ios/build/zipy/... only when they are not already staged there.
+copy_if_needed "$BUNDLE_SOURCE_PATH" "$STAGED_BUNDLE_PATH"
+copy_if_needed "$SOURCEMAP_SOURCE_PATH" "$STAGED_SOURCEMAP_PATH"
+
+APP_ID="${PRODUCT_BUNDLE_IDENTIFIER:-${BUNDLE_IDENTIFIER:-unknown}}"
+MARKETING_VERSION="${MARKETING_VERSION:-1.0.0}"
+BUILD_NUMBER="${CURRENT_PROJECT_VERSION:-0}"
+RELEASE_VERSION="${APP_ID}@${MARKETING_VERSION}+${BUILD_NUMBER}"
+
+echo "[zipy] Uploading archived iOS bundle + sourcemap"
+echo "[zipy] archive=${ARCHIVE_PATH:-unknown}"
+echo "[zipy] release=${RELEASE_VERSION}"
+echo "[zipy] bundle source=${BUNDLE_SOURCE_PATH}"
+echo "[zipy] sourcemap source=${SOURCEMAP_SOURCE_PATH}"
+echo "[zipy] bundle path=${STAGED_BUNDLE_PATH}"
+echo "[zipy] sourcemap path=${STAGED_SOURCEMAP_PATH}"
+if [ -n "$ZIPY_DEBUG_ID_VALUE" ]; then
+  echo "[zipy] using ZIPY_DEBUG_ID from ${ZIPY_IOS_SENTINEL_FILE}"
+else
+  echo "[zipy] no ZIPY_DEBUG_ID sentinel found; upload will fall back to ids already embedded in the source map"
+fi
+
+# Pass explicit env vars so the shared CLI can reuse the same upload command for Android maps and iOS archive JS artifacts.
+ZIPY_PLATFORM=ios \
+ZIPY_BUNDLE_PATH="$STAGED_BUNDLE_PATH" \
+ZIPY_SOURCEMAP_PATH="$STAGED_SOURCEMAP_PATH" \
+ZIPY_DEBUG_ID="$ZIPY_DEBUG_ID_VALUE" \
+ZIPY_APP_ID="$APP_ID" \
+ZIPY_BUNDLE_ID="$APP_ID" \
+ZIPY_RELEASE="$RELEASE_VERSION" \
+ZIPY_RELEASE_VERSION="$RELEASE_VERSION" \
+npx zipy-mobile-cli upload-sourcemaps release

package/zipy.gradle

@@ -1,5 +1,5 @@
 /**
- * Zipy Mobile CLI — Gradle integration (Sentry-style).
+ * Zipy Mobile CLI — Gradle integration.
  * 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
@@ -22,7 +22,7 @@ plugins.withId('com.android.application') {
       variant.buildConfigField "String", "ZIPY_BUNDLE_ID", "\"${variant.applicationId}\""
     }
   } catch (Throwable t) {
-    logger.warn("Zipy: could not add BuildConfig.ZIPY_BUNDLE_ID: ${t.message}")
+    logger.warn("[zipy] could not add BuildConfig.ZIPY_BUNDLE_ID: ${t.message}")
   }
 
   def androidComponents = extensions.getByName("androidComponents")
@@ -86,15 +86,15 @@ plugins.withId('com.android.application') {
             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)")
+              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}")
+              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.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")
+        logger.lifecycle("[zipy] generated bundle id and set in debugid.cjs; Metro will use it when bundling")
       }
 
       def zipyInjectTask = tasks.register(zipyInjectTaskName) { t ->
@@ -104,13 +104,13 @@ plugins.withId('com.android.application') {
         t.outputs.file(mapFile).optional(true)
         t.doLast {
           if (!zipySentinelFile.exists()) {
-            logger.warn("Zipy: sentinel not found (expected from bundle task doFirst)")
+            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")
+            logger.warn("[zipy] source map not found at ${mapFile.absolutePath}, skipping inject")
             return
           }
           try {
@@ -129,9 +129,9 @@ plugins.withId('com.android.application') {
             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}")
+            logger.lifecycle("[zipy] injected Zipy bundle id into ${mapFile.name}")
           } catch (Throwable e) {
-            logger.warn("Zipy: could not inject into source map: ${e.message}")
+            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)
@@ -176,7 +176,7 @@ plugins.withId('com.android.application') {
             def sentinelId = zipySentinelFile.text.trim()
             if (sentinelId) {
               environment("ZIPY_DEBUG_ID", sentinelId)
-              logger.lifecycle("Zipy: passing ZIPY_DEBUG_ID from sentinel for upload")
+              logger.lifecycle("[zipy] passing ZIPY_DEBUG_ID from sentinel for upload")
             }
           }
         }
@@ -198,13 +198,13 @@ plugins.withId('com.android.application') {
             if (f.exists()) {
               try {
                 f.text = emptyContent
-                logger.lifecycle("Zipy: cleared debugid.cjs (${f.name}) after build")
+                logger.lifecycle("[zipy] cleared debugid.cjs (${f.name}) after build")
               } catch (Throwable e) {
-                logger.warn("Zipy: could not clear ${f.absolutePath}: ${e.message}")
+                logger.warn("[zipy] could not clear ${f.absolutePath}: ${e.message}")
               }
             }
           }
-          logger.lifecycle("Zipy upload done for ${releaseName}")
+          logger.lifecycle("[zipy] upload done for ${releaseName}")
         }
       }