@revopush/code-push-cli 0.0.1

package/script/commands/debug.ts

@@ -0,0 +1,148 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import * as childProcess from "child_process";
+import * as cli from "../../script/types/cli";
+import * as moment from "moment";
+import * as path from "path";
+import * as Q from "q";
+
+const simctl = require("simctl");
+const which = require("which");
+
+interface IDebugPlatform {
+  getLogProcess(): any;
+  normalizeLogMessage(message: string): string;
+}
+
+class AndroidDebugPlatform implements IDebugPlatform {
+  public getLogProcess(): any {
+    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
+  private getNumberOfAvailableDevices(): number {
+    const output = childProcess.execSync("adb devices").toString();
+    const matches = output.match(/\b(device)\b/gim);
+    if (matches != null) {
+      return matches.length;
+    }
+    return 0;
+  }
+
+  public normalizeLogMessage(message: string): string {
+    // 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: number = message.indexOf('", source: file:///');
+    if (~sourceURLIndex) {
+      return message.substring(0, sourceURLIndex);
+    } else {
+      return message;
+    }
+  }
+}
+
+class iOSDebugPlatform implements IDebugPlatform {
+  private getSimulatorID(): string {
+    const output: any = simctl.list({ devices: true, silent: true });
+    const simulators: string[] = output.json.devices
+      .map((platform: any) => platform.devices)
+      .reduce((prev: any, next: any) => prev.concat(next))
+      .filter((device: any) => device.state === "Booted")
+      .map((device: any) => device.id);
+
+    return simulators[0];
+  }
+
+  public getLogProcess(): any {
+    if (process.platform !== "darwin") {
+      throw new Error("iOS debug logs can only be viewed on OS X.");
+    }
+
+    const simulatorID: string = this.getSimulatorID();
+    if (!simulatorID) {
+      throw new Error("No iOS simulators found. Re-run this command after starting one.");
+    }
+
+    const logFilePath: string = path.join(process.env.HOME, "Library/Logs/CoreSimulator", simulatorID, "system.log");
+    return childProcess.spawn("tail", ["-f", logFilePath]);
+  }
+
+  public normalizeLogMessage(message: string): string {
+    return message;
+  }
+}
+
+const logMessagePrefix = "[CodePush] ";
+function processLogData(logData: Buffer) {
+  const content = logData.toString();
+  content
+    .split("\n")
+    .filter((line: string) => line.indexOf(logMessagePrefix) > -1)
+    .map((line: string) => {
+      // 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: string) => console.log(line));
+}
+
+const debugPlatforms: any = {
+  android: new AndroidDebugPlatform(),
+  ios: new iOSDebugPlatform(),
+};
+
+export default function (command: cli.IDebugCommand): Q.Promise<void> {
+  return Q.Promise<void>((resolve, reject) => {
+    const platform: string = command.platform.toLowerCase();
+    const debugPlatform: IDebugPlatform = 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);
+    }
+  });
+}

package/script/hash-utils.ts

@@ -0,0 +1,241 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+/**
+ * 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.
+ */
+
+import * as crypto from "crypto";
+import * as fs from "fs";
+import * as path from "path";
+import * as q from "q";
+import * as stream from "stream";
+
+// 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) {}
+
+import Promise = q.Promise;
+const HASH_ALGORITHM = "sha256";
+
+export function generatePackageHashFromDirectory(directoryPath: string, basePath: string): Promise<string> {
+  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: PackageManifest) => {
+    return manifest.computePackageHash();
+  });
+}
+
+export function generatePackageManifestFromZip(filePath: string): Promise<PackageManifest> {
+  const deferred: q.Deferred<PackageManifest> = q.defer<PackageManifest>();
+  const reject = (error: Error) => {
+    if (deferred.promise.isPending()) {
+      deferred.reject(error);
+    }
+  };
+
+  const resolve = (manifest: PackageManifest) => {
+    if (deferred.promise.isPending()) {
+      deferred.resolve(manifest);
+    }
+  };
+
+  let zipFile: any;
+
+  yauzl.open(filePath, { lazyEntries: true }, (error?: any, openedZipFile?: any): void => {
+    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<string, string>();
+    const hashFilePromises: q.Promise<void>[] = [];
+
+    // Read each entry in the archive sequentially and generate a hash for it.
+    zipFile.readEntry();
+    zipFile
+      .on("error", (error: any): void => {
+        reject(error);
+      })
+      .on("entry", (entry: any): void => {
+        const fileName: string = PackageManifest.normalizePath(entry.fileName);
+        if (PackageManifest.isIgnored(fileName)) {
+          zipFile.readEntry();
+          return;
+        }
+
+        zipFile.openReadStream(entry, (error?: any, readStream?: stream.Readable): void => {
+          if (error) {
+            reject(error);
+            return;
+          }
+
+          hashFilePromises.push(
+            hashStream(readStream).then((hash: string) => {
+              fileHashesMap.set(fileName, hash);
+              zipFile.readEntry();
+            }, reject)
+          );
+        });
+      })
+      .on("end", (): void => {
+        q.all(hashFilePromises).then(() => resolve(new PackageManifest(fileHashesMap)), reject);
+      });
+  });
+
+  return deferred.promise.finally(() => zipFile && zipFile.close());
+}
+
+export function generatePackageManifestFromDirectory(directoryPath: string, basePath: string): Promise<PackageManifest> {
+  const deferred: q.Deferred<PackageManifest> = q.defer<PackageManifest>();
+  const fileHashesMap = new Map<string, string>();
+
+  recursiveFs.readdirr(directoryPath, (error?: any, directories?: string[], files?: string[]): void => {
+    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: Promise<void> = files.reduce((soFar: Promise<void>, filePath: string) => {
+      return soFar.then(() => {
+        const relativePath: string = PackageManifest.normalizePath(path.relative(basePath, filePath));
+        if (!PackageManifest.isIgnored(relativePath)) {
+          return hashFile(filePath).then((hash: string) => {
+            fileHashesMap.set(relativePath, hash);
+          });
+        }
+      });
+    }, q(<void>null));
+
+    generateManifestPromise
+      .then(() => {
+        deferred.resolve(new PackageManifest(fileHashesMap));
+      }, deferred.reject)
+      .done();
+  });
+
+  return deferred.promise;
+}
+
+export function hashFile(filePath: string): Promise<string> {
+  const readStream: fs.ReadStream = fs.createReadStream(filePath);
+  return hashStream(readStream);
+}
+
+export function hashStream(readStream: stream.Readable): Promise<string> {
+  const hashStream = <stream.Transform>(<any>crypto.createHash(HASH_ALGORITHM));
+  const deferred: q.Deferred<string> = q.defer<string>();
+
+  readStream
+    .on("error", (error: any): void => {
+      if (deferred.promise.isPending()) {
+        hashStream.end();
+        deferred.reject(error);
+      }
+    })
+    .on("end", (): void => {
+      if (deferred.promise.isPending()) {
+        hashStream.end();
+
+        const buffer = <Buffer>hashStream.read();
+        const hash: string = buffer.toString("hex");
+
+        deferred.resolve(hash);
+      }
+    });
+
+  readStream.pipe(hashStream);
+
+  return deferred.promise;
+}
+
+export class PackageManifest {
+  private _map: Map<string, string>;
+
+  public constructor(map?: Map<string, string>) {
+    if (!map) {
+      map = new Map<string, string>();
+    }
+    this._map = map;
+  }
+
+  public toMap(): Map<string, string> {
+    return this._map;
+  }
+
+  public computePackageHash(): Promise<string> {
+    let entries: string[] = [];
+    this._map.forEach((hash: string, name: string): void => {
+      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"));
+  }
+
+  public serialize(): string {
+    const obj: any = {};
+
+    this._map.forEach(function (value, key) {
+      obj[key] = value;
+    });
+
+    return JSON.stringify(obj);
+  }
+
+  public static deserialize(serializedContents: string): PackageManifest {
+    try {
+      const obj: any = JSON.parse(serializedContents);
+      const map = new Map<string, string>();
+
+      for (const key of Object.keys(obj)) {
+        map.set(key, obj[key]);
+      }
+
+      return new PackageManifest(map);
+    } catch (e) {}
+  }
+
+  public static normalizePath(filePath: string): string {
+    return filePath.replace(/\\/g, "/");
+  }
+
+  public static isIgnored(relativeFilePath: string): boolean {
+    const __MACOSX = "__MACOSX/";
+    const DS_STORE = ".DS_Store";
+
+    return startsWith(relativeFilePath, __MACOSX) || relativeFilePath === DS_STORE || endsWith(relativeFilePath, "/" + DS_STORE);
+  }
+}
+
+function startsWith(str: string, prefix: string): boolean {
+  return str && str.substring(0, prefix.length) === prefix;
+}
+
+function endsWith(str: string, suffix: string): boolean {
+  return str && str.indexOf(suffix, str.length - suffix.length) !== -1;
+}

package/script/index.ts

@@ -0,0 +1,5 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import AccountManager = require("./management-sdk");
+export = AccountManager;