code-push-itspar 1.0.0

package/bin/test/hash-utils.js

@@ -0,0 +1,149 @@
+"use strict";
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert = require("assert");
+const crypto = require("crypto");
+const fs = require("fs");
+const hashUtils = require("../script/hash-utils");
+var mkdirp = require("mkdirp");
+const os = require("os");
+const path = require("path");
+const q = require("q");
+var yauzl = require("yauzl");
+function randomString() {
+    var stringLength = 10;
+    return crypto
+        .randomBytes(Math.ceil(stringLength / 2))
+        .toString("hex") // convert to hexadecimal format
+        .slice(0, stringLength); // return required number of characters
+}
+function unzipToDirectory(zipPath, directoryPath) {
+    var deferred = q.defer();
+    var originalCwd = process.cwd();
+    mkdirp(directoryPath, (err) => {
+        if (err)
+            throw err;
+        process.chdir(directoryPath);
+        yauzl.open(zipPath, { lazyEntries: true }, function (err, zipfile) {
+            if (err)
+                throw err;
+            zipfile.readEntry();
+            zipfile.on("entry", function (entry) {
+                if (/\/$/.test(entry.fileName)) {
+                    // directory file names end with '/'
+                    mkdirp(entry.fileName, function (err) {
+                        if (err)
+                            throw err;
+                        zipfile.readEntry();
+                    });
+                }
+                else {
+                    // file entry
+                    zipfile.openReadStream(entry, function (err, readStream) {
+                        if (err)
+                            throw err;
+                        // ensure parent directory exists
+                        mkdirp(path.dirname(entry.fileName), function (err) {
+                            if (err)
+                                throw err;
+                            readStream.pipe(fs.createWriteStream(entry.fileName));
+                            readStream.on("end", function () {
+                                zipfile.readEntry();
+                            });
+                        });
+                    });
+                }
+            });
+            zipfile.on("end", function (err) {
+                if (err)
+                    deferred.reject(err);
+                else
+                    deferred.resolve(null);
+            });
+        });
+    });
+    return deferred.promise.finally(() => {
+        process.chdir(originalCwd);
+    });
+}
+describe("Hashing utility", () => {
+    const TEST_DIRECTORY = path.join(os.tmpdir(), "codepushtests", randomString());
+    const TEST_ARCHIVE_FILE_PATH = path.join(__dirname, "resources", "test.zip");
+    const TEST_ZIP_HASH = "540fed8df3553079e81d1353c5cc4e3cac7db9aea647a85d550f646e8620c317";
+    const TEST_ZIP_MANIFEST_HASH = "9e0499ce7df5c04cb304c9deed684dc137fc603cb484a5b027478143c595d80b";
+    const HASH_B = "3e23e8160039594a33894f6564e1b1348bbd7a0088d42c4acb73eeaed59c009d";
+    const HASH_C = "2e7d2c03a9507ae265ecf5b5356885a53393a2029d241394997265a1a25aefc6";
+    const HASH_D = "18ac3e7343f016890c510e93f935261169d9e3f565436429830faf0934f4f8e4";
+    const IGNORED_METADATA_ARCHIVE_FILE_PATH = path.join(__dirname, "resources", "ignoredMetadata.zip");
+    const INDEX_HASH = "b0693dc92f76e08bf1485b3dd9b514a2e31dfd6f39422a6b60edb722671dc98f";
+    it("generates a package hash from file", (done) => {
+        hashUtils.hashFile(TEST_ARCHIVE_FILE_PATH).done((packageHash) => {
+            assert.equal(packageHash, TEST_ZIP_HASH);
+            done();
+        });
+    });
+    it("generates a package manifest for an archive", (done) => {
+        hashUtils.generatePackageManifestFromZip(TEST_ARCHIVE_FILE_PATH).done((manifest) => {
+            var fileHashesMap = manifest.toMap();
+            assert.equal(fileHashesMap.size, 3);
+            var hash = fileHashesMap.get("b.txt");
+            assert.equal(hash, HASH_B);
+            hash = fileHashesMap.get("c.txt");
+            assert.equal(hash, HASH_C);
+            hash = fileHashesMap.get("d.txt");
+            assert.equal(hash, HASH_D);
+            done();
+        });
+    });
+    it("generates a package manifest for a directory", (done) => {
+        var directory = path.join(TEST_DIRECTORY, "testZip");
+        unzipToDirectory(TEST_ARCHIVE_FILE_PATH, directory)
+            .then(() => {
+            return hashUtils.generatePackageManifestFromDirectory(/*directoryPath*/ directory, /*basePath*/ directory);
+        })
+            .done((manifest) => {
+            var fileHashesMap = manifest.toMap();
+            assert.equal(fileHashesMap.size, 3);
+            var hash = fileHashesMap.get("b.txt");
+            assert.equal(hash, HASH_B);
+            hash = fileHashesMap.get("c.txt");
+            assert.equal(hash, HASH_C);
+            hash = fileHashesMap.get("d.txt");
+            assert.equal(hash, HASH_D);
+            done();
+        });
+    });
+    it("generates a package hash from manifest", (done) => {
+        hashUtils
+            .generatePackageManifestFromZip(TEST_ARCHIVE_FILE_PATH)
+            .then((manifest) => {
+            return manifest.computePackageHash();
+        })
+            .done((packageHash) => {
+            assert.equal(packageHash, TEST_ZIP_MANIFEST_HASH);
+            done();
+        });
+    });
+    it("generates a package manifest for an archive with ignorable metadata", (done) => {
+        hashUtils.generatePackageManifestFromZip(IGNORED_METADATA_ARCHIVE_FILE_PATH).done((manifest) => {
+            assert.equal(manifest.toMap().size, 1);
+            var hash = manifest.toMap().get("www/index.html");
+            assert.equal(hash, INDEX_HASH);
+            done();
+        });
+    });
+    it("generates a package manifest for a directory with ignorable metadata", (done) => {
+        var directory = path.join(TEST_DIRECTORY, "ignorableMetadata");
+        unzipToDirectory(IGNORED_METADATA_ARCHIVE_FILE_PATH, directory)
+            .then(() => {
+            return hashUtils.generatePackageManifestFromDirectory(/*directoryPath*/ directory, /*basePath*/ directory);
+        })
+            .done((manifest) => {
+            assert.equal(manifest.toMap().size, 1);
+            var hash = manifest.toMap().get("www/index.html");
+            assert.equal(hash, INDEX_HASH);
+            done();
+        });
+    });
+});

