@revopush/code-push-cli 0.0.1

package/bin/script/commands/debug.js

@@ -0,0 +1,125 @@
+"use strict";
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+Object.defineProperty(exports, "__esModule", { value: true });
+const childProcess = require("child_process");
+const moment = require("moment");
+const path = require("path");
+const Q = require("q");
+const simctl = require("simctl");
+const which = require("which");
+class AndroidDebugPlatform {
+    getLogProcess() {
+        try {
+            which.sync("adb");
+        }
+        catch (e) {
+            throw new Error("ADB command not found. Please ensure it is installed and available on your path.");
+        }
+        const numberOfAvailableDevices = this.getNumberOfAvailableDevices();
+        if (numberOfAvailableDevices === 0) {
+            throw new Error("No Android devices found. Re-run this command after starting one.");
+        }
+        // For now there is no ability to specify device for debug like:
+        // code-push debug android "192.168.121.102:5555"
+        // So we have to throw an error in case more than 1 android device was attached
+        // otherwise we will very likely run into an exception while trying to read ‘adb logcat’ from device which codepushified app is not running on.
+        if (numberOfAvailableDevices > 1) {
+            throw new Error(`Found "${numberOfAvailableDevices}" android devices. Please leave only one device you need to debug.`);
+        }
+        return childProcess.spawn("adb", ["logcat"]);
+    }
+    // The following is an example of what the output looks
+    // like when running the "adb devices" command.
+    //
+    // List of devices attached
+    // emulator-5554    device
+    // 192.168.121.102:5555    device
+    getNumberOfAvailableDevices() {
+        const output = childProcess.execSync("adb devices").toString();
+        const matches = output.match(/\b(device)\b/gim);
+        if (matches != null) {
+            return matches.length;
+        }
+        return 0;
+    }
+    normalizeLogMessage(message) {
+        // Check to see whether the message includes the source URL
+        // suffix, and if so, strip it. This can occur in Android Cordova apps.
+        const sourceURLIndex = message.indexOf('", source: file:///');
+        if (~sourceURLIndex) {
+            return message.substring(0, sourceURLIndex);
+        }
+        else {
+            return message;
+        }
+    }
+}
+class iOSDebugPlatform {
+    getSimulatorID() {
+        const output = simctl.list({ devices: true, silent: true });
+        const simulators = output.json.devices
+            .map((platform) => platform.devices)
+            .reduce((prev, next) => prev.concat(next))
+            .filter((device) => device.state === "Booted")
+            .map((device) => device.id);
+        return simulators[0];
+    }
+    getLogProcess() {
+        if (process.platform !== "darwin") {
+            throw new Error("iOS debug logs can only be viewed on OS X.");
+        }
+        const simulatorID = this.getSimulatorID();
+        if (!simulatorID) {
+            throw new Error("No iOS simulators found. Re-run this command after starting one.");
+        }
+        const logFilePath = path.join(process.env.HOME, "Library/Logs/CoreSimulator", simulatorID, "system.log");
+        return childProcess.spawn("tail", ["-f", logFilePath]);
+    }
+    normalizeLogMessage(message) {
+        return message;
+    }
+}
+const logMessagePrefix = "[CodePush] ";
+function processLogData(logData) {
+    const content = logData.toString();
+    content
+        .split("\n")
+        .filter((line) => line.indexOf(logMessagePrefix) > -1)
+        .map((line) => {
+        // Allow the current platform
+        // to normalize the message first.
+        line = this.normalizeLogMessage(line);
+        // Strip the CodePush-specific, platform agnostic
+        // log message prefix that is added to each entry.
+        const message = line.substring(line.indexOf(logMessagePrefix) + logMessagePrefix.length);
+        const timeStamp = moment().format("hh:mm:ss");
+        return `[${timeStamp}] ${message}`;
+    })
+        .forEach((line) => console.log(line));
+}
+const debugPlatforms = {
+    android: new AndroidDebugPlatform(),
+    ios: new iOSDebugPlatform(),
+};
+function default_1(command) {
+    return Q.Promise((resolve, reject) => {
+        const platform = command.platform.toLowerCase();
+        const debugPlatform = debugPlatforms[platform];
+        if (!debugPlatform) {
+            const availablePlatforms = Object.getOwnPropertyNames(debugPlatforms);
+            return reject(new Error(`"${platform}" is an unsupported platform. Available options are ${availablePlatforms.join(", ")}.`));
+        }
+        try {
+            const logProcess = debugPlatform.getLogProcess();
+            console.log(`Listening for ${platform} debug logs (Press CTRL+C to exit)`);
+            logProcess.stdout.on("data", processLogData.bind(debugPlatform));
+            logProcess.stderr.on("data", reject);
+            logProcess.on("close", resolve);
+        }
+        catch (e) {
+            reject(e);
+        }
+    });
+}
+exports.default = default_1;

