@contentsquare/react-native-cli 1.0.0

package/LICENSE

@@ -0,0 +1,48 @@
+                    The Content Square React Native CLI License 1.0
+                        (c) Content Square SAS 2025
+
+By downloading, installing, implementing or otherwise using the Content Square
+SAS React Native CLI (“the Contentsquare React Native CLI”) you agree to the 
+terms and conditions of this License Agreement.
+    
+Contentsquare grants you a limited, royalty-free, non-exclusive,
+non-transferrable, non-sublicensable, revocable copyright license to use and
+reproduce, without modification, the Contentsquare React Native CLI solely to enable the
+use of Contentsquare with or in your React Native platform applications, subject to the
+following conditions:
+    
+Other than as permitted in this agreement, you may not distribute, display,
+copy, execute publicly, make available to the public, reduce to human readable
+form, lease, resale, disassemble, decompile, adapt, sublicense, host as a
+service, make other commercial use of, sell, rent, lend, process, compile,
+reverse engineer, combine with other software, translate, modify, or create
+derivative works of the Contentsquare React Native CLI.
+    
+Contentsquare has no obligation to enable you or any of your applications to
+access, interact with, or retrieve or publish content to any Contentsquare
+platform or service. However, Contentsquare may provide you with such platform
+services on additional terms.
+    
+Contentsquare further has no obligation to provide support, maintenance,
+upgrades, modifications, or new releases of the Contentsquare React Native CLI, unless
+otherwise agreed in writing.
+    
+All other rights are reserved.
+    
+TO THE FULLEST EXTENT PERMITTED BY LAW, CONTENTSQUARE MAKES NO, AND HEREBY
+DISCLAIMS ANY AND ALL, REPRESENTATIONS WARRANTIES, CONDITIONS AND ALL OTHER
+TERMS OF ANY KIND WHATSOEVER WITH RESPECT TO THE CONTENTSQUARE REACT NATIVE CLI AND
+RELATED DOCUMENTATION, OR ADDITIONAL SERVICES, WHETHER EXPRESS OR IMPLIED, ORAL
+OR WRITTEN, INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OF ACCURACY, QUALITY,
+PERFORMANCE, MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A PARTICULAR
+PURPOSE. FOR THE AVOIDANCE OF DOUBT, CONTENTSQUARE DOES NOT WARRANT THAT THE
+CONTENTSQUARE REACT NATIVE CLI SHALL MEET YOUR NEEDS OR BE ERROR FREE. IN NO EVENT SHALL
+CONTENTSQUARE BE LIABLE FOR ANY TYPE OF DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
+IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THE CONTENTSQUARE REACT NATIVE CLI, EVEN IF ADVISED
+OF THE POSSIBILITY OF SUCH DAMAGE. YOU ASSUME SOLE RESPONSIBILITY FOR RESULTS
+OBTAINED FROM THE USE OF THE CONTENTSQUARE REACT NATIVE CLI BY YOU. THE CONTENTSQUARE
+REACT NATIVE CLI, SCRIPTS, OR ADDITIONAL SERVICES ARE PROVIDED TO YOU ON AN “AS IS”
+BASIS.

package/README.md

