diff --git a/.gitignore b/.gitignore
index c51f72aea4f1c609fe75a2f4e84acba5846a877b..e74e90f0e84d4ef1662eea56d30dc5cea687bd4c 100755
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +1,2 @@
 jar
-.idea/
+.*
\ No newline at end of file
diff --git a/BUILD.gn b/BUILD.gn
index 5b65edddb8bc3768c2cea3baf6d0886690f862fb..55ddcd1827aaddcd0d6773a7dc75afece789582d 100755
--- a/BUILD.gn
+++ b/BUILD.gn
@@ -63,3 +63,7 @@ ohos_prebuilt_etc("fastjson-1.2.83") {
   source = "//prebuilts/packing_tool/fastjson-1.2.83.jar"
   install_enable = false
 }
+
+ohos_group("ohos_packing_tool") {
+  deps = [ "ohos_packing_tool/frameworks:ohos_packing_tool" ]
+}
diff --git a/README_zh.md b/README_zh.md
index 85914a390aedf2a56fa1c086311732c767224927..268852d94f9300cc531813322dfc3aee163df11b 100644
--- a/README_zh.md
+++ b/README_zh.md
@@ -52,6 +52,7 @@ java -jar app_packing_tool.jar --mode hap --json-path <option> --maple-so-path [
 | --dir-list       | 否     | NA                   | 可指定目标文件夹列表，将其打入hap包内。                                   | NA         |
 | --compress-level | 否     | number               | 压缩等级，默认值1，可选等级1-9。在应用配置compressNativeLibs参数为true的情况下生效，数值越大压缩率越高、压缩速度越慢。  | NA    |
 | --pkg-context-path      | 否         | NA            | 可指定语境信息表文件路径，文件名必须为pkgContextInfo.json。 | 仅stage模型生效              |
+| --hnp-path | 否 | NA | 指定native软件包文件路径，将native软件包打入hap包内。 | NA |
 
 ### 1.2 har包模式打包指令
 
diff --git a/adapter/ohos/CommandParser.java b/adapter/ohos/CommandParser.java
index ef7c82d41fd0fe708a83daaede0c66ead5e95aa2..a12189b168048218a36626134ab00324126394d4 100644
--- a/adapter/ohos/CommandParser.java
+++ b/adapter/ohos/CommandParser.java
@@ -41,6 +41,7 @@ public class CommandParser {
     private static final String CMD_INDEX_PATH = "--index-path";
     private static final String CMD_JS_PATH = "--js-path";
     private static final String CMD_ETS_PATH = "--ets-path";
+    private static final String CMD_HNP_PATH = "--hnp-path";
     private static final String CMD_RPCID_PATH = "--rpcid-path";
     private static final String CMD_RPCID = "--rpcid";
     private static final String CMD_SO_PATH = "--maple-so-path";
@@ -130,6 +131,10 @@ public class CommandParser {
             entry.getKey().setEtsPath(entry.getValue());
             return true;
         });
+        commandFuncs.put(CMD_HNP_PATH, entry -> {
+            entry.getKey().setHnpPath(entry.getValue());
+            return true;
+        });
         commandFuncs.put(CMD_RPCID_PATH, entry -> {
             entry.getKey().setRpcidPath(entry.getValue());
             return true;
diff --git a/adapter/ohos/CompressVerify.java b/adapter/ohos/CompressVerify.java
index 520ee7dcfefc1312543e44bb160ed4784aba3677..ea1a995143d7157354e3a9734986399e1fac9fe8 100644
--- a/adapter/ohos/CompressVerify.java
+++ b/adapter/ohos/CompressVerify.java
@@ -345,6 +345,11 @@ public class CompressVerify {
             return false;
         }
 
+        if (isHapPathValid(utility.getHnpPath())) {
+            LOG.error("CompressVerify::isArgsValidInHapMode hnp-path is invalid.");
+            return false;
+        }
+
         if (isHapPathValid(utility.getResPath())) {
             LOG.error("CompressVerify::isArgsValidInHapMode res-path is invalid.");
             return false;
@@ -382,6 +387,11 @@ public class CompressVerify {
             return false;
         }
 
+        if (!utility.getEtsPath().isEmpty() && !isPathValid(utility.getEtsPath(), TYPE_DIR, null)) {
+            LOG.error("CompressVerify::isArgsValidInHapMode ets-path is invalid.");
+            return false;
+        }
+
         return isOutPathValid(utility, HAP_SUFFIX);
     }
 
@@ -944,6 +954,11 @@ public class CompressVerify {
             }
         }
 
+        if (!utility.getEtsPath().isEmpty() && !isPathValid(utility.getEtsPath(), TYPE_DIR, null)) {
+            LOG.error("CompressVerify::isArgsValidInHspMode ets-path is invalid.");
+            return false;
+        }
+
         return isOutPathValid(utility, HSP_SUFFIX);
     }
 
diff --git a/adapter/ohos/Compressor.java b/adapter/ohos/Compressor.java
index 03e7549a5f800db99a9f818cbb3ae42bf72ea106..46bf900ce5edc963705ad98eb0bdb2bbbd1befc8 100644
--- a/adapter/ohos/Compressor.java
+++ b/adapter/ohos/Compressor.java
@@ -27,6 +27,7 @@ import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.io.OutputStream;
+import java.io.OutputStreamWriter;
 import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
 import java.nio.file.Path;
@@ -118,6 +119,7 @@ public class Compressor {
     private static final String REGEX_SHAPE = "^circle$";
     private static final String JS_PATH = "js/";
     private static final String ETS_PATH = "ets/";
+    private static final String HNP_PATH = "hnp/";
     private static final String TEMP_HAP_DIR = "tempHapDir";
     private static final String TEMP_HSP_DIR = "tempHspDir";
     private static final String TEMP_SELECTED_HAP_DIR = "tempSelectedHapDir";
@@ -133,6 +135,7 @@ public class Compressor {
     private static final String JSON_SUFFIX = ".json";
     private static final String ATOMIC_SERVICE = "atomicService";
     private static final String RAW_FILE_PATH = "resources/rawfile";
+    private static final String SUMMARY = "summary";
     private static final String VERSION_CODE = "versionCode";
     private static final String VERSION_NAME = "versionName";
     private static final String VERSION = "version";
@@ -140,6 +143,7 @@ public class Compressor {
     private static final String VERSION_RECORD = "version_record.json";
     private static final String RES_INDEX = "resources.index";
     private static final String ETS_FILE_NAME = "ets";
+    private static final String HNP_FILE_NAME = "hnp";
     private static final String DIR_FILE_NAME = "dir";
     private static final String AN_FILE_NAME = "an";
     private static final String AP_FILE_NAME = "ap";
@@ -524,7 +528,8 @@ public class Compressor {
             String pretty = JSON.toJSONString(jsonObject, new SerializerFeature[]{
                     SerializerFeature.PrettyFormat, SerializerFeature.WriteMapNullValue,
                     SerializerFeature.WriteDateUseDateFormat});
-            bw = new BufferedWriter(new FileWriter(utility.getJsonPath()));
+            bw = new BufferedWriter(new OutputStreamWriter(
+                    new FileOutputStream(utility.getJsonPath()), StandardCharsets.UTF_8));
             bw.write(pretty);
         } catch (BundleException | IOException | JSONException exception) {
             LOG.error("Compressor::setGenerateBuildHash failed.");
@@ -651,7 +656,7 @@ public class Compressor {
             moduleJson.put(BUILD_HASH, hash);
             String pretty = JSON.toJSONString(jsonObject, SerializerFeature.PrettyFormat,
                     SerializerFeature.WriteMapNullValue, SerializerFeature.WriteDateUseDateFormat);
-            bw = new BufferedWriter(new FileWriter(jsonPath));
+            bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(jsonPath), StandardCharsets.UTF_8));
             bw.write(pretty);
         } catch (IOException e) {
             LOG.error("Compressor::putBuildHash failed, IOException: " + e.getMessage());
@@ -896,6 +901,11 @@ public class Compressor {
             pathToFile(utility, utility.getEtsPath(), etsPath, false);
         }
 
+        if (!utility.getHnpPath().isEmpty() && isModuleJSON(utility.getJsonPath())) {
+            String hnpPath = HNP_PATH;
+            pathToFile(utility, utility.getHnpPath(), hnpPath, false);
+        }
+
         if (!utility.getRpcidPath().isEmpty()) {
             String rpcidPath = NULL_DIR_NAME;
             pathToFile(utility, utility.getRpcidPath(), rpcidPath, false);
@@ -2179,8 +2189,9 @@ public class Compressor {
             if (!entryName.contains(RAW_FILE_PATH) &&
                     srcFile.getName().toLowerCase(Locale.ENGLISH).endsWith(JSON_SUFFIX)) {
                 zipEntry.setMethod(ZipEntry.STORED);
-                jsonSpecialProcess(utility, srcFile, zipEntry);
-                return;
+                if (jsonSpecialProcess(utility, srcFile, zipEntry)) {
+                    return;
+                }
             }
 
             if (isCompression) {
@@ -2326,10 +2337,9 @@ public class Compressor {
      * @param utility common data
      * @param srcFile file input
      * @param entry   zip file entry
-     * @throws BundleException FileNotFoundException|IOException.
+     * @return true if process success
      */
-    private void jsonSpecialProcess(Utility utility, File srcFile, ZipArchiveEntry entry)
-            throws BundleException {
+    private boolean jsonSpecialProcess(Utility utility, File srcFile, ZipArchiveEntry entry) {
         FileInputStream fileInputStream = null;
         BufferedReader bufferedReader = null;
         InputStreamReader inputStreamReader = null;
@@ -2381,14 +2391,16 @@ public class Compressor {
             // compress data
             zipOut.putArchiveEntry(entry);
             zipOut.write(trimJson);
-        } catch (IOException exception) {
+        } catch (Exception exception) {
             LOG.error("Compressor::jsonSpecialProcess io exception: " + exception.getMessage());
-            throw new BundleException("Json special process failed.");
+            LOG.warning("Json format err: " + srcFile.getAbsolutePath());
+            return false;
         } finally {
             Utility.closeStream(bufferedReader);
             Utility.closeStream(inputStreamReader);
             Utility.closeStream(fileInputStream);
         }
+        return true;
     }
 
     /**
@@ -2899,6 +2911,8 @@ public class Compressor {
                         tempDir.toAbsolutePath() + LINUX_FILE_SEPARATOR + MODULE_JSON);
                 File configFile = new File(
                         tempDir.toAbsolutePath() + LINUX_FILE_SEPARATOR + CONFIG_JSON);
+                File packInfoFile = new File(
+                        tempDir.toAbsolutePath() + LINUX_FILE_SEPARATOR + PACKINFO_NAME);
 
                 if (moduleFile.exists() && configFile.exists()) {
                     LOG.error("versionNormalize failed, invalid hap structure.");
@@ -2914,6 +2928,10 @@ public class Compressor {
                     LOG.error("versionNormalize failed, invalid hap structure.");
                     throw new BundleException("versionNormalize failed, invalid hap structure.");
                 }
+                if (packInfoFile.exists()) {
+                    String packInfoPath = tempDir.resolve(PACKINFO_NAME).toString();
+                    parseAndModifyPackInfo(packInfoPath, utility);
+                }
 
                 verifyModuleVersion(util, utility);
                 utils.add(util);
@@ -2969,12 +2987,44 @@ public class Compressor {
         return util;
     }
 
+    private void parseAndModifyPackInfo(String packInfoPath, Utility utility)
+            throws BundleException {
+        try (FileInputStream jsonStream = new FileInputStream(packInfoPath)) {
+            JSONObject jsonObject = JSON.parseObject(jsonStream, JSONObject.class);
+            if (jsonObject == null) {
+                LOG.warning("parseAndModifyPackInfo failed, json format invalid.");
+                return;
+            }
+            JSONObject summaryObject = jsonObject.getJSONObject(SUMMARY);
+            if (summaryObject == null) {
+                LOG.warning("parseAndModifyPackInfo failed, summary invalid.");
+                return;
+            }
+            JSONObject appObject = summaryObject.getJSONObject(APP);
+            if (appObject == null) {
+                LOG.warning("parseAndModifyPackInfo failed, app invalid.");
+                return;
+            }
+            JSONObject versionObject = appObject.getJSONObject(VERSION);
+            if (versionObject == null) {
+                LOG.warning("parseAndModifyPackInfo failed, version invalid.");
+                return;
+            }
+            versionObject.put(CODE, utility.getVersionCode());
+            versionObject.put(NAME, utility.getVersionName());
+            writeJson(packInfoPath, jsonObject);
+        } catch (IOException e) {
+            LOG.warning("parseAndModifyPackInfo failed, IOException." + e.getMessage());
+        }
+    }
+
     private void writeJson(String jsonFilePath, JSONObject jsonObject) throws IOException, BundleException {
         BufferedWriter bw = null;
         try {
             String pretty = JSON.toJSONString(jsonObject, SerializerFeature.PrettyFormat,
                 SerializerFeature.WriteMapNullValue, SerializerFeature.WriteDateUseDateFormat);
-            bw = new BufferedWriter(new FileWriter(jsonFilePath));
+            bw = new BufferedWriter(new OutputStreamWriter(
+                    new FileOutputStream(jsonFilePath), StandardCharsets.UTF_8));
             bw.write(pretty);
         } catch (IOException exception) {
             LOG.error("Compressor::writeJson failed for IOException " + exception.getMessage());
@@ -3048,6 +3098,9 @@ public class Compressor {
                     case ETS_FILE_NAME:
                         utility.setEtsPath(filePath);
                         break;
+                    case HNP_FILE_NAME:
+                        utility.setHnpPath(filePath);
+                        break;
                     case LIBS_DIR:
                         utility.setLibPath(filePath);
                         break;
diff --git a/adapter/ohos/JsonUtil.java b/adapter/ohos/JsonUtil.java
index 1ad3360a70b2446be4a56b3bb38c7b0ba2aff06d..70df337f3437560d1cd06b0ebf19389ee4914a8e 100644
--- a/adapter/ohos/JsonUtil.java
+++ b/adapter/ohos/JsonUtil.java
@@ -1382,10 +1382,14 @@ public class JsonUtil {
         if (!jsonObject.containsKey(META_DATA)) {
             return moduleMetadataInfos;
         }
-        JSONArray metadatas = jsonObject.getJSONArray(META_DATA);
-        for (int i = 0; i < metadatas.size(); ++i) {
-            JSONObject metadata = metadatas.getJSONObject(i);
-            moduleMetadataInfos.add(parseModuleMetadata(metadata, data, profileJsons));
+        try {
+            JSONArray metadatas = jsonObject.getJSONArray(META_DATA);
+            for (int i = 0; i < metadatas.size(); ++i) {
+                JSONObject metadata = metadatas.getJSONObject(i);
+                moduleMetadataInfos.add(parseModuleMetadata(metadata, data, profileJsons));
+            }
+        } catch (JSONException | NullPointerException ex) {
+            LOG.warning("JsonUtil::parseModuleMetadataInfos err: " + ex.getMessage());
         }
         return moduleMetadataInfos;
     }
@@ -1492,23 +1496,27 @@ public class JsonUtil {
      */
     static List<CommonEvent> parseModuleCommonEvents(JSONObject jsonObject) {
         List<CommonEvent> commonEvents = new ArrayList<>();
-        JSONArray commonEventObjs = jsonObject.getJSONArray("commonEvents");
-        for (int i = 0; i < commonEventObjs.size(); ++i) {
-            JSONObject commonEventObj = commonEventObjs.getJSONObject(i);
-            CommonEvent commonEvent = new CommonEvent();
-            if (commonEventObj.containsKey("name")) {
-                commonEvent.name = getJsonString(commonEventObj, "name");
-            }
-            if (commonEventObj.containsKey("permission")) {
-                commonEvent.permission = getJsonString(commonEventObj, "permission");
-            }
-            if (commonEventObj.containsKey("types")) {
-                commonEvent.type = JSON.parseArray(getJsonString(commonEventObj, "types"), String.class);
-            }
-            if (commonEventObj.containsKey("events")) {
-                commonEvent.events = JSON.parseArray(getJsonString(commonEventObj, "events"), String.class);
+        try {
+            JSONArray commonEventObjs = jsonObject.getJSONArray("commonEvents");
+            for (int i = 0; i < commonEventObjs.size(); ++i) {
+                JSONObject commonEventObj = commonEventObjs.getJSONObject(i);
+                CommonEvent commonEvent = new CommonEvent();
+                if (commonEventObj.containsKey("name")) {
+                    commonEvent.name = getJsonString(commonEventObj, "name");
+                }
+                if (commonEventObj.containsKey("permission")) {
+                    commonEvent.permission = getJsonString(commonEventObj, "permission");
+                }
+                if (commonEventObj.containsKey("types")) {
+                    commonEvent.type = JSON.parseArray(getJsonString(commonEventObj, "types"), String.class);
+                }
+                if (commonEventObj.containsKey("events")) {
+                    commonEvent.events = JSON.parseArray(getJsonString(commonEventObj, "events"), String.class);
+                }
+                commonEvents.add(commonEvent);
             }
-            commonEvents.add(commonEvent);
+        } catch (JSONException | NullPointerException ex) {
+            LOG.warning("JsonUtil::parseModuleCommonEvents err: " + ex.getMessage());
         }
         return commonEvents;
     }
@@ -1530,12 +1538,16 @@ public class JsonUtil {
             if (jsonStr.isEmpty()) {
                 continue;
             }
-            JSONObject jsonObj = JSON.parseObject(jsonStr);
-            if (jsonObj.containsKey("shortcuts")) {
-                JSONArray shortcutObjs = jsonObj.getJSONArray("shortcuts");
-                for (int j = 0; j < shortcutObjs.size(); ++j) {
-                    shortcuts.add(parseModuleShortcutObj(shortcutObjs.getJSONObject(j), data));
+            try {
+                JSONObject jsonObj = JSON.parseObject(jsonStr);
+                if (jsonObj.containsKey("shortcuts")) {
+                    JSONArray shortcutObjs = jsonObj.getJSONArray("shortcuts");
+                    for (int j = 0; j < shortcutObjs.size(); ++j) {
+                        shortcuts.add(parseModuleShortcutObj(shortcutObjs.getJSONObject(j), data));
+                    }
                 }
+            } catch (JSONException ignore) {
+                LOG.warning("ignored metadata: " + moduleMetadataInfo.name);
             }
         }
         return shortcuts;
@@ -1733,31 +1745,39 @@ public class JsonUtil {
         if (!moduleJson.containsKey(DEFINE_PERMISSIONS)) {
             return definePermissions;
         }
-        JSONArray definePermissionObjs = moduleJson.getJSONArray(DEFINE_PERMISSIONS);
-        for (int i = 0; i < definePermissionObjs.size(); ++i) {
-            definePermissions.add(parseDefinePermission(definePermissionObjs.getJSONObject(i), data));
+        try {
+            JSONArray definePermissionObjs = moduleJson.getJSONArray(DEFINE_PERMISSIONS);
+            for (int i = 0; i < definePermissionObjs.size(); ++i) {
+                definePermissions.add(parseDefinePermission(definePermissionObjs.getJSONObject(i), data));
+            }
+        } catch (JSONException | NullPointerException ex) {
+            LOG.warning("JsonUtil::parseDefinePermissions err: " + ex.getMessage());
         }
         return definePermissions;
     }
 
     static ModuleAtomicService parseModuleAtomicService(JSONObject moduleJson) {
         ModuleAtomicService moduleAtomicService = new ModuleAtomicService();
-        JSONObject atomicServiceObj = null;
-        if (!moduleJson.containsKey(ATOMIC_SERVICE)) {
-            return moduleAtomicService;
-        }
-        atomicServiceObj = moduleJson.getJSONObject(ATOMIC_SERVICE);
-        JSONArray preloadObjs = atomicServiceObj.getJSONArray(PRELOADS);
-        List<PreloadItem> preloadItems = new ArrayList<>();
-        for (int i = 0; i < preloadObjs.size(); ++i) {
-            PreloadItem preloadItem = new PreloadItem();
-            JSONObject itemObj = preloadObjs.getJSONObject(i);
-            if (itemObj.containsKey(MODULE_NAME)) {
-                preloadItem.setModuleName(getJsonString(itemObj, MODULE_NAME));
+        try {
+            JSONObject atomicServiceObj = null;
+            if (!moduleJson.containsKey(ATOMIC_SERVICE)) {
+                return moduleAtomicService;
+            }
+            atomicServiceObj = moduleJson.getJSONObject(ATOMIC_SERVICE);
+            JSONArray preloadObjs = atomicServiceObj.getJSONArray(PRELOADS);
+            List<PreloadItem> preloadItems = new ArrayList<>();
+            for (int i = 0; i < preloadObjs.size(); ++i) {
+                PreloadItem preloadItem = new PreloadItem();
+                JSONObject itemObj = preloadObjs.getJSONObject(i);
+                if (itemObj.containsKey(MODULE_NAME)) {
+                    preloadItem.setModuleName(getJsonString(itemObj, MODULE_NAME));
+                }
+                preloadItems.add(preloadItem);
             }
-            preloadItems.add(preloadItem);
+            moduleAtomicService.setPreloadItems(preloadItems);
+        } catch (JSONException | NullPointerException ex) {
+            LOG.warning("JsonUtil::parseModuleAtomicService err: " + ex.getMessage());
         }
-        moduleAtomicService.setPreloadItems(preloadItems);
 
         return moduleAtomicService;
     }
@@ -1910,7 +1930,9 @@ public class JsonUtil {
         if (jsonObject.containsKey("iconId")) {
             int resId = jsonObject.getIntValue("iconId");
             iconPath = ResourcesParser.getBaseResourceById(resId, data);
-            iconPath = iconPath.substring(iconPath.indexOf("resources"));
+            if (iconPath.contains("resources")) {
+                iconPath = iconPath.substring(iconPath.indexOf("resources"));
+            }
         }
         if (!iconPath.isEmpty()) {
             return iconPath;
diff --git a/adapter/ohos/Utility.java b/adapter/ohos/Utility.java
index 8d58a0e6e7075ed6daf76fe9565a0ba14c2b8654..54316f0e9a5f063548c1ecfeb64e9dcf6cf7ddf1 100644
--- a/adapter/ohos/Utility.java
+++ b/adapter/ohos/Utility.java
@@ -41,6 +41,7 @@ public class Utility {
     static final String FALSE_STRING = "false";
     static final String TRUE_STRING = "true";
 
+    private static final String INVALID_PATH = "invalid";
     private static final String CMD_PREFIX = "--";
     private static final Log LOG = new Log(Utility.class.toString());
 
@@ -84,6 +85,7 @@ public class Utility {
     private String filePath = "";
     private String jsPath = "";
     private String etsPath = "";
+    private String hnpPath = "";
     private String rpcidPath = "";
     private int VersionCode = -1;
     private String VersionName = "";
@@ -537,6 +539,10 @@ public class Utility {
 
     public void setEtsPath(String etsPath) { this.etsPath = etsPath; }
 
+    public String getHnpPath() { return hnpPath; }
+
+    public void setHnpPath(String hnpPath) { this.hnpPath = hnpPath; }
+
     public String getRpcidPath() {
         return rpcidPath;
     }
@@ -664,7 +670,7 @@ public class Utility {
         try {
             canonicalPath = file.getCanonicalPath();
         } catch (IOException exception) {
-            canonicalPath = "";
+            canonicalPath = INVALID_PATH;
             LOG.error("Utility::getFormattedPath exception," + exception.getMessage());
         }
         return canonicalPath;
diff --git a/bundle.json b/bundle.json
index fb366a96e451e8ee85c8639134e35f6e4d842dff..570c8e61203824d4efadcf57fa763e7dbbacb73e 100755
--- a/bundle.json
+++ b/bundle.json
@@ -16,11 +16,15 @@
       "subsystem": "developtools",
       "adapted_system_type": [ "mini", "small", "standard" ],
       "deps": {
-        "components": []
+        "components": [
+          "json",
+          "zlib"
+        ]
       },
       "build": {
         "sub_component": [
-          "//developtools/packing_tool:packing_tool"
+          "//developtools/packing_tool:packing_tool",
+          "//developtools/packing_tool:ohos_packing_tool"
         ]
       }
     }
diff --git a/modulecheck/app.json b/modulecheck/app.json
index 9a695913f9930d9e657987c2277dfd800f437d2f..17c2fe7fa315e8de9d3fbd8bf6399c4f17cd33a6 100644
--- a/modulecheck/app.json
+++ b/modulecheck/app.json
@@ -78,45 +78,95 @@
         "versionCode",
         "versionName"
       ],
-      "propertyNames": {
-        "enum": [
-          "bundleName",
-          "debug",
-          "bundleType",
-          "icon",
-          "label",
-          "description",
-          "vendor",
-          "versionCode",
-          "versionName",
-          "minCompatibleVersionCode",
-          "minAPIVersion",
-          "targetAPIVersion",
-          "apiReleaseType",
-          "distributedNotificationEnabled",
-          "entityType",
-          "keepAlive",
-          "removable",
-          "singleton",
-          "userDataClearable",
-          "accessible",
-          "multiProjects",
-          "asanEnabled",
-          "default",
-          "tablet",
-          "tv",
-          "wearable",
-          "car",
-          "targetBundleName",
-          "targetPriority",
-          "generateBuildHash",
-          "2in1",
-          "GWPAsanEnabled",
-          "tsanEnabled",
-          "appEnvironments",
-          "maxChildProcess",
-          "multiAppMode"
-        ]
+      "if": {
+        "properties": {
+          "bundleType": {
+            "const": "app"
+          }
+        }
+      },
+      "then": {
+        "propertyNames": {
+          "enum": [
+            "bundleName",
+            "debug",
+            "bundleType",
+            "icon",
+            "label",
+            "description",
+            "vendor",
+            "versionCode",
+            "versionName",
+            "minCompatibleVersionCode",
+            "minAPIVersion",
+            "targetAPIVersion",
+            "apiReleaseType",
+            "distributedNotificationEnabled",
+            "entityType",
+            "keepAlive",
+            "removable",
+            "singleton",
+            "userDataClearable",
+            "accessible",
+            "multiProjects",
+            "asanEnabled",
+            "default",
+            "tablet",
+            "tv",
+            "wearable",
+            "car",
+            "targetBundleName",
+            "targetPriority",
+            "generateBuildHash",
+            "2in1",
+            "GWPAsanEnabled",
+            "tsanEnabled",
+            "appEnvironments",
+            "maxChildProcess",
+            "multiAppMode"
+          ]
+        }
+      },
+      "else": {
+        "propertyNames": {
+          "enum": [
+            "bundleName",
+            "debug",
+            "bundleType",
+            "icon",
+            "label",
+            "description",
+            "vendor",
+            "versionCode",
+            "versionName",
+            "minCompatibleVersionCode",
+            "minAPIVersion",
+            "targetAPIVersion",
+            "apiReleaseType",
+            "distributedNotificationEnabled",
+            "entityType",
+            "keepAlive",
+            "removable",
+            "singleton",
+            "userDataClearable",
+            "accessible",
+            "multiProjects",
+            "asanEnabled",
+            "default",
+            "tablet",
+            "tv",
+            "wearable",
+            "car",
+            "targetBundleName",
+            "targetPriority",
+            "generateBuildHash",
+            "2in1",
+            "GWPAsanEnabled",
+            "tsanEnabled",
+            "appEnvironments",
+            "maxChildProcess"
+          ]
+        }
       },
       "properties": {
         "bundleName": {
@@ -344,6 +394,10 @@
               "maxCount"
             ]
           },
+          "required": [
+            "multiAppModeType",
+            "maxCount"
+          ],
           "properties": {
             "multiAppModeType": {
               "description": "Indicates the type of application multiple open mode.",
diff --git a/modulecheck/appStartup.json b/modulecheck/appStartup.json
index 2bc3d176b701548d3bb47e102d84efd8a6ac0576..ae1983c23183cc1c3e76fc2b2664821a77fcdfd4 100644
--- a/modulecheck/appStartup.json
+++ b/modulecheck/appStartup.json
@@ -64,7 +64,7 @@
             "type": "string",
             "enum": [
               "mainThread",
-              "taskpool"
+	            "taskPool"
             ],
             "default": "mainThread"
           },
@@ -82,4 +82,4 @@
       "maxLength": 127
     }
   }
-}
+}
\ No newline at end of file
diff --git a/modulecheck/module.json b/modulecheck/module.json
index 7735dd26a64014d53ce23a61c6bd3fd1144dd740..ad7a78c2edaa423ffc1c88227d38122121c73738 100644
--- a/modulecheck/module.json
+++ b/modulecheck/module.json
@@ -135,7 +135,8 @@
                 "querySchemes",
                 "routerMap",
                 "appEnvironments",
-                "appStartup"
+                "appStartup",
+                "hnpPackages"
               ]
             },
             "required": [
@@ -1514,6 +1515,40 @@
           "type": "string",
           "pattern": "^[$]profile:[0-9a-zA-Z_.]+$",
           "maxLength": 255
+        },
+        "hnpPackages": {
+          "description": "Native package configuration file.",
+          "type": "array",
+          "minItems": 1,
+          "items": {
+            "type": "object",
+            "propertyNames": {
+              "enum": [
+                "package",
+                "type"
+              ]
+            },
+            "required": [
+              "package",
+              "type"
+            ],
+            "properties": {
+              "package": {
+                "description": "Indicates the file name of native package.",
+                "type": "string",
+                "pattern": "^([a-zA-Z0-9_-]+(\/[a-zA-Z0-9_-]+)*\/)?[a-zA-Z0-9_-]+\\.hnp$",
+                "maxLength": 255
+              },
+              "type": {
+                "description": "Indicates the type of native package.",
+                "type": "string",
+                "enum": [
+                  "public",
+                  "private"
+                ]
+              }
+            }
+          }
         }
       }
     }
diff --git a/ohos_packing_tool/LICENSE b/ohos_packing_tool/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..4a459866a57c25462afad17f3fe0b50d440da080
--- /dev/null
+++ b/ohos_packing_tool/LICENSE
@@ -0,0 +1,177 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
\ No newline at end of file
diff --git a/ohos_packing_tool/frameworks/BUILD.gn b/ohos_packing_tool/frameworks/BUILD.gn
new file mode 100644
index 0000000000000000000000000000000000000000..78bb699a6b08dfcd807e0dede7937cfd9b81a347
--- /dev/null
+++ b/ohos_packing_tool/frameworks/BUILD.gn
@@ -0,0 +1,34 @@
+# Copyright (c) 2024 Huawei Device Co., Ltd.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import("//build/ohos.gni")
+
+ohos_executable("ohos_packing_tool") {
+  include_dirs = [ "include" ]
+  sources = [
+    "src/hap_packager.cpp",
+    "src/hsp_packager.cpp",
+    "src/main.cpp",
+    "src/packager.cpp",
+    "src/shell_command.cpp",
+  ]
+  configs = []
+  cflags = []
+  external_deps = [
+    "json:nlohmann_json_static",
+    "zlib:libz",
+  ]
+  install_enable = false
+  subsystem_name = "developtools"
+  part_name = "packing_tool"
+}
diff --git a/ohos_packing_tool/frameworks/include/constants.h b/ohos_packing_tool/frameworks/include/constants.h
new file mode 100644
index 0000000000000000000000000000000000000000..b6daeb26455718c9a3390759960714bf59329d01
--- /dev/null
+++ b/ohos_packing_tool/frameworks/include/constants.h
@@ -0,0 +1,148 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef DEVELOPTOOLS_PACKING_TOOL_APT_FRAMEWORKS_INCLUDE_CONSTANTS_H
+#define DEVELOPTOOLS_PACKING_TOOL_APT_FRAMEWORKS_INCLUDE_CONSTANTS_H
+
+#include <iostream>
+#include <map>
+#include <string>
+#include <getopt.h>
+
+namespace OHOS {
+namespace AppPackingTool {
+namespace Constants {
+const std::string CMD_HELP = "help";
+const std::string CMD_PACK = "pack";
+const std::string CMD_UNPACK = "unpack";
+
+const std::string MODE_HAP = "hap";
+const std::string MODE_HSP = "hsp";
+const std::string MODE_APP = "app";
+const std::string MODE_HQF = "hqf";
+const std::string MODE_APPQF = "appqf";
+const std::string MODE_MULTIAPP = "multiApp";
+const std::string MODE_VERSION_NORMALIZE = "versionNormalize";
+const std::string MODE_PACKAGE_NORMALIZE = "packageNormalize";
+
+const std::string PARAM_PREFIX = "--";
+const std::string PARAM_MODE = "mode";
+const std::string PARAM_JSON_PATH = "json-path";
+const std::string PARAM_LIB_PATH = "lib-path";
+const std::string PARAM_RESOURCES_PATH = "resources-path";
+const std::string PARAM_INDEX_PATH = "index-path";
+const std::string PARAM_PACK_INFO_PATH = "pack-info-path";
+const std::string PARAM_PROFILE_PATH = "profile-path";
+const std::string PARAM_ETS_PATH = "ets-path";
+const std::string PARAM_OUT_PATH = "out-path";
+const std::string PARAM_MAPLE_SO_PATH = "maple-so-path";
+const std::string PARAM_MAPLE_SO_DIR = "maple-so-dir";
+const std::string PARAM_RPCID_PATH = "rpcid-path";
+const std::string PARAM_JS_PATH = "js-path";
+const std::string PARAM_FORCE = "force";
+const std::string PARAM_AN_PATH = "an-path";
+const std::string PARAM_AP_PATH = "ap-path";
+const std::string PARAM_DIR_LIST = "dir-list";
+const std::string PARAM_COMPRESS_LEVEL = "compress-level";
+const std::string PARAM_PKG_CONTEXT_PATH = "pkg-context-path";
+const std::string PARAM_HAP_PATH = "hap-path";
+const std::string PARAM_HSP_PATH = "hsp-path";
+const std::string PARAM_SIGNATURE_PATH = "signature-path";
+const std::string PARAM_CERTIFICATE_PATH = "certificate-path";
+const std::string PARAM_HAP_LIST = "hap-list";
+const std::string PARAM_HSP_LIST = "hsp-list";
+const std::string PARAM_APP_LIST = "app-list";
+const std::string PARAM_HQF_LIST = "hqf-list";
+const std::string PARAM_INPUT_LIST = "input-list";
+const std::string PARAM_VERSION_CODE = "version-code";
+const std::string PARAM_VERSION_NAME = "version-name";
+const std::string PARAM_APP_PATH = "app-path";
+const std::string PARAM_RPCID = "rpcid";
+const std::string PARAM_APPQF_PATH = "appqf-path";
+const std::string PARAM_MAIN_MODULE_LIMIT = "main-module-limit";
+const std::string PARAM_NORMAL_MODULE_LIMIT = "normal-module-limit";
+
+const std::string MODULE_JSON = "module.json";
+const std::string CONFIG_JSON = "config.json";
+const std::string LIB_PATH = "libs";
+const std::string RESOURCES_PATH = "resources";
+const std::string RESOURCES_INDEX = "resources.index";
+const std::string PACK_INFO = "pack.info";
+const std::string ETS_PATH = "ets";
+const std::string RPCID_SC = "rpcid.sc";
+const std::string PKG_CONTEXT_JSON = "pkgContextInfo.json";
+
+const std::string JSON_SUFFIX = ".json";
+const std::string HAP_SUFFIX = ".hap";
+const std::string HSP_SUFFIX = ".hsp";
+const std::string APP_SUFFIX = ".app";
+
+constexpr const char* SHORT_OPTIONS = "";
+const struct option LONG_OPTIONS[] = {
+    {PARAM_MODE.c_str(), required_argument, nullptr, 1},
+    {PARAM_JSON_PATH.c_str(), required_argument, nullptr, 2},
+    {PARAM_LIB_PATH.c_str(), required_argument, nullptr, 3},
+    {PARAM_RESOURCES_PATH.c_str(), required_argument, nullptr, 4},
+    {PARAM_INDEX_PATH.c_str(), required_argument, nullptr, 5},
+    {PARAM_PACK_INFO_PATH.c_str(), required_argument, nullptr, 6},
+    {PARAM_PROFILE_PATH.c_str(), required_argument, nullptr, 7},
+    {PARAM_ETS_PATH.c_str(), required_argument, nullptr, 8},
+    {PARAM_OUT_PATH.c_str(), required_argument, nullptr, 9},
+    {PARAM_MAPLE_SO_PATH.c_str(), required_argument, nullptr, 10},
+    {PARAM_MAPLE_SO_DIR.c_str(), required_argument, nullptr, 11},
+    {PARAM_RPCID_PATH.c_str(), required_argument, nullptr, 13},
+    {PARAM_JS_PATH.c_str(), required_argument, nullptr, 14},
+    {PARAM_FORCE.c_str(), required_argument, nullptr, 15},
+    {PARAM_AN_PATH.c_str(), required_argument, nullptr, 16},
+    {PARAM_AP_PATH.c_str(), required_argument, nullptr, 17},
+    {PARAM_DIR_LIST.c_str(), required_argument, nullptr, 18},
+    {PARAM_COMPRESS_LEVEL.c_str(), required_argument, nullptr, 19},
+    {PARAM_PKG_CONTEXT_PATH.c_str(), required_argument, nullptr, 20},
+    {PARAM_HAP_PATH.c_str(), required_argument, nullptr, 21},
+    {PARAM_HSP_PATH.c_str(), required_argument, nullptr, 22},
+    {PARAM_SIGNATURE_PATH.c_str(), required_argument, nullptr, 23},
+    {PARAM_CERTIFICATE_PATH.c_str(), required_argument, nullptr, 24},
+    {PARAM_HAP_LIST.c_str(), required_argument, nullptr, 25},
+    {PARAM_HSP_LIST.c_str(), required_argument, nullptr, 26},
+    {PARAM_APP_LIST.c_str(), required_argument, nullptr, 27},
+    {PARAM_HQF_LIST.c_str(), required_argument, nullptr, 28},
+    {PARAM_INPUT_LIST.c_str(), required_argument, nullptr, 29},
+    {PARAM_VERSION_CODE.c_str(), required_argument, nullptr, 30},
+    {PARAM_VERSION_NAME.c_str(), required_argument, nullptr, 31},
+    {PARAM_APP_PATH.c_str(), required_argument, nullptr, 32},
+    {PARAM_RPCID.c_str(), required_argument, nullptr, 33},
+    {PARAM_APPQF_PATH.c_str(), required_argument, nullptr, 34},
+    {PARAM_MAIN_MODULE_LIMIT.c_str(), required_argument, nullptr, 35},
+    {PARAM_NORMAL_MODULE_LIMIT.c_str(), required_argument, nullptr, 36},
+    {nullptr, 0, nullptr, 0},
+};
+constexpr const int OPTIONS_SIZE = sizeof(LONG_OPTIONS) / sizeof(LONG_OPTIONS[0]);
+
+enum PARAM_TYPE {
+    DEFAULT,
+    REGULAR_FILE,
+    REGULAR_FILE_ARRAY,
+    DIRECTORY,
+    DIRECTORY_ARRAY,
+    FILE_OR_DIRECTORY,
+    FILE_OR_DIRECTORY_ARRAY,
+};
+
+constexpr const int BUF_SIZE = 1024 * 4;
+}
+}  // namespace AppExecFwk
+}  // namespace OHOS
+
+#endif  // DEVELOPTOOLS_PACKING_TOOL_APT_FRAMEWORKS_INCLUDE_CONSTANTS_H
\ No newline at end of file
diff --git a/ohos_packing_tool/frameworks/include/hap_packager.h b/ohos_packing_tool/frameworks/include/hap_packager.h
new file mode 100644
index 0000000000000000000000000000000000000000..a6e142875bef82d8238204d24a8dc0144c18bc4a
--- /dev/null
+++ b/ohos_packing_tool/frameworks/include/hap_packager.h
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef DEVELOPTOOLS_PACKING_TOOL_APT_FRAMEWORKS_INCLUDE_HAP_PACKAGER_H
+#define DEVELOPTOOLS_PACKING_TOOL_APT_FRAMEWORKS_INCLUDE_HAP_PACKAGER_H
+
+#include <iostream>
+#include <map>
+#include <string>
+
+#include "packager.h"
+
+namespace OHOS {
+namespace AppPackingTool {
+
+class HapPackager : public Packager {
+public:
+    HapPackager(const std::map<std::string, std::string> &parameterMap, std::string &resultReceiver);
+    ~HapPackager() override {}
+
+protected:
+    int InitAllowedParam() override;
+    int PreProcess() override;
+    int Process() override;
+    int PostProcess() override;
+};
+
+}  // namespace AppExecFwk
+}  // namespace OHOS
+
+#endif  // DEVELOPTOOLS_PACKING_TOOL_APT_FRAMEWORKS_INCLUDE_HAP_PACKAGER_H
\ No newline at end of file
diff --git a/ohos_packing_tool/frameworks/include/hsp_packager.h b/ohos_packing_tool/frameworks/include/hsp_packager.h
new file mode 100644
index 0000000000000000000000000000000000000000..bfc88de1f8bd194cb269216a71d3530557ee451d
--- /dev/null
+++ b/ohos_packing_tool/frameworks/include/hsp_packager.h
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef DEVELOPTOOLS_PACKING_TOOL_APT_FRAMEWORKS_INCLUDE_HSP_PACKAGER_H
+#define DEVELOPTOOLS_PACKING_TOOL_APT_FRAMEWORKS_INCLUDE_HSP_PACKAGER_H
+
+#include <iostream>
+#include <map>
+#include <string>
+
+#include "packager.h"
+
+namespace OHOS {
+namespace AppPackingTool {
+
+class HspPackager : public Packager {
+public:
+    HspPackager(const std::map<std::string, std::string> &parameterMap, std::string &resultReceiver);
+    ~HspPackager() override {}
+
+protected:
+    int InitAllowedParam() override;
+    int PreProcess() override;
+    int Process() override;
+    int PostProcess() override;
+};
+
+}  // namespace AppExecFwk
+}  // namespace OHOS
+
+#endif  // DEVELOPTOOLS_PACKING_TOOL_APT_FRAMEWORKS_INCLUDE_HSP_PACKAGER_H
\ No newline at end of file
diff --git a/ohos_packing_tool/frameworks/include/packager.h b/ohos_packing_tool/frameworks/include/packager.h
new file mode 100644
index 0000000000000000000000000000000000000000..eb643dabafff1f6338d1b25b87ae77173c0121c5
--- /dev/null
+++ b/ohos_packing_tool/frameworks/include/packager.h
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef DEVELOPTOOLS_PACKING_TOOL_APT_FRAMEWORKS_INCLUDE_PACKAGER_H
+#define DEVELOPTOOLS_PACKING_TOOL_APT_FRAMEWORKS_INCLUDE_PACKAGER_H
+
+#include <filesystem>
+#include <functional>
+#include <iostream>
+#include <map>
+#include <regex>
+#include <string>
+#include <vector>
+
+#include "constants.h"
+#include "contrib/minizip/zip.h"
+#include "contrib/minizip/unzip.h"
+#include "nlohmann/json.hpp"
+
+namespace fs = std::filesystem;
+
+namespace OHOS {
+namespace AppPackingTool {
+
+enum ErrCode {
+    ERR_OK = 0,
+    ERR_INVALID_VALUE,
+};
+
+struct Parameter {
+    std::string paramName;
+    bool required;
+    Constants::PARAM_TYPE paramType;
+    std::string paramRegrex;
+    std::string zipEntry;
+};
+
+class Packager {
+public:
+    Packager(const std::map<std::string, std::string> &parameterMap, std::string &resultReceiver);
+    virtual ~Packager();
+
+    std::string MakePackage();
+
+    virtual int InitAllowedParam() = 0;
+    virtual int PreProcess() = 0;
+    virtual int Process() = 0;
+    virtual int PostProcess() = 0;
+
+protected:
+    const std::map<std::string, std::string> &parameterMap_;
+    std::string &resultReceiver_;
+    std::vector<Parameter> allowedParameters_;
+    nlohmann::json moduleJson;
+    nlohmann::json packInfo;
+    
+    void AddFileToZip(zipFile zf, const fs::path &filePath, const fs::path &zipPath, zip_fileinfo &zipfi);
+    void WriteStringToZip(zipFile zf, const std::string &content, const fs::path &zipPath, zip_fileinfo &zipfi);
+    bool ParseJsonFile(nlohmann::json &jsonObject, std::string filePath);
+    bool CheckFileValid(const std::string &filePath, const std::string &filename);
+    bool endWith(const std::string &str, const std::string &suffix);
+};
+
+}  // namespace AppExecFwk
+}  // namespace OHOS
+
+#endif  // DEVELOPTOOLS_PACKING_TOOL_APT_FRAMEWORKS_INCLUDE_PACKAGER_H
\ No newline at end of file
diff --git a/ohos_packing_tool/frameworks/include/shell_command.h b/ohos_packing_tool/frameworks/include/shell_command.h
new file mode 100644
index 0000000000000000000000000000000000000000..02d90d42b44fe01b70b7e286738646f6a1755acc
--- /dev/null
+++ b/ohos_packing_tool/frameworks/include/shell_command.h
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef DEVELOPTOOLS_PACKING_TOOL_APT_FRAMEWORKS_INCLUDE_SHELLCOMMAND_H
+#define DEVELOPTOOLS_PACKING_TOOL_APT_FRAMEWORKS_INCLUDE_SHELLCOMMAND_H
+
+#include <map>
+#include <string>
+#include <functional>
+#include <vector>
+
+#include "packager.h"
+
+namespace OHOS {
+namespace AppPackingTool {
+namespace {
+const int OFFSET_REQUIRED_ARGUMENT = 2;
+const std::string HELP_MSG_NO_OPTION = "error: you must specify an option at least.";
+const std::string STRING_CODE = "code:";
+const std::string TOOL_NAME = "apt";
+
+const std::string HELP_MSG = "usage: apt <command> <options>\n"
+                             "These are common apt commands list:\n"
+                             "  help    list available commands\n"
+                             "  pack    pack a bundle  with options\n";
+
+}  // namespace
+
+class ShellCommand {
+public:
+    ShellCommand(int argc, char *argv[], std::string name);
+    virtual ~ShellCommand();
+
+    int ParseParam();
+    int OnCommand();
+    std::string ExecCommand();
+    int CreateCommandMap();
+
+protected:
+    static constexpr int MIN_ARGUMENT_NUMBER = 2;
+
+    int argc_;
+    char **argv_;
+
+    std::string cmd_;
+    std::string name_;
+    std::map<std::string, std::function<int()>> commandMap_;
+    std::map<std::string, std::string> parameterMap_;
+    std::string resultReceiver_ = "";
+
+    int RunAsHelpCommand();
+    int RunAsPackCommand();
+    int RunAsUnpackCommand();
+
+private:
+    std::unique_ptr<Packager> getPackager();
+};
+
+}  // namespace AppExecFwk
+}  // namespace OHOS
+
+#endif  // DEVELOPTOOLS_PACKING_TOOL_APT_FRAMEWORKS_INCLUDE_SHELLCOMMAND_H
\ No newline at end of file
diff --git a/ohos_packing_tool/frameworks/src/hap_packager.cpp b/ohos_packing_tool/frameworks/src/hap_packager.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fda8730b78a34631cbb4b22bcfdfb85f3f48cd5a
--- /dev/null
+++ b/ohos_packing_tool/frameworks/src/hap_packager.cpp
@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <filesystem>
+#include <fstream>
+#include <iostream>
+#include <ostream>
+#include <regex>
+#include <string>
+
+#include "hap_packager.h"
+#include "constants.h"
+#include "contrib/minizip/zip.h"
+#include "nlohmann/json.hpp"
+#include "packager.h"
+
+namespace OHOS {
+namespace AppPackingTool {
+namespace {}
+
+HapPackager::HapPackager(const std::map<std::string, std::string> &parameterMap, std::string &resultReceiver)
+    : Packager(parameterMap, resultReceiver)
+{}
+
+int HapPackager::InitAllowedParam()
+{
+    allowedParameters_ = {
+        {}
+    };
+    return ERR_OK;
+}
+
+int HapPackager::PreProcess()
+{
+    return ERR_OK;
+}
+
+int HapPackager::Process()
+{
+    std::cout << "Hap DoPackage" << std::endl;
+    std::string outPath = parameterMap_.at(Constants::PARAM_OUT_PATH);
+    zipFile zf = zipOpen64(outPath.c_str(), APPEND_STATUS_CREATE);
+    if (zf == nullptr) {
+        std::cout << "err zipOpen64 null" << std::endl;
+        return ERR_INVALID_VALUE;
+    }
+    zip_fileinfo fi = {};
+    std::map<std::string, std::string>::const_iterator it = parameterMap_.find(Constants::PARAM_JSON_PATH);
+    if (it != parameterMap_.end()) {
+        if (ParseJsonFile(moduleJson, it->second)) {
+            WriteStringToZip(zf, moduleJson.dump(), fs::path(Constants::MODULE_JSON), fi);
+        }
+    }
+    it = parameterMap_.find(Constants::PARAM_LIB_PATH);
+    if (it != parameterMap_.end()) {
+        AddFileToZip(zf, fs::path(it->second), fs::path(Constants::LIB_PATH), fi);
+    }
+    it = parameterMap_.find(Constants::PARAM_RESOURCES_PATH);
+    if (it != parameterMap_.end()) {
+        AddFileToZip(zf, fs::path(it->second), fs::path(Constants::RESOURCES_PATH), fi);
+    }
+    it = parameterMap_.find(Constants::PARAM_INDEX_PATH);
+    if (it != parameterMap_.end()) {
+        AddFileToZip(zf, fs::path(it->second), fs::path(Constants::RESOURCES_INDEX), fi);
+    }
+    it = parameterMap_.find(Constants::PARAM_PACK_INFO_PATH);
+    if (it != parameterMap_.end()) {
+        AddFileToZip(zf, fs::path(it->second), fs::path(Constants::PACK_INFO), fi);
+    }
+    it = parameterMap_.find(Constants::PARAM_ETS_PATH);
+    if (it != parameterMap_.end()) {
+        AddFileToZip(zf, fs::path(it->second), fs::path(Constants::ETS_PATH), fi);
+    }
+    it = parameterMap_.find(Constants::PARAM_RPCID_PATH);
+    if (it != parameterMap_.end()) {
+        AddFileToZip(zf, fs::path(it->second), fs::path(Constants::RPCID_SC), fi);
+    }
+    it = parameterMap_.find(Constants::PARAM_PKG_CONTEXT_PATH);
+    if (it != parameterMap_.end()) {
+        AddFileToZip(zf, fs::path(it->second), fs::path(Constants::PKG_CONTEXT_JSON), fi);
+    }
+    zipClose(zf, nullptr);
+    return ERR_OK;
+}
+
+int HapPackager::PostProcess()
+{
+    return ERR_OK;
+}
+
+} // namespace AppPackingTool
+} // namespace OHOS
\ No newline at end of file
diff --git a/ohos_packing_tool/frameworks/src/hsp_packager.cpp b/ohos_packing_tool/frameworks/src/hsp_packager.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e625197de4b0dcaaa351f0ef7e7514374c72621c
--- /dev/null
+++ b/ohos_packing_tool/frameworks/src/hsp_packager.cpp
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <iostream>
+#include <ostream>
+#include <string>
+
+#include "hsp_packager.h"
+#include "constants.h"
+#include "packager.h"
+
+namespace OHOS {
+namespace AppPackingTool {
+namespace {}
+
+HspPackager::HspPackager(const std::map<std::string, std::string> &parameterMap, std::string &resultReceiver)
+    : Packager(parameterMap, resultReceiver)
+{}
+
+int HspPackager::InitAllowedParam()
+{
+    return ERR_OK;
+}
+int HspPackager::PreProcess()
+{
+    return ERR_OK;
+}
+int HspPackager::Process()
+{
+    std::cout << "Hsp DoPackage" << std::endl;
+    std::string outPath = parameterMap_.at(Constants::PARAM_OUT_PATH);
+    zipFile zf = zipOpen64(outPath.c_str(), APPEND_STATUS_CREATE);
+    if (zf == nullptr) {
+        std::cout << "err zipOpen64 null" << std::endl;
+        return ERR_INVALID_VALUE;
+    }
+    zip_fileinfo fi = {};
+    std::map<std::string, std::string>::const_iterator it = parameterMap_.find(Constants::PARAM_JSON_PATH);
+    if (it != parameterMap_.end()) {
+        if (ParseJsonFile(moduleJson, it->second)) {
+            WriteStringToZip(zf, moduleJson.dump(), fs::path(Constants::MODULE_JSON), fi);
+        }
+    }
+    it = parameterMap_.find(Constants::PARAM_LIB_PATH);
+    if (it != parameterMap_.end()) {
+        AddFileToZip(zf, fs::path(it->second), fs::path(Constants::LIB_PATH), fi);
+    }
+    it = parameterMap_.find(Constants::PARAM_RESOURCES_PATH);
+    if (it != parameterMap_.end()) {
+        AddFileToZip(zf, fs::path(it->second), fs::path(Constants::RESOURCES_PATH), fi);
+    }
+    it = parameterMap_.find(Constants::PARAM_INDEX_PATH);
+    if (it != parameterMap_.end()) {
+        AddFileToZip(zf, fs::path(it->second), fs::path(Constants::RESOURCES_INDEX), fi);
+    }
+    it = parameterMap_.find(Constants::PARAM_PACK_INFO_PATH);
+    if (it != parameterMap_.end()) {
+        AddFileToZip(zf, fs::path(it->second), fs::path(Constants::PACK_INFO), fi);
+    }
+    it = parameterMap_.find(Constants::PARAM_ETS_PATH);
+    if (it != parameterMap_.end()) {
+        AddFileToZip(zf, fs::path(it->second), fs::path(Constants::ETS_PATH), fi);
+    }
+    it = parameterMap_.find(Constants::PARAM_RPCID_PATH);
+    if (it != parameterMap_.end()) {
+        AddFileToZip(zf, fs::path(it->second), fs::path(Constants::RPCID_SC), fi);
+    }
+    it = parameterMap_.find(Constants::PARAM_PKG_CONTEXT_PATH);
+    if (it != parameterMap_.end()) {
+        AddFileToZip(zf, fs::path(it->second), fs::path(Constants::PKG_CONTEXT_JSON), fi);
+    }
+    zipClose(zf, nullptr);
+    return ERR_OK;
+}
+int HspPackager::PostProcess()
+{
+    return ERR_OK;
+}
+
+} // namespace AppPackingTool
+} // namespace OHOS
\ No newline at end of file
diff --git a/ohos_packing_tool/frameworks/src/main.cpp b/ohos_packing_tool/frameworks/src/main.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e04fc26d680f9349225ba27b06932e18fb64c6c7
--- /dev/null
+++ b/ohos_packing_tool/frameworks/src/main.cpp
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <iostream>
+
+#include "shell_command.h"
+
+int main(int argc, char *argv[])
+{
+    OHOS::AppPackingTool::ShellCommand cmd(argc, argv, OHOS::AppPackingTool::TOOL_NAME);
+    std::cout << cmd.ExecCommand();
+    quick_exit(0);
+}
\ No newline at end of file
diff --git a/ohos_packing_tool/frameworks/src/packager.cpp b/ohos_packing_tool/frameworks/src/packager.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..77c2a7ed8d8fb9080f87e40ab23e962cce70a7e5
--- /dev/null
+++ b/ohos_packing_tool/frameworks/src/packager.cpp
@@ -0,0 +1,170 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <filesystem>
+#include <fstream>
+#include <iostream>
+#include <sstream>
+#include <string>
+
+#include "packager.h"
+
+namespace OHOS {
+namespace AppPackingTool {
+namespace {}
+
+Packager::Packager(const std::map<std::string, std::string> &parameterMap, std::string &resultReceiver)
+    : parameterMap_(parameterMap), resultReceiver_(resultReceiver)
+{}
+
+Packager::~Packager() {}
+
+std::string Packager::MakePackage()
+{
+    if (InitAllowedParam() != ERR_OK) {
+        std::cout << "PreCheck err" << std::endl;
+    }
+
+    if (PreProcess() != ERR_OK) {
+        std::cout << "PreCheck err" << std::endl;
+    }
+
+    if (Process() != ERR_OK) {
+        std::cout << "DoPackage err" << std::endl;
+    }
+
+    if (PostProcess() != ERR_OK) {
+        std::cout << "PostCheck err" << std::endl;
+    }
+
+    return "OHOS::ERR_OK";
+}
+
+int Packager::PreProcess()
+{
+    std::cout << "PreCheck" << std::endl;
+    resultReceiver_.append("do PreCheck\n");
+    return ERR_OK;
+}
+
+int Packager::Process()
+{
+    std::cout << "DoPackage" << std::endl;
+    resultReceiver_.append("do DoPackage\n");
+    return ERR_OK;
+}
+
+int Packager::PostProcess()
+{
+    std::cout << "PostCheck" << std::endl;
+    resultReceiver_.append("do PostCheck\n");
+    return ERR_OK;
+}
+
+void Packager::AddFileToZip(zipFile zf, const fs::path &filePath, const fs::path &zipPath, zip_fileinfo &zipfi)
+{
+    if (fs::is_directory(filePath)) {
+        for (const auto &entry : fs::directory_iterator(filePath)) {
+            fs::path tmpPath = zipPath / entry.path().filename();
+            AddFileToZip(zf, entry.path(), tmpPath, zipfi);
+        }
+    } else if (fs::is_regular_file(filePath)) {
+        std::ifstream file(filePath, std::ios::binary);
+        if (!file.is_open()) {
+            std::cout << "err opening file for read: " << filePath << std::endl;
+        }
+        int ret = zipOpenNewFileInZip(zf, zipPath.string().c_str(), &zipfi, nullptr, 0,
+            nullptr, 0, nullptr, 0, Z_DEFAULT_COMPRESSION);
+        if (ret != ZIP_OK) {
+            std::cout << "zipOpenNewFileInZip err: " << ret << ", " << filePath << std::endl;
+            file.close();
+            return ;
+        }
+        char buffer[Constants::BUF_SIZE];
+        while (file.good()) {
+            file.read(buffer, sizeof(buffer));
+            auto bytesRead = file.gcount();
+            if (bytesRead <= 0) {
+                std::cout << "read file: " << filePath << " err, bytesRead: " << bytesRead << std::endl;
+                break;
+            }
+            if (zipWriteInFileInZip(zf, buffer, bytesRead) < 0) {
+                std::cout << "err write to zip file: " << filePath << std::endl;
+                break;
+            }
+        }
+        zipCloseFileInZip(zf);
+        file.close();
+    }
+}
+
+void Packager::WriteStringToZip(zipFile zf, const std::string &content, const fs::path &zipPath, zip_fileinfo &zipfi)
+{
+    if (zipOpenNewFileInZip(zf, zipPath.string().c_str(), &zipfi, nullptr, 0, nullptr, 0, nullptr, 0,
+                            Z_DEFAULT_COMPRESSION) == ZIP_OK) {
+        if (zipWriteInFileInZip(zf, content.data(), content.length()) < 0) {
+            std::cout << "zipWriteInFileInZip err: " << errno << std::endl;
+        }
+        zipCloseFileInZip(zf);
+    }
+}
+
+bool Packager::ParseJsonFile(nlohmann::json &jsonObject, std::string filePath)
+{
+    std::ifstream i(filePath);
+    if (!i.is_open()) {
+        std::cout<<"failed to open json file, errno: " << errno << std::endl;
+        return false;
+    }
+    i.seekg(0, std::ios::end);
+    int len = static_cast<int>(i.tellg());
+    if (len == 0) {
+        i.close();
+        std::cout << "json file is empty" << std::endl;
+        return true;
+    }
+    i.seekg(0, std::ios::beg);
+    jsonObject = nlohmann::json::parse(i, nullptr, false);
+    if (jsonObject.is_discarded()) {
+        i.close();
+        std::cout << "ParseJsonFile failed due to data is discarded." << std::endl;
+        return false;
+    }
+    i.close();
+    return true;
+}
+
+bool Packager::endWith(const std::string &str, const std::string &suffix)
+{
+    if (str.length() >= suffix.length()) {
+        return str.compare(str.length() - suffix.length(), suffix.length(), suffix);
+    }
+    return false;
+}
+
+bool Packager::CheckFileValid(const std::string &filePath, const std::string &filename)
+{
+    if (fs::is_regular_file(filePath)) {
+        std::string name = fs::path(filePath).filename();
+        if (endWith(name, filename)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+
+} // namespace AppPackingTool
+} // namespace OHOS
\ No newline at end of file
diff --git a/ohos_packing_tool/frameworks/src/shell_command.cpp b/ohos_packing_tool/frameworks/src/shell_command.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fe51887b5697fbf0236ebfa6de8124193951d772
--- /dev/null
+++ b/ohos_packing_tool/frameworks/src/shell_command.cpp
@@ -0,0 +1,157 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "shell_command.h"
+
+#include <getopt.h>
+#include <iostream>
+#include <memory>
+#include <string>
+
+#include "constants.h"
+#include "packager.h"
+#include "hap_packager.h"
+#include "hsp_packager.h"
+
+namespace OHOS {
+namespace AppPackingTool {
+namespace {
+
+} // namespace
+
+ShellCommand::ShellCommand(int argc, char *argv[], std::string name)
+{
+    opterr = 0;
+    argc_ = argc;
+    argv_ = argv;
+    name_ = name;
+
+    if (argc < MIN_ARGUMENT_NUMBER) {
+        cmd_ = Constants::CMD_HELP;
+        return;
+    }
+    cmd_ = argv[1];
+}
+
+ShellCommand::~ShellCommand() {}
+
+int ShellCommand::CreateCommandMap()
+{
+    commandMap_ = {
+        {"help", std::bind(&ShellCommand::RunAsHelpCommand, this)},
+        {"pack", std::bind(&ShellCommand::RunAsPackCommand, this)},
+        {"unpack", std::bind(&ShellCommand::RunAsUnpackCommand, this)},
+    };
+    return ERR_OK;
+}
+
+int ShellCommand::ParseParam()
+{
+    int n = 0;
+    while (n < Constants::OPTIONS_SIZE) {
+        int32_t option = getopt_long(argc_, argv_, Constants::SHORT_OPTIONS, Constants::LONG_OPTIONS, nullptr);
+        if (optind < 0 || optind > argc_) {
+            return ERR_INVALID_VALUE;
+        }
+        if (option < 0) {
+            std::cout << "ParseParam finish." << std::endl;
+            break;
+        } else if (option == '?') {
+            resultReceiver_.append("not support param: ").append(argv_[optind - 1]).append("\n");
+            return ERR_INVALID_VALUE;
+        } else {
+            // example: --mode hap
+            std::string paramName = argv_[optind - OFFSET_REQUIRED_ARGUMENT];
+            paramName = paramName.substr(Constants::PARAM_PREFIX.length());
+            std::string paramValue = optarg;
+            parameterMap_[paramName] = optarg;
+        }
+        n++;
+    }
+    return ERR_OK;
+}
+
+int ShellCommand::OnCommand()
+{
+    auto respond = commandMap_[cmd_];
+    if (respond == nullptr) {
+        resultReceiver_.append("not support command: ").append(cmd_).append("\n");
+        respond = commandMap_[Constants::CMD_HELP];
+    }
+    respond();
+    return ERR_OK;
+}
+
+std::string ShellCommand::ExecCommand()
+{
+    int result = CreateCommandMap();
+    if (result != ERR_OK) {
+        resultReceiver_.append("failed to create command map.\n");
+        return resultReceiver_;
+    }
+    result = ParseParam();
+    if (result != ERR_OK) {
+        resultReceiver_.append("failed to init parameter map.\n");
+        return resultReceiver_;
+    }
+
+    result = OnCommand();
+    if (result != ERR_OK) {
+        resultReceiver_.append("failed to execute your command.\n");
+        return resultReceiver_;
+    }
+    return resultReceiver_;
+}
+
+int ShellCommand::RunAsHelpCommand()
+{
+    resultReceiver_.append(HELP_MSG);
+    return ERR_OK;
+}
+
+int ShellCommand::RunAsPackCommand()
+{
+    std::cout << "RunAsPackCommand " << std::endl;
+    std::unique_ptr<Packager> packager = getPackager();
+    if (packager != nullptr) {
+        packager->MakePackage();
+    }
+    return ERR_OK;
+}
+
+int ShellCommand::RunAsUnpackCommand()
+{
+    std::cout << "RunAsUnpackCommand " << std::endl;
+    return ERR_OK;
+}
+
+std::unique_ptr<Packager> ShellCommand::getPackager()
+{
+    std::string mode = parameterMap_[Constants::PARAM_MODE];
+    if (mode == Constants::MODE_HAP) {
+        std::unique_ptr<Packager> packager =
+            std::make_unique<HapPackager>(parameterMap_, resultReceiver_);
+        return packager;
+    } else if (mode == Constants::MODE_HSP) {
+        std::unique_ptr<Packager> packager =
+            std::make_unique<HspPackager>(parameterMap_, resultReceiver_);
+        return packager;
+    }
+    resultReceiver_.append("not support --mode: ").append(mode).append("\n");
+    return nullptr;
+}
+
+} // namespace AppPackingTool
+} // namespace OHOS
\ No newline at end of file