package/bin/test/management-sdk.js

@@ -0,0 +1,338 @@
+"use strict";
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert = require("assert");
+const Q = require("q");
+const AccountManager = require("../script/management-sdk");
+var request = require("superagent");
+var manager;
+describe("Management SDK", () => {
+    beforeEach(() => {
+        manager = new AccountManager(/*accessKey=*/ "dummyAccessKey", /*customHeaders=*/ null, /*serverUrl=*/ "http://localhost");
+    });
+    after(() => {
+        // Prevent an exception that occurs due to how superagent-mock overwrites methods
+        request.Request.prototype._callback = function () { };
+    });
+    it("methods reject the promise with status code info when an error occurs", (done) => {
+        mockReturn("Text", 404);
+        var methodsWithErrorHandling = [
+            manager.addApp.bind(manager, "appName"),
+            manager.getApp.bind(manager, "appName"),
+            manager.renameApp.bind(manager, "appName", {}),
+            manager.removeApp.bind(manager, "appName"),
+            manager.transferApp.bind(manager, "appName", "email1"),
+            manager.addDeployment.bind(manager, "appName", "deploymentName"),
+            manager.getDeployment.bind(manager, "appName", "deploymentName"),
+            manager.getDeployments.bind(manager, "appName"),
+            manager.renameDeployment.bind(manager, "appName", "deploymentName", {
+                name: "newDeploymentName",
+            }),
+            manager.removeDeployment.bind(manager, "appName", "deploymentName"),
+            manager.addCollaborator.bind(manager, "appName", "email1"),
+            manager.getCollaborators.bind(manager, "appName"),
+            manager.removeCollaborator.bind(manager, "appName", "email1"),
+            manager.patchRelease.bind(manager, "appName", "deploymentName", "label", {
+                description: "newDescription",
+            }),
+            manager.promote.bind(manager, "appName", "deploymentName", "newDeploymentName", { description: "newDescription" }),
+            manager.rollback.bind(manager, "appName", "deploymentName", "targetReleaseLabel"),
+        ];
+        var result = Q(null);
+        methodsWithErrorHandling.forEach(function (f) {
+            result = result.then(() => {
+                return testErrors(f);
+            });
+        });
+        result.done(() => {
+            done();
+        });
+        // Test that the proper error code and text is passed through on a server error
+        function testErrors(method) {
+            return Q.Promise((resolve, reject, notify) => {
+                method().done(() => {
+                    assert.fail("Should have thrown an error");
+                    reject();
+                }, (error) => {
+                    assert.equal(error.message, "Text");
+                    assert(error.statusCode);
+                    resolve();
+                });
+            });
+        }
+    });
+    it("isAuthenticated handles successful auth", (done) => {
+        mockReturn(JSON.stringify({ authenticated: true }), 200, {});
+        manager.isAuthenticated().done((authenticated) => {
+            assert(authenticated, "Should be authenticated");
+            done();
+        });
+    });
+    it("isAuthenticated handles unsuccessful auth", (done) => {
+        mockReturn("Unauthorized", 401, {});
+        manager.isAuthenticated().done((authenticated) => {
+            assert(!authenticated, "Should not be authenticated");
+            done();
+        });
+    });
+    it("isAuthenticated handles unsuccessful auth with promise rejection", (done) => {
+        mockReturn("Unauthorized", 401, {});
+        // use optional parameter to ask for rejection of the promise if not authenticated
+        manager.isAuthenticated(true).done((authenticated) => {
+            assert.fail("isAuthenticated should have rejected the promise");
+            done();
+        }, (err) => {
+            assert.equal(err.message, "Unauthorized", "Error message should be 'Unauthorized'");
+            done();
+        });
+    });
+    it("isAuthenticated handles unexpected status codes", (done) => {
+        mockReturn("Not Found", 404, {});
+        manager.isAuthenticated().done((authenticated) => {
+            assert.fail("isAuthenticated should have rejected the promise");
+            done();
+        }, (err) => {
+            assert.equal(err.message, "Not Found", "Error message should be 'Not Found'");
+            done();
+        });
+    });
+    it("addApp handles successful response", (done) => {
+        mockReturn(JSON.stringify({ success: true }), 201, {
+            location: "/appName",
+        });
+        manager.addApp("appName").done((obj) => {
+            assert.ok(obj);
+            done();
+        }, rejectHandler);
+    });
+    it("addApp handles error response", (done) => {
+        mockReturn(JSON.stringify({ success: false }), 404, {});
+        manager.addApp("appName").done((obj) => {
+            throw new Error("Call should not complete successfully");
+        }, (error) => done());
+    });
+    it("getApp handles JSON response", (done) => {
+        mockReturn(JSON.stringify({ app: {} }), 200, {});
+        manager.getApp("appName").done((obj) => {
+            assert.ok(obj);
+            done();
+        }, rejectHandler);
+    });
+    it("updateApp handles success response", (done) => {
+        mockReturn(JSON.stringify({ apps: [] }), 200, {});
+        manager.renameApp("appName", "newAppName").done((obj) => {
+            assert.ok(!obj);
+            done();
+        }, rejectHandler);
+    });
+    it("removeApp handles success response", (done) => {
+        mockReturn("", 200, {});
+        manager.removeApp("appName").done((obj) => {
+            assert.ok(!obj);
+            done();
+        }, rejectHandler);
+    });
+    it("transferApp handles successful response", (done) => {
+        mockReturn("", 201);
+        manager.transferApp("appName", "email1").done((obj) => {
+            assert.ok(!obj);
+            done();
+        }, rejectHandler);
+    });
+    it("addDeployment handles success response", (done) => {
+        mockReturn(JSON.stringify({ deployment: { name: "name", key: "key" } }), 201, { location: "/deploymentName" });
+        manager.addDeployment("appName", "deploymentName").done((obj) => {
+            assert.ok(obj);
+            done();
+        }, rejectHandler);
+    });
+    it("getDeployment handles JSON response", (done) => {
+        mockReturn(JSON.stringify({ deployment: {} }), 200, {});
+        manager.getDeployment("appName", "deploymentName").done((obj) => {
+            assert.ok(obj);
+            done();
+        }, rejectHandler);
+    });
+    it("getDeployments handles JSON response", (done) => {
+        mockReturn(JSON.stringify({ deployments: [] }), 200, {});
+        manager.getDeployments("appName").done((obj) => {
+            assert.ok(obj);
+            done();
+        }, rejectHandler);
+    });
+    it("renameDeployment handles success response", (done) => {
+        mockReturn(JSON.stringify({ apps: [] }), 200, {});
+        manager.renameDeployment("appName", "deploymentName", "newDeploymentName").done((obj) => {
+            assert.ok(!obj);
+            done();
+        }, rejectHandler);
+    });
+    it("removeDeployment handles success response", (done) => {
+        mockReturn("", 200, {});
+        manager.removeDeployment("appName", "deploymentName").done((obj) => {
+            assert.ok(!obj);
+            done();
+        }, rejectHandler);
+    });
+    it("getDeploymentHistory handles success response with no packages", (done) => {
+        mockReturn(JSON.stringify({ history: [] }), 200);
+        manager.getDeploymentHistory("appName", "deploymentName").done((obj) => {
+            assert.ok(obj);
+            assert.equal(obj.length, 0);
+            done();
+        }, rejectHandler);
+    });
+    it("getDeploymentHistory handles success response with two packages", (done) => {
+        mockReturn(JSON.stringify({ history: [{ label: "v1" }, { label: "v2" }] }), 200);
+        manager.getDeploymentHistory("appName", "deploymentName").done((obj) => {
+            assert.ok(obj);
+            assert.equal(obj.length, 2);
+            assert.equal(obj[0].label, "v1");
+            assert.equal(obj[1].label, "v2");
+            done();
+        }, rejectHandler);
+    });
+    it("getDeploymentHistory handles error response", (done) => {
+        mockReturn("", 404);
+        manager.getDeploymentHistory("appName", "deploymentName").done((obj) => {
+            throw new Error("Call should not complete successfully");
+        }, (error) => done());
+    });
+    it("clearDeploymentHistory handles success response", (done) => {
+        mockReturn("", 204);
+        manager.clearDeploymentHistory("appName", "deploymentName").done((obj) => {
+            assert.ok(!obj);
+            done();
+        }, rejectHandler);
+    });
+    it("clearDeploymentHistory handles error response", (done) => {
+        mockReturn("", 404);
+        manager.clearDeploymentHistory("appName", "deploymentName").done((obj) => {
+            throw new Error("Call should not complete successfully");
+        }, (error) => done());
+    });
+    it("addCollaborator handles successful response", (done) => {
+        mockReturn("", 201, { location: "/collaborators" });
+        manager.addCollaborator("appName", "email1").done((obj) => {
+            assert.ok(!obj);
+            done();
+        }, rejectHandler);
+    });
+    it("addCollaborator handles error response", (done) => {
+        mockReturn("", 404, {});
+        manager.addCollaborator("appName", "email1").done((obj) => {
+            throw new Error("Call should not complete successfully");
+        }, (error) => done());
+    });
+    it("getCollaborators handles success response with no collaborators", (done) => {
+        mockReturn(JSON.stringify({ collaborators: {} }), 200);
+        manager.getCollaborators("appName").done((obj) => {
+            assert.ok(obj);
+            assert.equal(Object.keys(obj).length, 0);
+            done();
+        }, rejectHandler);
+    });
+    it("getCollaborators handles success response with multiple collaborators", (done) => {
+        mockReturn(JSON.stringify({
+            collaborators: {
+                email1: { permission: "Owner", isCurrentAccount: true },
+                email2: { permission: "Collaborator", isCurrentAccount: false },
+            },
+        }), 200);
+        manager.getCollaborators("appName").done((obj) => {
+            assert.ok(obj);
+            assert.equal(obj["email1"].permission, "Owner");
+            assert.equal(obj["email2"].permission, "Collaborator");
+            done();
+        }, rejectHandler);
+    });
+    it("removeCollaborator handles success response", (done) => {
+        mockReturn("", 200, {});
+        manager.removeCollaborator("appName", "email1").done((obj) => {
+            assert.ok(!obj);
+            done();
+        }, rejectHandler);
+    });
+    it("patchRelease handles success response", (done) => {
+        mockReturn(JSON.stringify({ package: { description: "newDescription" } }), 200);
+        manager
+            .patchRelease("appName", "deploymentName", "label", {
+            description: "newDescription",
+        })
+            .done((obj) => {
+            assert.ok(!obj);
+            done();
+        }, rejectHandler);
+    });
+    it("patchRelease handles error response", (done) => {
+        mockReturn("", 400);
+        manager.patchRelease("appName", "deploymentName", "label", {}).done((obj) => {
+            throw new Error("Call should not complete successfully");
+        }, (error) => done());
+    });
+    it("promote handles success response", (done) => {
+        mockReturn(JSON.stringify({ package: { description: "newDescription" } }), 200);
+        manager
+            .promote("appName", "deploymentName", "newDeploymentName", {
+            description: "newDescription",
+        })
+            .done((obj) => {
+            assert.ok(!obj);
+            done();
+        }, rejectHandler);
+    });
+    it("promote handles error response", (done) => {
+        mockReturn("", 400);
+        manager
+            .promote("appName", "deploymentName", "newDeploymentName", {
+            rollout: 123,
+        })
+            .done((obj) => {
+            throw new Error("Call should not complete successfully");
+        }, (error) => done());
+    });
+    it("rollback handles success response", (done) => {
+        mockReturn(JSON.stringify({ package: { label: "v1" } }), 200);
+        manager.rollback("appName", "deploymentName", "v1").done((obj) => {
+            assert.ok(!obj);
+            done();
+        }, rejectHandler);
+    });
+    it("rollback handles error response", (done) => {
+        mockReturn("", 400);
+        manager.rollback("appName", "deploymentName", "v1").done((obj) => {
+            throw new Error("Call should not complete successfully");
+        }, (error) => done());
+    });
+});
+// Helper method that is used everywhere that an assert.fail() is needed in a promise handler
+function rejectHandler(val) {
+    assert.fail();
+}
+// Wrapper for superagent-mock that abstracts away information not needed for SDK tests
+function mockReturn(bodyText, statusCode, header = {}) {
+    require("superagent-mock")(request, [
+        {
+            pattern: "http://localhost/(\\w+)/?",
+            fixtures: function (match, params) {
+                var isOk = statusCode >= 200 && statusCode < 300;
+                if (!isOk) {
+                    var err = new Error(bodyText);
+                    err.status = statusCode;
+                    throw err;
+                }
+                return {
+                    text: bodyText,
+                    status: statusCode,
+                    ok: isOk,
+                    header: header,
+                    headers: {},
+                };
+            },
+            callback: function (match, data) {
+                return data;
+            },
+        },
+    ]);
+}