package/bin/script/hash-utils.js

@@ -0,0 +1,203 @@
+"use strict";
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PackageManifest = exports.hashStream = exports.hashFile = exports.generatePackageManifestFromDirectory = exports.generatePackageManifestFromZip = exports.generatePackageHashFromDirectory = void 0;
+/**
+ * NOTE!!! This utility file is duplicated for use by the CodePush service (for server-driven hashing/
+ * integrity checks) and Management SDK (for end-to-end code signing), please keep them in sync.
+ */
+const crypto = require("crypto");
+const fs = require("fs");
+const path = require("path");
+const q = require("q");
+// Do not throw an exception if either of these modules are missing, as they may not be needed by the
+// consumer of this file.
+// - recursiveFs: Only required for hashing of directories
+// - yauzl: Only required for in-memory hashing of zip files
+let recursiveFs, yauzl;
+try {
+    recursiveFs = require("recursive-fs");
+}
+catch (e) { }
+try {
+    yauzl = require("yauzl");
+}
+catch (e) { }
+const HASH_ALGORITHM = "sha256";
+function generatePackageHashFromDirectory(directoryPath, basePath) {
+    if (!fs.lstatSync(directoryPath).isDirectory()) {
+        throw new Error("Not a directory. Please either create a directory, or use hashFile().");
+    }
+    return generatePackageManifestFromDirectory(directoryPath, basePath).then((manifest) => {
+        return manifest.computePackageHash();
+    });
+}
+exports.generatePackageHashFromDirectory = generatePackageHashFromDirectory;
+function generatePackageManifestFromZip(filePath) {
+    const deferred = q.defer();
+    const reject = (error) => {
+        if (deferred.promise.isPending()) {
+            deferred.reject(error);
+        }
+    };
+    const resolve = (manifest) => {
+        if (deferred.promise.isPending()) {
+            deferred.resolve(manifest);
+        }
+    };
+    let zipFile;
+    yauzl.open(filePath, { lazyEntries: true }, (error, openedZipFile) => {
+        if (error) {
+            // This is the first time we try to read the package as a .zip file;
+            // however, it may not be a .zip file.  Handle this gracefully.
+            resolve(null);
+            return;
+        }
+        zipFile = openedZipFile;
+        const fileHashesMap = new Map();
+        const hashFilePromises = [];
+        // Read each entry in the archive sequentially and generate a hash for it.
+        zipFile.readEntry();
+        zipFile
+            .on("error", (error) => {
+            reject(error);
+        })
+            .on("entry", (entry) => {
+            const fileName = PackageManifest.normalizePath(entry.fileName);
+            if (PackageManifest.isIgnored(fileName)) {
+                zipFile.readEntry();
+                return;
+            }
+            zipFile.openReadStream(entry, (error, readStream) => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                hashFilePromises.push(hashStream(readStream).then((hash) => {
+                    fileHashesMap.set(fileName, hash);
+                    zipFile.readEntry();
+                }, reject));
+            });
+        })
+            .on("end", () => {
+            q.all(hashFilePromises).then(() => resolve(new PackageManifest(fileHashesMap)), reject);
+        });
+    });
+    return deferred.promise.finally(() => zipFile && zipFile.close());
+}
+exports.generatePackageManifestFromZip = generatePackageManifestFromZip;
+function generatePackageManifestFromDirectory(directoryPath, basePath) {
+    const deferred = q.defer();
+    const fileHashesMap = new Map();
+    recursiveFs.readdirr(directoryPath, (error, directories, files) => {
+        if (error) {
+            deferred.reject(error);
+            return;
+        }
+        if (!files || files.length === 0) {
+            deferred.reject("Error: Can't sign the release because no files were found.");
+            return;
+        }
+        // Hash the files sequentially, because streaming them in parallel is not necessarily faster
+        const generateManifestPromise = files.reduce((soFar, filePath) => {
+            return soFar.then(() => {
+                const relativePath = PackageManifest.normalizePath(path.relative(basePath, filePath));
+                if (!PackageManifest.isIgnored(relativePath)) {
+                    return hashFile(filePath).then((hash) => {
+                        fileHashesMap.set(relativePath, hash);
+                    });
+                }
+            });
+        }, q(null));
+        generateManifestPromise
+            .then(() => {
+            deferred.resolve(new PackageManifest(fileHashesMap));
+        }, deferred.reject)
+            .done();
+    });
+    return deferred.promise;
+}
+exports.generatePackageManifestFromDirectory = generatePackageManifestFromDirectory;
+function hashFile(filePath) {
+    const readStream = fs.createReadStream(filePath);
+    return hashStream(readStream);
+}
+exports.hashFile = hashFile;
+function hashStream(readStream) {
+    const hashStream = crypto.createHash(HASH_ALGORITHM);
+    const deferred = q.defer();
+    readStream
+        .on("error", (error) => {
+        if (deferred.promise.isPending()) {
+            hashStream.end();
+            deferred.reject(error);
+        }
+    })
+        .on("end", () => {
+        if (deferred.promise.isPending()) {
+            hashStream.end();
+            const buffer = hashStream.read();
+            const hash = buffer.toString("hex");
+            deferred.resolve(hash);
+        }
+    });
+    readStream.pipe(hashStream);
+    return deferred.promise;
+}
+exports.hashStream = hashStream;
+class PackageManifest {
+    _map;
+    constructor(map) {
+        if (!map) {
+            map = new Map();
+        }
+        this._map = map;
+    }
+    toMap() {
+        return this._map;
+    }
+    computePackageHash() {
+        let entries = [];
+        this._map.forEach((hash, name) => {
+            entries.push(name + ":" + hash);
+        });
+        // Make sure this list is alphabetically ordered so that other clients
+        // can also compute this hash easily given the update contents.
+        entries = entries.sort();
+        return q(crypto.createHash(HASH_ALGORITHM).update(JSON.stringify(entries)).digest("hex"));
+    }
+    serialize() {
+        const obj = {};
+        this._map.forEach(function (value, key) {
+            obj[key] = value;
+        });
+        return JSON.stringify(obj);
+    }
+    static deserialize(serializedContents) {
+        try {
+            const obj = JSON.parse(serializedContents);
+            const map = new Map();
+            for (const key of Object.keys(obj)) {
+                map.set(key, obj[key]);
+            }
+            return new PackageManifest(map);
+        }
+        catch (e) { }
+    }
+    static normalizePath(filePath) {
+        return filePath.replace(/\\/g, "/");
+    }
+    static isIgnored(relativeFilePath) {
+        const __MACOSX = "__MACOSX/";
+        const DS_STORE = ".DS_Store";
+        return startsWith(relativeFilePath, __MACOSX) || relativeFilePath === DS_STORE || endsWith(relativeFilePath, "/" + DS_STORE);
+    }
+}
+exports.PackageManifest = PackageManifest;
+function startsWith(str, prefix) {
+    return str && str.substring(0, prefix.length) === prefix;
+}
+function endsWith(str, suffix) {
+    return str && str.indexOf(suffix, str.length - suffix.length) !== -1;
+}

package/bin/script/index.js

@@ -0,0 +1,5 @@
+"use strict";
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+const AccountManager = require("./management-sdk");
+module.exports = AccountManager;