@@ -0,0 +1,63 @@
+# @contentsquare/react-native-cli
+
+A Command Line Interface (CLI) tool for Contentsquare used to upload mapping files for React Native apps.
+
+## Installation
+
+```bash
+yarn add @contentsquare/react-native-cli --dev
+```
+
+## Configuration
+
+The upload command requires the following information:
+
+- **The targeted platform**
+
+  `ios` or `android`
+
+- **The project ID**
+
+  1. Login to the Contentsquare platform on https://app.contentsquare.com
+  2. Make sure to be on the right project
+  3. The project ID can be found in the URL query parameter `project`:<br/>`https://app.contentsquare.com/#/{MODULE_NAME}?project={PROJECT_ID}&hash={HASH}]`
+
+- **Valid API credentials**
+
+  Follow the dedicated documentation from the Help Center to get the client ID and client Secret: [How to create API credentials](https://support.contentsquare.com/hc/en-gb/articles/9292880837660-How-to-create-API-credentials).
+
+### Using JSON file
+
+You can provide this information by adding a `contentsquare-cli.json` file at the root of your project.
+
+```json
+{
+  "android": {
+    "clientId": "[ANDROID CLIENT ID]",
+    "clientSecret": "[ANDROID CLIENT SECRET]",
+    "projectId": "[ANDROID PROJECT ID]",
+    "sourcemapPath": "[PATH TO SOURCEMAP IN ANDROID PROJECT]"
+  },
+  "ios": {
+    "clientId": "[IOS CLIENT ID]",
+    "clientSecret": "[IOS CLIENT SECRET]",
+    "projectId": "[IOS PROJECT ID]",
+    "sourcemapPath": "[PATH TO SOURCEMAP IN IOS PROJECT]"
+  }
+}
+```
+
+### Using command line arguments
+
+Alternatively, this information can be added as arguments directly on the command line
+
+| Option             | Description                                                                                                                             |
+| ------------------ | --------------------------------------------------------------------------------------------------------------------------------------- |
+| `--client-id`      | The client ID of [API credentials](https://support.contentsquare.com/hc/en-gb/articles/9292880837660-How-to-create-API-credentials)     |
+| `--client-secret`  | The client secret of [API credentials](https://support.contentsquare.com/hc/en-gb/articles/9292880837660-How-to-create-API-credentials) |
+| `--config`         | The path to the configuration file relative to project root                                                                             |
+| `--help`           | Display the help message                                                                                                                |
+| `--platform`       | The platform to target: `ios` or `android`                                                                                              |
+| `--project-id`     | The project ID                                                                                                                          |
+| `--sourcemap-path` | The path to the sourcemap file                                                                                                          |
+| `--upload-url`     | The URL of the Contentsquare platform, default value: https://api.csq.io                                                                |

package/dist/auth.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.authenticate = void 0;
+const axios_1 = __importDefault(require("axios"));
+const logger_1 = require("./logger");
+const authenticate = async (clientId, clientSecret, projectId, baseUrl) => {
+    try {
+        const endpoint = `${baseUrl}/v1/oauth/token`;
+        logger_1.log.verbose(`Authentication details\nendpoint: ${endpoint},\nclientId: ${clientId},\nprojectId: ${projectId}`);
+        const response = await axios_1.default.post(endpoint, {
+            client_id: clientId,
+            client_secret: clientSecret,
+            project_id: projectId,
+            grant_type: 'client_credentials',
+            scope: 'symbolicator',
+        });
+        return response.data;
+    }
+    catch (error) {
+        throw new Error(`Authentication failed: ${error}`);
+    }
+};
+exports.authenticate = authenticate;

package/dist/config.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createConfig = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const logger_1 = require("./logger");
+/**
+ * Creates a configuration object based on the provided options and config file.
+ * @param {Options} options - The options object.
+ * @param {string} configPath - The path to the config file.
+ * @returns {Config} - The configuration object.
+ */
+const createConfig = (options, configPath) => {
+    const configFile = configPath
+        ? path_1.default.resolve(configPath)
+        : path_1.default.resolve('./contentsquare-cli.json');
+    let configFileValues = { android: {}, ios: {} };
+    if (fs_1.default.existsSync(configFile)) {
+        logger_1.log.verbose(`Loading config file from ${configFile}`);
+        configFileValues = JSON.parse(fs_1.default.readFileSync(configFile).toString());
+    }
+    else {
+        logger_1.log.warn(`No config file found at: ${configFile}`);
+    }
+    const defaultUploadUrl = 'https://authentication.contentsquare.com';
+    const getConfigValue = (platform, key) => {
+        var _a, _b, _c;
+        return options.platform === platform
+            ? ((_a = options[key]) === null || _a === void 0 ? void 0 : _a.toString()) || ((_b = configFileValues[platform]) === null || _b === void 0 ? void 0 : _b[key])
+            : (_c = configFileValues[platform]) === null || _c === void 0 ? void 0 : _c[key];
+    };
+    const config = {
+        android: {
+            clientId: getConfigValue('android', 'clientId'),
+            clientSecret: getConfigValue('android', 'clientSecret'),
+            projectId: getConfigValue('android', 'projectId'),
+            sourcemapPath: getConfigValue('android', 'sourcemapPath'),
+            uploadUrl: getConfigValue('android', 'uploadUrl') || defaultUploadUrl,
+        },
+        ios: {
+            clientId: getConfigValue('ios', 'clientId'),
+            clientSecret: getConfigValue('ios', 'clientSecret'),
+            projectId: getConfigValue('ios', 'projectId'),
+            sourcemapPath: getConfigValue('ios', 'sourcemapPath'),
+            uploadUrl: getConfigValue('ios', 'uploadUrl') || defaultUploadUrl,
+        },
+    };
+    // Log the final configuration for debug purposes
+    logger_1.log.verbose('Configuration:\n', JSON.stringify(config, null, 2));
+    return config;
+};
+exports.createConfig = createConfig;

package/dist/index.js

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const auth_1 = require("./auth");
+const config_1 = require("./config");
+const logger_1 = require("./logger");
+const sourcemap_1 = require("./sourcemap");
+const upload_1 = require("./upload");
+const utils_1 = require("./utils");
+const packageJson = require('../package.json');
+const { version } = packageJson;
+const program = new commander_1.Command();
+program
+    .version(version)
+    .description('CLI tool from Contentsquare to upload source maps for React Native apps');
+program
+    .command('update-sourcemap-id')
+    .description('Update source map ID')
+    .option('--platform <platform>', 'Platform (ios or android)')
+    .option('--verbose', 'Enable verbose logging')
+    .option('--working-dir <workingDir>', 'Working directory, defaults to cwd')
+    .action(async (options) => {
+    if (options.verbose) {
+        (0, logger_1.setLogLevel)('verbose');
+    }
+    if (options.workingDir) {
+        process.chdir(options.workingDir);
+        logger_1.log.verbose(`Changed working directory to ${process.cwd()}`);
+    }
+    const platforms = (0, utils_1.getPlatformSelection)(options.platform);
+    (0, sourcemap_1.updateSourcemapId)(platforms);
+});
+program
+    .command('upload-sourcemaps')
+    .description('Upload source maps for React Native app')
+    .option('--client-id <clientId>', 'Client ID of API credentials')
+    .option('--client-secret <clientSecret>', 'Client secret API credentials')
+    .option('--config <config>', 'Path to the config file relative to the root of the project')
+    .option('--platform <platform>', 'Platform (ios or android)')
+    .option('--project-id <projectId>', 'Project ID')
+    .option('--sourcemap-path <sourcemapPath>', 'Path to the source map file')
+    .option('--upload-url <uploadUrl>', 'URL for API upload endpoint')
+    .option('--verbose', 'Enable verbose logging')
+    .option('--working-dir <workingDir>', 'Working directory, defaults to cwd')
+    .action(async (options) => {
+    if (options.verbose) {
+        (0, logger_1.setLogLevel)('verbose');
+    }
+    if (options.workingDir) {
+        process.chdir(options.workingDir);
+        logger_1.log.verbose(`Changed working directory to ${process.cwd()}`);
+    }
+    const config = (0, config_1.createConfig)(options, options.config);
+    const platforms = (0, utils_1.getPlatformSelection)(options.platform);
+    for (const platform of platforms) {
+        const platformConfig = config[platform];
+        if (platformConfig.clientId &&
+            platformConfig.clientSecret &&
+            platformConfig.projectId &&
+            platformConfig.sourcemapPath &&
+            platformConfig.uploadUrl) {
+            try {
+                logger_1.log.verbose(`Authenticating for ${platform} ...`);
+                const { access_token: token, endpoint, token_type: tokenType, } = await (0, auth_1.authenticate)(platformConfig.clientId, platformConfig.clientSecret, platformConfig.projectId, (0, utils_1.ensureHttps)(platformConfig.uploadUrl));
+                logger_1.log.verbose(`Authentication successful for ${platform}`);
+                const sourcemapId = (0, sourcemap_1.readSourcemapId)(platform);
+                logger_1.log.verbose(`Uploading source map for ${platform} ...`);
+                await (0, upload_1.uploadSourcemap)(platformConfig.sourcemapPath, platform, sourcemapId, tokenType, token, (0, utils_1.ensureHttps)(endpoint));
+                logger_1.log.success(`Source map with ID: ${sourcemapId} uploaded successfully for ${platform}`);
+            }
+            catch (error) {
+                logger_1.log.error(`Failed to upload source map for ${platform}, project ID: ${platformConfig.projectId}:`, error);
+            }
+        }
+        else {
+            logger_1.log.warn(`Missing required parameters for ${platform}, skipping upload.`);
+        }
+    }
+});
+program.parse(process.argv);

package/dist/logger.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.log = exports.setLogLevel = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const chalk_1 = __importDefault(require("chalk"));
+let logLevel = 'info';
+const setLogLevel = (level) => {
+    logLevel = level;
+};
+exports.setLogLevel = setLogLevel;
+const logLevels = {
+    verbose: 0,
+    info: 1,
+    success: 2,
+    warn: 3,
+    error: 4,
+};
+const shouldLog = (level) => {
+    return logLevels[level] >= logLevels[logLevel];
+};
+const logMessage = (level, ...messages) => {
+    if (shouldLog(level)) {
+        const color = getColor(level);
+        console.log(color(`${level}`), ...messages);
+    }
+};
+const getColor = (level) => {
+    switch (level) {
+        case 'verbose':
+            return chalk_1.default.dim;
+        case 'info':
+            return chalk_1.default.blue;
+        case 'success':
+            return chalk_1.default.green;
+        case 'warn':
+            return chalk_1.default.yellow;
+        case 'error':
+            return chalk_1.default.red;
+        default:
+            return chalk_1.default.white;
+    }
+};
+exports.log = {
+    verbose: (...messages) => logMessage('verbose', ...messages),
+    info: (...messages) => logMessage('info', ...messages),
+    success: (...messages) => logMessage('success', ...messages),
+    warn: (...messages) => logMessage('warn', ...messages),
+    error: (...messages) => logMessage('error', ...messages),
+};

package/dist/sourcemap.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readSourcemapId = exports.saveSourcemapId = exports.updateSourcemapId = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const uuid_1 = require("uuid");
+const logger_1 = require("./logger");
+const SOURCEMAP_INFO_FILE = 'contentsquare-sourcemap-info.json';
+const updateSourcemapId = (platforms) => {
+    for (const platform of platforms) {
+        const sourcemapId = (0, uuid_1.v4)();
+        try {
+            (0, exports.saveSourcemapId)(platform, sourcemapId);
+            logger_1.log.success(`Updated source map ID for platform ${platform}: ${sourcemapId}`);
+        }
+        catch (error) {
+            logger_1.log.error(error);
+        }
+    }
+};
+exports.updateSourcemapId = updateSourcemapId;
+const saveSourcemapId = (platform, id) => {
+    const sourcemapInfoPath = path_1.default.join(process.cwd(), SOURCEMAP_INFO_FILE);
+    try {
+        let config = {};
+        if (fs_1.default.existsSync(sourcemapInfoPath)) {
+            config = JSON.parse(fs_1.default.readFileSync(sourcemapInfoPath).toString());
+        }
+        config[platform] = { id };
+        fs_1.default.writeFileSync(sourcemapInfoPath, JSON.stringify(config, null, 2));
+        logger_1.log.verbose(`Source map ID: ${id}\nsaved successfully for platform: ${platform}\nin path:${sourcemapInfoPath}`);
+    }
+    catch (error) {
+        throw new Error(`Failed to save source map ID for ${platform} in ${sourcemapInfoPath}: ${error}`);
+    }
+};
+exports.saveSourcemapId = saveSourcemapId;
+const readSourcemapId = (platform) => {
+    var _a;
+    const sourcemapInfoPath = path_1.default.join(process.cwd(), SOURCEMAP_INFO_FILE);
+    if (!fs_1.default.existsSync(sourcemapInfoPath)) {
+        throw new Error(`Source map info file not found at path: ${sourcemapInfoPath}.\nPlease run 'update-sourcemap-id' command before bundling.`);
+    }
+    const config = JSON.parse(fs_1.default.readFileSync(sourcemapInfoPath).toString());
+    const sourcemapId = (_a = config[platform]) === null || _a === void 0 ? void 0 : _a.id;
+    if (!sourcemapId) {
+        throw new Error(`Source map ID for platform '${platform}' not found in the source map info file.`);
+    }
+    return sourcemapId;
+};
+exports.readSourcemapId = readSourcemapId;

package/dist/upload.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadSourcemap = void 0;
+const axios_1 = __importDefault(require("axios"));
+const fs_1 = __importDefault(require("fs"));
+const node_zlib_1 = require("node:zlib");
+const path_1 = __importDefault(require("path"));
+const logger_1 = require("./logger");
+const uploadSourcemap = async (filePath, platform, sourcemapId, tokenType, authToken, baseUrl) => {
+    const endpoint = `${baseUrl}/v1/react-symbols/${sourcemapId}?platform=${platform}`;
+    const fileName = path_1.default.basename(filePath);
+    if (!fs_1.default.existsSync(filePath)) {
+        logger_1.log.error(`File ${filePath} not found`);
+        throw new Error(`File not found: ${filePath}`);
+    }
+    const gzippedFileName = `${fileName}.gz`;
+    logger_1.log.verbose(`Compressing file ${fileName} to ${gzippedFileName} ...`);
+    // Compress the file using gzip
+    const gzip = (0, node_zlib_1.createGzip)();
+    const source = fs_1.default.createReadStream(filePath);
+    const destination = fs_1.default.createWriteStream(gzippedFileName);
+    return new Promise((resolve, reject) => {
+        source
+            .pipe(gzip)
+            .pipe(destination)
+            .on('finish', async () => {
+            try {
+                logger_1.log.verbose(`Uploading compressed file ${gzippedFileName} to ${endpoint} ...`);
+                const gzippedFileStream = fs_1.default.createReadStream(gzippedFileName);
+                await axios_1.default.post(endpoint, gzippedFileStream, {
+                    headers: {
+                        'Content-Encoding': 'gzip',
+                        'Content-Type': 'application/octet-stream',
+                        Authorization: `${tokenType[0].toUpperCase() + tokenType.slice(1)} ${authToken}`,
+                    },
+                });
+                // Clean up the gzipped file
+                fs_1.default.unlinkSync(gzippedFileName);
+                logger_1.log.verbose(`File ${gzippedFileName} uploaded and removed locally.`);
+                resolve();
+            }
+            catch (error) {
+                fs_1.default.unlinkSync(gzippedFileName);
+                logger_1.log.error(`Error uploading file ${gzippedFileName} to ${endpoint}`);
+                reject(new Error(`Error uploading file: ${error}`));
+            }
+        })
+            .on('error', (error) => {
+            logger_1.log.error(`Error compressing file ${fileName}: ${error.message}`);
+            reject(new Error(`Error compressing file: ${error.message}`));
+        });
+    });
+};
+exports.uploadSourcemap = uploadSourcemap;

package/dist/utils.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPlatformSelection = exports.ensureHttps = void 0;
+/**
+ * Adds https prefix to a URL if not already present.
+ * @param {string} url - The URL to check and modify.
+ * @returns {string} - The URL with https prefix.
+ */
+const ensureHttps = (url) => {
+    if (!url.startsWith('http://') && !url.startsWith('https://')) {
+        return `https://${url}`;
+    }
+    return url;
+};
+exports.ensureHttps = ensureHttps;
+/**
+ * Returns the exclusive platform selection based on the input, defaults to both platforms.
+ * @param {string} platform - The platform to check.
+ * @returns {Array<'ios' | 'android'>} - The platform selection.
+ */
+const getPlatformSelection = (platform) => {
+    return platform ? [platform] : ['ios', 'android'];
+};
+exports.getPlatformSelection = getPlatformSelection;

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@contentsquare/react-native-cli",
+  "version": "1.0.0",
+  "description": "CLI tool from Contentsquare to upload source maps for React Native apps",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "bin": {
+    "contentsquare-cli": "dist/index.js"
+  },
+  "files": [
+    "/README.md",
+    "/LICENSE",
+    "/dist/",
+    "/bin/",
+    "/scripts/"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "pack": "yarn pack --out %s-v%v.tgz",
+    "test": "jest",
+    "publish": "yarn npm publish --access public",
+    "publish:beta": "yarn npm publish --access public --tag beta",
+    "prepack": "echo 'TODO: Make it call 'yarn test' before packing'",
+    "postinstall": "chmod +x ./scripts/contentsquare-xcode.sh && chmod +x ./scripts/ios-config.sh"
+  },
+  "dependencies": {
+    "axios": "^1.15.0",
+    "commander": "^7.2.0",
+    "fs": "0.0.2",
+    "path": "0.12.7",
+    "uuid": "10.0.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.13",
+    "@types/node": "20.14.2",
+    "@types/uuid": "^9.0.8",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.2.5",
+    "typescript": "^4.0.0"
+  }
+}

package/scripts/contentsquare-xcode.sh

@@ -0,0 +1,35 @@
+#!/bin/bash
+# This script is supposed to be invoked as part of Xcode build process
+# and relies on environment variables (including PWD) set by Xcode
+
+# Print commands before executing them (useful for troubleshooting)
+set -x -e
+
+# Path to contentsquare-cli folder inside node_modules
+CONTENTSQUARE_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+
+# Path to react-native folder inside node_modules
+REACT_NATIVE_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/../../../react-native" && pwd)"
+
+# Read the path to Contentsquare cli config file, default is ./contentsquare-cli.json
+CONTENTSQUARE_CONFIG_PATH=${CONTENTSQUARE_CONFIG_PATH:-"./contentsquare-cli.json"}
+
+# check and assign NODE_BINARY env
+source "$REACT_NATIVE_DIR/scripts/node-binary.sh"
+
+# Define the path to react-native-xcode.sh
+REACT_NATIVE_XCODE="$REACT_NATIVE_DIR/scripts/react-native-xcode.sh"
+
+# Change directory to React Native project root directory, so contentsquare-cli can be called from proper location
+cd ..
+echo "Changed directory to: $(pwd)"
+
+# Pre-build step: Any specific tasks you need to run before react-native-xcode.sh
+"$NODE_BINARY" ./node_modules/.bin/contentsquare-cli update-sourcemap-id --platform ios
+
+/bin/sh -c "$REACT_NATIVE_XCODE"
+
+# Post-build step: Any tasks you want to execute after react-native-xcode.sh
+"$NODE_BINARY" ./node_modules/.bin/contentsquare-cli upload-sourcemaps --config "$CONTENTSQUARE_CONFIG_PATH" --platform ios
+
+/bin/sh -c "$CONTENTSQUARE_DIR/scripts/ios-config.sh"

package/scripts/contentsquare.gradle

@@ -0,0 +1,33 @@
+import groovy.json.JsonSlurper
+
+// Apply the local source-map.gradle file as a script
+apply from: "$rootDir/../node_modules/@contentsquare/react-native-cli/scripts/source-maps.gradle"
+println "Source maps gradle script applied."
+
+android.applicationVariants.all { variant ->
+    def flavorName = variant.flavorName?.capitalize() ?: "NoFlavor"
+    def buildTypeName = variant.buildType.name.capitalize()
+    def buildVariant = "${flavorName}${buildTypeName}" 
+
+    // Determine contentsquareConfigPath, log both custom and default paths
+    def contentsquareConfigPath = project.hasProperty("contentsquareConfigPath${buildVariant}") ?
+            project["contentsquareConfigPath${buildVariant}"] :
+            project.contentsquareConfigPath
+
+    def contentsquareConfigPathAdjusted = "../${contentsquareConfigPath}" 
+    println "Using Contentsquare config path for ${buildVariant}: ${contentsquareConfigPathAdjusted}"
+
+    // Check if contentsquareConfigPathAdjusted is defined
+    if (contentsquareConfigPathAdjusted == null) {
+        println "ERROR: Contentsquare config path is not defined for ${buildVariant}."
+        return
+    }
+
+    def buildType = variant.buildType
+    def productFlavor = variant.productFlavors.isEmpty() ? null : variant.productFlavors[0]
+
+    def crashExtension = productFlavor?.extensions?.findByName("errorAnalysisCrash")
+            ?: buildType?.extensions?.findByName("errorAnalysisCrash")
+
+    crashExtension?.reactNativeCredentialsFile { file(contentsquareConfigPathAdjusted) }
+}

package/scripts/ios-config.sh

@@ -0,0 +1,29 @@
+#!/bin/bash
+
+# Print commands before executing them (useful for troubleshooting)
+set -x -e
+
+# Read the path to Contentsquare CLI config file, default is ./contentsquare-cli.json
+CONTENTSQUARE_CONFIG_PATH=${CONTENTSQUARE_CONFIG_PATH:-"./contentsquare-cli.json"}
+
+# TODO: Have to use this workaround that depends on env var, upload-symbols script does not support --url argument
+CONTENTSQUARE_STAGING=${CONTENTSQUARE_STAGING:-"false"}
+
+extract_ios_json_value() {
+  local key=$1
+  local file=$2
+  grep -A 10 '"ios": {' "$file" | grep -Eo "\"$key\": \".*\"|\"$key\": [0-9]+" | sed -E "s/\"$key\": \"(.*)\"/\1/" | sed -E "s/\"$key\": ([0-9]+)/\1/"
+}
+
+# Extract values from the "ios" object in the JSON file
+CLIENT_ID=$(extract_ios_json_value "clientId" "$CONTENTSQUARE_CONFIG_PATH")
+CLIENT_SECRET=$(extract_ios_json_value "clientSecret" "$CONTENTSQUARE_CONFIG_PATH")
+PROJECT_ID=$(extract_ios_json_value "projectId" "$CONTENTSQUARE_CONFIG_PATH")
+
+# Contentsquare script for iOS symbol upload
+# --staging requires you to be connected to the VPN
+${SRCROOT}/upload-symbols ${DWARF_DSYM_FOLDER_PATH} \
+  --project-id $PROJECT_ID \
+  --client-id $CLIENT_ID \
+  --client-secret $CLIENT_SECRET \
+  $( [ "$CONTENTSQUARE_STAGING" = "true" ] && echo "--staging" )

package/scripts/source-maps.gradle

@@ -0,0 +1,223 @@
+import org.apache.tools.ant.taskdefs.condition.Os
+
+afterEvaluate {
+    def androidExtension = extensions.findByName("android")
+
+    if (androidExtension == null || androidExtension.applicationVariants == null) {
+        throw new GradleException("Android extension is missing or not running in the application module. Ensure 'contentsquare.gradle' is applied in the correct module, typically in 'android/app/build.gradle'.")
+    }
+
+    androidExtension.applicationVariants.all { variant ->
+        def flavorName = variant.flavorName.capitalize()
+        def buildTypeName = variant.buildType.name.capitalize()
+        def buildVariant = "${flavorName}${buildTypeName}"
+
+        println "Processing Build Variant: ${buildVariant}"
+
+        def reactConfig = getReactConfig(buildDir, variant)
+        def targetName = reactConfig["targetName"]
+        def targetPath = reactConfig["targetPath"]
+        def reactRoot = file(reactConfig.root)
+
+        def bundleTask = tasks.findByName(reactConfig.bundleTaskName)
+
+        if (bundleTask == null) {
+            logger.info("No JS bundle task found for variant=${targetName}.")
+            return
+        }
+        if (!bundleTask.enabled) {
+            logger.info("JS bundle task for variant=${targetName} is disabled.")
+            return
+        }
+
+        def serviceName = getServiceName(variant)
+        logger.info("Using service name=${serviceName} and version=${variant.versionName} for upload.")
+
+        def bundleAssetName = reactConfig.bundleAssetName
+        def sourceMapsDirectory = file("$buildDir/generated/sourcemaps/react/${targetPath}")
+        def sourceMapFile = file("$sourceMapsDirectory/${bundleAssetName}.map")
+
+        def updateTask = tasks.register("update${targetName}SourceMapsID", Exec) {
+            group = "contentsquare"
+            description = "Updates the source maps ID for the build."
+            
+            workingDir = file(reactConfig.root)
+            commandLine "${getContentsquareCLIExecPath(reactConfig)}",
+                        "update-sourcemap-id",
+                        "--platform",
+                        "android",
+                        "--verbose",
+                        "--working-dir",
+                        reactConfig.root
+        }
+
+        def uploadTask = tasks.register("upload${targetName}SourceMaps") {
+            group = "contentsquare"
+            description = "Uploads source maps to Contentsquare."
+            
+            // Declare inputs so Gradle knows this task depends on these files
+            inputs.file(sourceMapFile)
+            inputs.files(reactConfig.bundleFileResolver)
+
+            doLast {
+                def defaultConfigPath = project.ext.contentsquareConfigPath
+
+                def specificConfigKey = "contentsquareConfigPath${buildVariant}"
+                def specificConfigPath = project.ext.has(specificConfigKey) ? project.ext[specificConfigKey] : null
+
+                def resolvedConfigPath = specificConfigPath ? "$rootDir/${specificConfigPath}" : "$rootDir/${defaultConfigPath}"
+                println "Using config path for ${buildVariant}: ${resolvedConfigPath}"
+
+                def jsBundleFile = reactConfig.bundleFileResolver()
+                if (jsBundleFile == null || !sourceMapFile.exists()) {
+                    throw new GradleException("Source maps or JS bundle file is missing; upload aborted.")
+                }
+                
+                def cliPath = getContentsquareCLIExecPath(reactConfig).toString()
+                def configPath = resolvedConfigPath.toString()
+                def rootPath = reactConfig.root.toString()
+                
+                def command = new ArrayList<String>()
+                command.add(cliPath)
+                command.add("upload-sourcemaps")
+                command.add("--config")
+                command.add(configPath)
+                command.add("--platform")
+                command.add("android")
+                command.add("--verbose")
+                command.add("--working-dir")
+                command.add(rootPath)
+                
+                def processBuilder = new ProcessBuilder(command)
+                processBuilder.directory(reactRoot)
+                processBuilder.redirectErrorStream(true)
+                
+                def process = processBuilder.start()
+                process.inputStream.eachLine { line -> println line }
+                
+                def exitCode = process.waitFor()
+                if (exitCode != 0) {
+                    throw new GradleException("Upload failed with exit code ${exitCode}")
+                } else {
+                    println "Source maps uploaded successfully for variant=${buildVariant}."
+                }   
+            }
+        }
+
+        bundleTask.dependsOn updateTask
+        bundleTask.finalizedBy uploadTask
+        
+        uploadTask.configure {
+            mustRunAfter bundleTask
+        }
+    }
+}
+
+private def getContentsquareCLIExecPath(reactConfig) {
+    def defaultPath = "${reactConfig.root}/node_modules/.bin/contentsquare-cli"
+
+    def envPath = System.getenv('CONTENTSQUARE_CLI_EXEC')
+    if (envPath && isExecutable(envPath)) {
+        return envPath
+    } else if (envPath) {
+        logger.warn("Invalid CONTENTSQUARE_CLI_EXEC path. Falling back to default.", true)
+    }
+
+    def nodeExecutable = Os.isFamily(Os.FAMILY_WINDOWS) ? 'node.exe' : 'node'
+    def nodeScript = '''
+    const path = require('path');
+    const modulePath = require.resolve('@contentsquare/react-native-cli/package.json');
+    const cliPath = path.resolve(path.dirname(modulePath), '../../.bin/contentsquare-cli');
+    console.log(cliPath);
+    '''
+
+    return executeNodeScript(nodeExecutable, nodeScript) ?: defaultPath
+}
+
+private def executeNodeScript(String executable, String script) {
+    try {
+        def process = new ProcessBuilder(executable)
+                .redirectErrorStream(true)
+                .start()
+
+        process.outputStream.withWriter { it.write(script) }
+
+        def output = process.inputStream.text.trim()
+        process.waitFor()
+        return output
+    } catch (Exception e) {
+        logger.error("Failed to execute Node.js script: ${e.message}")
+        return null
+    }
+}
+
+private def isExecutable(String path) {
+    def file = new File(path)
+    return file.exists() && file.canExecute()
+}
+
+private def getReactConfig(File buildDir, variant) {
+    def config = [:]
+
+    if (project.extensions.findByName("react")) {
+        def bundleAssetName = project.extensions.react.bundleAssetName.get() ?: "index.android.bundle"
+        def targetName = variant.name.capitalize()
+        config.bundleTaskName = "createBundle${targetName}JsAndAssets"
+        config.bundleFileResolver = resolveBundleFile([
+                "$buildDir/generated/assets/react/${variant.name}",
+                "$buildDir/ASSETS/createBundle${targetName}JsAndAssets",
+                "$buildDir/generated/assets/createBundle${targetName}JsAndAssets"
+        ], bundleAssetName)
+        config.bundleAssetName = bundleAssetName
+        config.targetPath = variant.name
+        config.targetName = targetName
+        config.root = project.extensions.react.root.get() ?: "../../"
+    } else {
+        def targetName = variant.name.capitalize()
+        def targetPath = variant.dirName
+        config.bundleTaskName = "bundle${targetName}JsAndAssets"
+        config.bundleFileResolver = resolveBundleFile(["$buildDir/generated/assets/react/${targetPath}"], "index.android.bundle")
+        config.targetPath = targetPath
+        config.targetName = targetName
+        config.root = "../../"
+    }
+
+    return config
+}
+
+private def resolveBundleFile(List<String> directories, String fileName) {
+    return {
+        directories.collect { file("$it/$fileName") }.find { it.exists() }
+    }
+}
+
+private def runShellCommand(List<String> command, File workingDir) {
+    def outputStream = new ByteArrayOutputStream()
+    def errorStream = new ByteArrayOutputStream()
+
+    try {
+        def result = project.exec {
+            workingDir = workingDir
+            standardOutput = outputStream
+            errorOutput = errorStream
+            commandLine command
+        }
+
+        if (result.exitValue != 0) {
+            logger.error("Error: ${errorStream.toString('UTF-8')}")
+            result.rethrowFailure()
+        } else {
+            logger.lifecycle("Success: ${outputStream.toString('UTF-8')}")
+        }
+    } catch (Exception e) {
+        logger.error("Command execution failed: ${e.message}")
+        throw e
+    }
+}
+
+private def getServiceName(variant) {
+    if (project.hasProperty("contentsquare") && project.contentsquare.serviceName) {
+        return project.contentsquare.serviceName
+    }
+    return variant.applicationId
+}