package/bsdiff/README.md

@@ -0,0 +1,114 @@
+# ENDSLEY/BSDIFF43 Utility
+
+A cross-platform implementation of the ENDSLEY/BSDIFF43 binary diff and patch algorithm, optimized for CodePush deployments. While the standard `bsdiff` available through package managers supports BSDIFF40 format, this tool implements the enhanced ENDSLEY/BSDIFF43 format with additional optimizations for mobile app updates.
+
+## Why ENDSLEY/BSDIFF43?
+
+- **Optimized for Mobile**: Specifically tuned for React Native and Cordova app updates
+- **Streaming-First**: No seeking operations during patch application, perfect for mobile downloads
+- **Minimal Resource Usage**: Efficient streaming with minimal disk I/O and memory footprint
+- **Cross-Platform**: Works reliably on iOS, Android, and Windows platforms
+- **Integration-Ready**: Designed for easy integration with build and deployment systems
+- **Smaller Updates**: Generates optimized patch sizes for faster downloads
+- **Compression Options**: Flexible compression support (raw, bzip2, Brotli) for different scenarios
+
+## Credits
+
+Built using the bsdiff/bspatch library:
+- Original bsdiff algorithm by Colin Percival (2003-2005)
+- Enhanced ENDSLEY/BSDIFF43 version by Matthew Endsley (2012)
+- Source: https://github.com/mendsley/bsdiff
+
+## Prerequisites
+
+### Dependencies
+- bzip2 library (for compression support)
+  - **macOS**: Pre-installed
+  - **Ubuntu/Debian**: `sudo apt-get install libbz2-dev`
+  - **CentOS/RHEL**: `sudo yum install bzip2-devel`
+  - **Windows**: Available through WSL package manager
+
+## Usage
+
+### Building from Source
+To use bsdiff/bspatch directly without code-push-itspar, follow these steps:
+
+```bash
+cd cli/bsdiff
+make clean
+make
+```
+
+### Creating a Patch
+```bash
+./bsdiff43 diff <old_file> <new_file> <patch_file> <compression>
+```
+
+Parameters:
+- `old_file`: Path to the original bundle file
+- `new_file`: Path to the new bundle file
+- `patch_file`: Path where the patch file will be saved
+- `compression`: Boolean flag (true/false)
+  - `false` (default): Creates a raw patch that can be further compressed using Brotli
+  - `true`: Uses built-in bzip2 compression (Note: cannot be further compressed)
+
+Example:
+```bash
+./bsdiff43 diff old.bundle new.bundle patch.diff false
+```
+
+### Applying a Patch
+```bash
+./bsdiff43 patch <old_file> <patch_file> <output_file> <is_patch_compressed>
+```
+
+Parameters:
+- `old_file`: Path to the original bundle file
+- `patch_file`: Path to the patch file
+- `output_file`: Path where the reconstructed new file will be saved
+- `is_patch_compressed`: Boolean flag (true/false)
+  - Must match the compression setting used when creating the patch
+
+Example:
+```bash
+./bsdiff43 patch old.bundle patch.diff reconstructed.bundle false
+```
+
+### Compression Notes
+- When `compression=false`, the patch is created in raw format
+  - This is recommended when using with code-push-itspar as it allows for Brotli compression later
+  - Results in better compression ratios in most cases
+- When `compression=true`, the patch is compressed using bzip2
+  - Cannot be further compressed using other algorithms
+  - Useful for standalone usage without code-push-itspar
+
+## File Structure
+
+- `bsdiff/` - Contains the binary diff/patch utility
+  - `bsdiff43` - The compiled executable
+  - `bsdiff.c`, `bsdiff.h` - Source for diff functionality
+  - `bspatch.c`, `bspatch.h` - Source for patch functionality
+  - `main.c` - Main program entry point
+  - `Makefile` - Build configuration
+  - `LICENSE` - BSD 2-clause license
+
+### Error Handling
+
+Both functions return:
+- `0` on success
+- Non-zero value on error
+
+## License
+
+Licensed under BSD 2-clause:
+```
+Copyright 2003-2005 Colin Percival
+Copyright 2012 Matthew Endsley
+All rights reserved
+```
+
+Requirements:
+1. Keep the copyright notice and license text in source files
+2. Include the same copyright notice and license in binary distributions
+
+See `bsdiff/LICENSE` for complete license text.