airborne-devkit 0.26.1 → 0.28.0

package/CHANGELOG.md

@@ -2,6 +2,84 @@
 All notable changes to this project will be documented in this file. See [conventional commits](https://www.conventionalcommits.org/) for commit guidelines.
 
 - - -
+## airborne_cli-v0.3.0 - 2026-03-26
+#### Features
+- add platform-specific configuration and improve file processing and update smithy-cli-generator submodule - (823cfe5) - Yash Rajput
+
+- - -
+
+## v0.27.0 - 2026-03-26
+#### Miscellaneous Chores
+- **(version)** v0.27.0 [skip ci] - (75587e4) - Airborne Bot
+
+- - -
+
+## v0.26.1 - 2026-03-26
+#### Miscellaneous Chores
+- **(version)** v0.26.1 [skip ci] - (7b0b420) - Airborne Bot
+
+- - -
+
+## v0.26.0 - 2026-03-26
+#### Miscellaneous Chores
+- **(version)** v0.26.0 [skip ci] - (e987bfa) - Airborne Bot
+
+- - -
+
+## v0.25.0 - 2026-03-26
+#### Miscellaneous Chores
+- **(version)** v0.25.0 [skip ci] - (8a22156) - Airborne Bot
+
+- - -
+
+## v0.24.4 - 2026-03-26
+#### Miscellaneous Chores
+- **(version)** v0.24.4 [skip ci] - (3398e93) - Airborne Bot
+
+- - -
+
+## v0.24.3 - 2026-03-26
+#### Miscellaneous Chores
+- **(version)** v0.24.3 [skip ci] - (bd6d431) - Airborne Bot
+
+- - -
+
+## v0.24.2 - 2026-03-26
+#### Miscellaneous Chores
+- **(version)** v0.24.2 [skip ci] - (3c27527) - Airborne Bot
+
+- - -
+
+## v0.24.1 - 2026-03-26
+#### Miscellaneous Chores
+- **(version)** v0.24.1 [skip ci] - (c89ac50) - Airborne Bot
+
+- - -
+
+## v0.24.0 - 2026-03-26
+#### Miscellaneous Chores
+- **(version)** v0.24.0 [skip ci] - (d127ca2) - Airborne Bot
+
+- - -
+
+## v0.23.3 - 2026-03-26
+#### Miscellaneous Chores
+- **(version)** v0.23.3 [skip ci] - (fea39f7) - Airborne Bot
+
+- - -
+
+## v0.23.2 - 2026-03-26
+#### Miscellaneous Chores
+- **(version)** v0.23.2 [skip ci] - (1a6ac61) - Airborne Bot
+
+- - -
+
+## v0.23.1 - 2026-03-26
+#### Miscellaneous Chores
+- **(version)** v0.23.1 [skip ci] - (1644fd6) - Airborne Bot
+
+- - -
+
 ## airborne_cli-v0.2.0 - 2026-02-05
 #### Features
 - add Expo project support in cli - (751a4f5) - Yash Rajput

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "airborne-devkit",
-  "version": "0.26.1",
+  "version": "0.28.0",
   "description": "Cli for Airborne",
   "main": "src/index.js",
   "type": "module",

package/src/index.js

@@ -3,7 +3,7 @@
 import { Command, InvalidOptionArgumentError } from "commander";
 import coreCli from "airborne-core-cli";
 import {
-  readAirborneConfig,
+  readAndResolveAirborneConfig,
   writeAirborneConfig,
   normalizeOptions,
   formatCommand,
@@ -17,16 +17,27 @@ import {
   readReleaseConfig,
   releaseConfigExists,
   updateLocalReleaseConfig,
+  writeReleaseConfig,
 } from "./utils/release.js";
 import { createFiles, uploadFiles } from "./utils/file.js";
 import { createPackageFromLocalRelease } from "./utils/package.js";
 import { PostLoginAction } from "airborne-core-cli/action";
+import { getBaseUrl, setBaseUrl } from "airborne-core-cli";
 const program = new Command();
 
+try{
+  const baseUrl = await getBaseUrl();
+  if(!baseUrl){
+    await setBaseUrl("https://airborne.juspay.in");
+  }
+}catch(err){
+   await setBaseUrl("https://airborne.juspay.in");
+}
+
 program
   .name("airborne-devkit")
   .description("Command-line interface for Airborne operations")
-  .version("0.26.1");
+  .version("0.28.0");
 
 coreCli.commands.forEach((cmd, i) => {
   if (cmd._name !== "PostLogin") {
@@ -48,8 +59,10 @@ program
 
   Usage 2 - With all options specified:
     $ airborne-devkit create-local-airborne-config [directoryPath] \\
-      -o <organisation> \\
-      -n <namespace> \\
+      --android-organisation <android-organisation> \\
+      --ios-organisation <ios-organisation> \\
+      --android-namespace <android-namespace> \\
+      --ios-namespace <ios-namespace> \\
       -j <js-entry-file> \\
       -a <android-index-file> \\
       -i <ios-index-file> \\
@@ -57,8 +70,10 @@ program
 
   Parameters:
       [directoryPath] (optional) : Directory where config will be created (defaults to current directory)
-      -o, --organisation <string> (optional) : Organisation name of the package
-      -n, --namespace <string> (optional) : Namespace or application name of the package
+      --android-organisation <string> (optional) : Organisation name for Android
+      --ios-organisation <string> (optional) : Organisation name for iOS
+      --android-namespace <string> (optional) : Namespace or application name for Android
+      --ios-namespace <string> (optional) : Namespace or application name for iOS
       -j, --js-entry-file <string> (optional) : Path to the JavaScript entry file
       -a, --android-index-file <string> (optional) : Path to the Android bundle output file
       -i, --ios-index-file <string> (optional) : Path to the iOS bundle output file
@@ -66,10 +81,21 @@ program
 
 `
   )
-  .option("-o, --organisation <org>", "Organisation name of the package")
   .option(
-    "-n, --namespace <namespace>",
-    "Namespace or application name of the package"
+    "--android-organisation <org>",
+    "Organisation name for Android"
+  )
+  .option(
+    "--ios-organisation <org>",
+    "Organisation name for iOS"
+  )
+  .option(
+    "--android-namespace <namespace>",
+    "Namespace or application name for Android"
+  )
+  .option(
+    "--ios-namespace <namespace>",
+    "Namespace or application name for iOS"
   )
   .option("-j, --js-entry-file <path>", "Path to the JavaScript entry file")
   .option(
@@ -91,29 +117,35 @@ Examples:
 
 3. Create config with all options specified:
    $ airborne-devkit create-local-airborne-config \\
-     -o "MyCompany" \\
-     -n "MyApp" \\
+     --android-organisation "MyCompany" \\
+     --ios-organisation "MyCompany" \\
+     --android-namespace "MyApp" \\
+     --ios-namespace "MyApp" \\
      -j "index.js" \\
      -a "android/app/build/generated/assets/react/release/index.android.bundle" \\
      -i "ios/main.jsbundle"
 
 4. Create config in specific directory with options:
    $ airborne-devkit create-local-airborne-config ./my-rn-project \\
-     -o "MyCompany" \\
-     -n "MyApp"
+     --android-organisation "MyCompany" \\
+     --ios-organisation "MyCompany" \\
+     --android-namespace "MyApp" \\
+     --ios-namespace "MyApp"
 
 5. Create config for an Expo project:
    $ airborne-devkit create-local-airborne-config -e
 
 6. Create config for Expo project with all options:
    $ airborne-devkit create-local-airborne-config \\
-     -o "MyCompany" \\
-     -n "MyApp" \\
+     --android-organisation "MyCompany" \\
+     --ios-organisation "MyCompany" \\
+     --android-namespace "MyApp" \\
+     --ios-namespace "MyApp" \\
      -e
 
 Notes:
 - If directoryPath is not provided, current working directory will be used
-- If organisation or namespace and others are not provided, you'll be prompted to enter them
+- If organisations, namespaces, and others are not provided, you'll be prompted to enter them
 - Command will fail if an airborne config already exists in the target directory`
   )
   .action(async (directoryPath, options) => {
@@ -245,8 +277,9 @@ Notes:
         );
       }
       const normalizedOptions = normalizeOptions(options);
-      const airborneConfig = await readAirborneConfig(
-        normalizedOptions.directory_path
+      const airborneConfig = await readAndResolveAirborneConfig(
+        normalizedOptions.directory_path,
+        normalizedOptions.platform
       );
       const releaseConfig = await releaseConfigExists(
         normalizedOptions.directory_path,
@@ -383,7 +416,10 @@ Notes:
       }
       const normalizedOptions = normalizeOptions(options);
 
-      const config = await readAirborneConfig(normalizedOptions.directory_path);
+      const config = await readAndResolveAirborneConfig(
+        normalizedOptions.directory_path,
+        options.platform
+      );
       await updateLocalReleaseConfig(
         config,
         normalizedOptions,
@@ -492,8 +528,9 @@ Notes:
         );
       }
       const normalizedOptions = normalizeOptions(options);
-      let airborneConfig = await readAirborneConfig(
-        normalizedOptions.directory_path
+      let airborneConfig = await readAndResolveAirborneConfig(
+        normalizedOptions.directory_path,
+        normalizedOptions.platform
       );
 
       airborneConfig = { ...airborneConfig, ...normalizedOptions };
@@ -502,27 +539,81 @@ Notes:
         airborneConfig.platform,
         airborneConfig.namespace
       );
-      const filesToUpload = releaseConfig.package.important.concat(
-        releaseConfig.package.index
-      );
+
       try {
         airborneConfig.token = await loadToken(normalizedOptions.directory_path)
           .access_token;
       } catch (err) {
         throw new Error("Please log in first");
       }
+
+      let baseUrl;
       if (!options.upload) {
-        let baseUrl = await promptWithType(
+        baseUrl = await promptWithType(
           "\n Provide your base url for files: ",
           "string"
         );
         if (baseUrl[baseUrl.length - 1] !== "/") {
           baseUrl = baseUrl + "/";
         }
-        await createFiles(filesToUpload, airborneConfig, baseUrl);
-      } else {
-        await uploadFiles(filesToUpload, airborneConfig);
       }
+
+      const processFiles = async (files) => {
+        if (!files || files.length === 0) return;
+        if (options.upload) {
+          return await uploadFiles(files, airborneConfig);
+        } else {
+          return await createFiles(files, airborneConfig, baseUrl);
+        }
+      };
+
+      const applyResults = (entries, results) => {
+        if (!entries || !results) return;
+        for (const entry of entries) {
+          if (results[entry.file_path]) {
+            entry.url = results[entry.file_path].url;
+            entry.checksum = results[entry.file_path].checksum;
+          }
+        }
+      };
+
+      console.log("Processing index file");
+      const indexFiles = [releaseConfig.package.index];
+      const indexResults = await processFiles(indexFiles);
+      applyResults(indexFiles, indexResults);
+      releaseConfig.package.index = indexFiles[0];
+
+      const importantFiles = releaseConfig.package.important || [];
+      if (importantFiles.length > 0) {
+        console.log("Processing important files");
+        const importantResults = await processFiles(importantFiles);
+        applyResults(importantFiles, importantResults);
+        releaseConfig.package.important = importantFiles;
+      }
+
+      const lazyFiles = releaseConfig.package.lazy || [];
+      if (lazyFiles.length > 0) {
+        console.log("Processing lazy files");
+        const lazyResults = await processFiles(lazyFiles);
+        applyResults(lazyFiles, lazyResults);
+        releaseConfig.package.lazy = lazyFiles;
+      }
+
+      const resourceFiles = releaseConfig.resources || [];
+      if (resourceFiles.length > 0) {
+        console.log("Processing resource files");
+        const resourceResults = await processFiles(resourceFiles);
+        applyResults(resourceFiles, resourceResults);
+        releaseConfig.resources = resourceFiles;
+      }
+
+      await writeReleaseConfig(
+        releaseConfig,
+        airborneConfig.platform,
+        airborneConfig.namespace,
+        airborneConfig.directory_path
+      );
+
       process.exit(0);
     } catch (err) {
       console.error("❌ Failed to create remote files:", err.message);
@@ -631,8 +722,9 @@ Notes:
         );
       }
       const normalizedOptions = normalizeOptions(options);
-      let airborneConfig = await readAirborneConfig(
-        normalizedOptions.directory_path
+      let airborneConfig = await readAndResolveAirborneConfig(
+        normalizedOptions.directory_path,
+        normalizedOptions.platform
       );
 
       airborneConfig = { ...airborneConfig, ...normalizedOptions };

package/src/utils/common.js

@@ -4,11 +4,76 @@ import { createHash } from "crypto";
 import { createReadStream } from "fs";
 import { promptWithType } from "./prompt.js";
 
+function persistToConfig(configPath, platform, fields, label) {
+  try {
+    const raw = JSON.parse(fs.readFileSync(configPath, "utf8"));
+    if (!raw[platform]) {
+      raw[platform] = {};
+    }
+    for (const [key, value] of Object.entries(fields)) {
+      raw[platform][key] = value;
+    }
+    fs.writeFileSync(configPath, JSON.stringify(raw, null, 2), "utf8");
+    const keys = Object.keys(fields).join(", ");
+    console.log(`✅ Updated ${label} ${keys} in ${configPath}`);
+  } catch (err) {
+    console.error(
+      `⚠️  Could not persist ${label} config to file:`,
+      err.message
+    );
+  }
+}
+
+export async function readAndResolveAirborneConfig(directoryPath, platform) {
+  const airborneConfig = await readAirborneConfig(directoryPath);
+  const configPath = path.join(directoryPath, "airborne-config.json");
+  const label = platform === "android" ? "Android" : "iOS";
+
+  if (!airborneConfig[platform]) {
+    airborneConfig[platform] = {};
+  }
+
+  const fieldsToPersist = {};
+
+  if (!airborneConfig[platform].organisation) {
+    const oldOrganisation = airborneConfig.organisation || undefined;
+
+    airborneConfig[platform].organisation = await promptWithType(
+      `\n Please enter the ${label} organisation name${oldOrganisation ? ` (default: ${oldOrganisation})` : ""}: `,
+      "string",
+      oldOrganisation
+    );
+    fieldsToPersist.organisation = airborneConfig[platform].organisation;
+  }
+
+  if (!airborneConfig[platform].namespace) {
+    const oldNamespace = airborneConfig.namespace || undefined;
+
+    airborneConfig[platform].namespace = await promptWithType(
+      `\n Please enter the ${label} namespace/application name${oldNamespace ? ` (default: ${oldNamespace})` : ""}: `,
+      "string",
+      oldNamespace
+    );
+    fieldsToPersist.namespace = airborneConfig[platform].namespace;
+  }
+
+  if (Object.keys(fieldsToPersist).length > 0) {
+    persistToConfig(configPath, platform, fieldsToPersist, label);
+  }
+
+  airborneConfig.namespace = airborneConfig[platform].namespace;
+  airborneConfig.organisation = airborneConfig[platform].organisation;
+
+  return airborneConfig;
+}
+
 const cliToConfigMap = {
   platform: "platform",
   tag: "tag",
-  organisation: "organisation",
-  namespace: "namespace",
+  androidOrganisation: "android.organisation",
+  iosOrganisation: "ios.organisation",
+  androidNamespace: "android.namespace",
+  iosNamespace: "ios.namespace",
   jsEntryFile: "js_entry_file",
   androidIndex: "android.index_file_path",
   iosIndex: "ios.index_file_path",
@@ -55,14 +120,16 @@ export async function writeAirborneConfig(options) {
   try {
     const filledOptions = await fillAirborneConfigOptions(options);
     const config = {
-      organisation: filledOptions.organisation,
-      namespace: filledOptions.namespace,
       expo: filledOptions.expo,
       js_entry_file: filledOptions.js_entry_file,
       android: {
+        organisation: filledOptions.android.organisation,
+        namespace: filledOptions.android.namespace,
         index_file_path: filledOptions.android.index_file_path,
       },
       ios: {
+        organisation: filledOptions.ios.organisation,
+        namespace: filledOptions.ios.namespace,
         index_file_path: filledOptions.ios.index_file_path,
       },
     };
@@ -107,13 +174,23 @@ export async function fillAirborneConfigOptions(options = {}) {
 
   const questions = [
     {
-      key: "organisation",
-      question: "\n Please enter the organisation name: ",
+      key: "android.organisation",
+      question: "\n Please enter the Android organisation name: ",
+      expectedType: "string",
+    },
+    {
+      key: "ios.organisation",
+      question: "\n Please enter the iOS organisation name: ",
+      expectedType: "string",
+    },
+    {
+      key: "android.namespace",
+      question: "\n Please enter the Android namespace/application name: ",
       expectedType: "string",
     },
     {
-      key: "namespace",
-      question: "\n Please enter namespace/application name: ",
+      key: "ios.namespace",
+      question: "\n Please enter the iOS namespace/application name: ",
       expectedType: "string",
     },
     {

package/src/utils/file.js

@@ -82,6 +82,8 @@ export const uploadFiles = async (filesToUpload, config) => {
     errors: [],
   };
 
+  const fileResults = {};
+
   try {
     for (let index = 0; index < filesToUpload.length; index++) {
       const fileObj = filesToUpload[index];
@@ -90,10 +92,10 @@ export const uploadFiles = async (filesToUpload, config) => {
       try {
         console.log(`${fileProgress} 🔍 Processing ${fileObj.file_path}...`);
 
-        const storedChecksum = await getMappedChecksum(
+        const stored = await getMappedChecksumAndURL(
           config.directory_path,
           fileObj.file_path,
-          config.tag
+          config
         );
 
         const baseDir = path.isAbsolute(config.directory_path)
@@ -115,10 +117,11 @@ export const uploadFiles = async (filesToUpload, config) => {
 
         const checksum = await sha256FileHex(fileFullPath);
 
-        if (storedChecksum === checksum) {
+        if (stored?.checksum === checksum) {
           console.log(
             `${fileProgress} ✅ File already exists, checksum matches`
           );
+          fileResults[fileObj.file_path] = { url: stored.url, checksum: stored.checksum };
           results.existing++;
           continue;
         }
@@ -144,11 +147,18 @@ export const uploadFiles = async (filesToUpload, config) => {
         await createFileMapping(
           config.directory_path,
           uploadOutput.file_path,
-          uploadOutput.id,
-          uploadOutput.checksum,
-          uploadOutput.tag
+          {
+            id: uploadOutput.id,
+            checksum: uploadOutput.checksum,
+            url: uploadOutput.url,
+            organisation: config.organisation,
+            namespace: config.namespace,
+            tag: uploadOutput.tag,
+          }
         );
 
+        fileResults[fileObj.file_path] = { url: uploadOutput.url, checksum: uploadOutput.checksum };
+
         // Check if this was a new upload or existing file returned
         if (uploadOutput.checksum === checksum) {
           console.log(
@@ -185,6 +195,8 @@ export const uploadFiles = async (filesToUpload, config) => {
     console.error("\n💥 Upload process failed:", err.message);
     throw err;
   }
+
+  return fileResults;
 };
 
 export async function createFiles(filesToCreate, config, prefixUrl) {
@@ -199,6 +211,8 @@ export async function createFiles(filesToCreate, config, prefixUrl) {
     errors: [],
   };
 
+  const fileResults = {};
+
   try {
     for (let index = 0; index < filesToCreate.length; index++) {
       const fileObj = filesToCreate[index];
@@ -207,10 +221,10 @@ export async function createFiles(filesToCreate, config, prefixUrl) {
       try {
         console.log(`${fileProgress} 🔍 Processing ${fileObj.file_path}...`);
 
-        const storedChecksum = await getMappedChecksum(
+        const stored = await getMappedChecksumAndURL(
           config.directory_path,
           fileObj.file_path,
-          config.tag
+          config
         );
 
         const baseDir = path.isAbsolute(config.directory_path)
@@ -230,14 +244,15 @@ export async function createFiles(filesToCreate, config, prefixUrl) {
           throw new Error(`File not found: ${fileFullPath}`);
         }
 
-        if (storedChecksum) {
+        if (stored?.checksum) {
           console.log(`${fileProgress} 🔐 Calculating checksum...`);
           const checksum = await sha256FileHex(fileFullPath);
 
-          if (storedChecksum === checksum) {
+          if (stored.checksum === checksum) {
             console.log(
               `${fileProgress} ✅ File already exists, checksum matches`
             );
+            fileResults[fileObj.file_path] = { url: stored.url, checksum: stored.checksum };
             results.existing++;
             continue;
           }
@@ -270,11 +285,18 @@ export async function createFiles(filesToCreate, config, prefixUrl) {
         await createFileMapping(
           config.directory_path,
           output.file_path,
-          output.id,
-          output.checksum,
-          output.tag
+          {
+            id: output.id,
+            checksum: output.checksum,
+            url: output.url,
+            organisation: config.organisation,
+            namespace: config.namespace,
+            tag: output.tag,
+          }
         );
 
+        fileResults[fileObj.file_path] = { url: output.url, checksum: output.checksum };
+
         console.log(
           `${fileProgress} ✅ Successfully processed file record for ${fileObj.file_path}`
         );
@@ -304,14 +326,14 @@ export async function createFiles(filesToCreate, config, prefixUrl) {
     console.error("\n💥 File creation process failed:", err.message);
     throw err;
   }
+
+  return fileResults;
 }
 
 export async function createFileMapping(
   directory_path,
   file_path,
-  id,
-  checksum,
-  tag
+  { id, checksum, url, organisation, namespace, tag }
 ) {
   const airborneDir = path.join(directory_path, ".airborne");
   const mappingFile = path.join(airborneDir, "mappings.json");
@@ -329,12 +351,18 @@ export async function createFileMapping(
       tag = "__default__";
     }
 
-    if (!mappings[tag]) {
-      mappings[tag] = {};
+    if (!mappings[organisation]) {
+      mappings[organisation] = {};
+    }
+    if (!mappings[organisation][namespace]) {
+      mappings[organisation][namespace] = {};
+    }
+    if (!mappings[organisation][namespace][tag]) {
+      mappings[organisation][namespace][tag] = {};
     }
 
-    // Update or insert mapping with checksum
-    mappings[tag][file_path] = { id, checksum };
+    // Update or insert mapping with checksum and url
+    mappings[organisation][namespace][tag][file_path] = { id, checksum, url };
 
     // Write updated mappings back
     await fs.promises.writeFile(
@@ -348,7 +376,7 @@ export async function createFileMapping(
   }
 }
 
-export async function getMappedChecksum(directory_path, file_path, tag) {
+export async function getMappedChecksumAndURL(directory_path, file_path, { organisation, namespace, tag }) {
   const mappingFile = path.join(directory_path, ".airborne", "mappings.json");
   if (!tag) {
     tag = "__default__";
@@ -357,13 +385,15 @@ export async function getMappedChecksum(directory_path, file_path, tag) {
   try {
     const data = await fs.promises.readFile(mappingFile, "utf8");
     const mappings = JSON.parse(data);
-    return mappings[tag][file_path]?.checksum || null;
+    const entry = mappings[organisation]?.[namespace]?.[tag]?.[file_path];
+    if (!entry) return null;
+    return { checksum: entry.checksum || null, url: entry.url || null };
   } catch (err) {
     return null;
   }
 }
 
-export async function readFileMapping(directory_path, file_path, tag) {
+export async function readFileMapping(directory_path, file_path, { organisation, namespace, tag }) {
   const mappingFile = path.join(directory_path, ".airborne", "mappings.json");
 
   if (!tag) {
@@ -373,7 +403,7 @@ export async function readFileMapping(directory_path, file_path, tag) {
   try {
     const data = await fs.promises.readFile(mappingFile, "utf8");
     const mappings = JSON.parse(data);
-    return mappings[tag][file_path] || null;
+    return mappings[organisation]?.[namespace]?.[tag]?.[file_path] || null;
   } catch (err) {
     return null;
   }

package/src/utils/package.js

@@ -17,7 +17,7 @@ export async function createPackageFromLocalRelease(
     const indexMapping = await readFileMapping(
       airborneConfig.directory_path,
       indexFilePath,
-      airborneConfig.tag
+      airborneConfig
     );
     if (!indexMapping) {
       throw new Error(`Missing upload for index file: ${indexFilePath}`);
@@ -36,7 +36,7 @@ export async function createPackageFromLocalRelease(
       const mapping = await readFileMapping(
         airborneConfig.directory_path,
         file_path,
-        airborneConfig.tag
+        airborneConfig
       );
       if (!mapping) {
         throw new Error(`Missing mapping for file: ${file_path}`);

package/src/utils/release.js

@@ -141,11 +141,13 @@ export async function createLocalReleaseConfig(
         properties: {},
       },
       package: {
+        name: airborneConfig.namespace,
         version: "",
         prooerties: {},
         index: {
           file_path: airborneConfig[platform].index_file_path,
           url: "",
+          checksum: "",
         },
         important: remotebundleContents
           .filter(
@@ -291,11 +293,13 @@ export async function updateLocalReleaseConfig(
         properties: existingReleaseConfig?.config?.properties || {},
       },
       package: {
+        name: airborneConfig.namespace,
         version: existingReleaseConfig?.package?.version || "",
         properties: existingReleaseConfig?.package?.properties || {},
         index: {
           file_path: airborneConfig[options.platform].index_file_path,
-          url: existingReleaseConfig?.package?.index?.url || "",
+          url: "",
+          checksum: "",
         },
         important: remotebundleContents
           .filter(
@@ -305,10 +309,14 @@ export async function updateLocalReleaseConfig(
           .map((item) => ({
             file_path: item.path,
             url: "",
+            checksum: "",
           })),
-        lazy: existingReleaseConfig?.package?.lazy || [],
+        lazy: [],
       },
-      resources: existingReleaseConfig?.resources || [],
+      resources: (existingReleaseConfig?.resources || []).filter(
+        (res) =>
+          !remotebundleContents.some((item) => item.path === res.file_path)
+      ),
     };
 
     await writeReleaseConfig(