@revopush/code-push-cli 0.0.8-rc.0 → 0.0.8-rc.1

package/bin/script/binary-utils.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getIosVersion = exports.extractMetadataFromIOS = exports.extractMetadataFromAndroid = void 0;
+const path = require("path");
+const fs = require("fs");
+const chalk = require("chalk");
+const command_executor_1 = require("./command-executor");
+const hash_utils_1 = require("./hash-utils");
+const os = require("os");
+const Q = require("q");
+const yazl = require("yazl");
+const promises_1 = require("node:fs/promises");
+const plist_1 = require("plist");
+const bplist = require("bplist-parser");
+async function extractMetadataFromAndroid(extractFolder, outputFolder) {
+    const assetsFolder = path.join(extractFolder, "assets");
+    if (!fs.existsSync(assetsFolder)) {
+        throw new Error("Invalid APK structure: assets folder not found.");
+    }
+    const codepushMetadata = path.join(assetsFolder, "CodePushMetadata");
+    let fileHashes = {};
+    if (fs.existsSync(codepushMetadata)) {
+        fileHashes = await takeHashesFromMetadata(codepushMetadata);
+    }
+    else {
+        (0, command_executor_1.log)(chalk.yellow(`\nWarning: CodepushMetadata file not found in APK. Check used version of SDK\n`));
+    }
+    // Get index.android.bundle from root of app folder
+    const mainJsBundlePath = path.join(assetsFolder, "index.android.bundle");
+    if (fs.existsSync(mainJsBundlePath)) {
+        // Copy bundle to output folder
+        const outputCodePushFolder = path.join(outputFolder, "CodePush");
+        fs.mkdirSync(outputCodePushFolder, { recursive: true });
+        const outputBundlePath = path.join(outputCodePushFolder, "index.android.bundle");
+        fs.copyFileSync(mainJsBundlePath, outputBundlePath);
+    }
+    else {
+        throw new Error("index.android.bundle not found in APK root folder.");
+    }
+    // Save packageManifest.json
+    const manifestPath = path.join(outputFolder, "packageManifest.json");
+    fs.writeFileSync(manifestPath, JSON.stringify(fileHashes, null, 2));
+    (0, command_executor_1.log)(chalk.cyan(`\nSaved packageManifest.json with ${Object.keys(fileHashes).length} entries.\n`));
+    // Create zip archive with packageManifest.json and bundle file
+    const zipPath = path.join(os.tmpdir(), `CodePushBinary-${Date.now()}.zip`);
+    await createZipArchive(outputFolder, zipPath, ["packageManifest.json", "CodePush/index.android.bundle"]);
+    return zipPath;
+}
+exports.extractMetadataFromAndroid = extractMetadataFromAndroid;
+async function extractMetadataFromIOS(extractFolder, outputFolder) {
+    const payloadFolder = path.join(extractFolder, "Payload");
+    if (!fs.existsSync(payloadFolder)) {
+        throw new Error("Invalid IPA structure: Payload folder not found.");
+    }
+    const appFolders = fs.readdirSync(payloadFolder).filter((item) => {
+        const itemPath = path.join(payloadFolder, item);
+        return fs.statSync(itemPath).isDirectory() && item.endsWith(".app");
+    });
+    if (appFolders.length === 0) {
+        throw new Error("Invalid IPA structure: No .app folder found in Payload.");
+    }
+    const appFolder = path.join(payloadFolder, appFolders[0]);
+    const codePushFolder = path.join(appFolder, "assets");
+    const fileHashes = {};
+    if (fs.existsSync(codePushFolder)) {
+        await calculateHashesForDirectory(codePushFolder, appFolder, fileHashes);
+    }
+    else {
+        (0, command_executor_1.log)(chalk.yellow(`\nWarning: CodePush folder not found in IPA.\n`));
+    }
+    const mainJsBundlePath = path.join(appFolder, "main.jsbundle");
+    if (fs.existsSync(mainJsBundlePath)) {
+        (0, command_executor_1.log)(chalk.cyan(`\nFound main.jsbundle, calculating hash:\n`));
+        const bundleHash = await (0, hash_utils_1.hashFile)(mainJsBundlePath);
+        fileHashes["CodePush/main.jsbundle"] = bundleHash;
+        // Copy bundle to output folder
+        const outputCodePushFolder = path.join(outputFolder, "CodePush");
+        fs.mkdirSync(outputCodePushFolder, { recursive: true });
+        const outputBundlePath = path.join(outputCodePushFolder, "main.jsbundle");
+        fs.copyFileSync(mainJsBundlePath, outputBundlePath);
+    }
+    else {
+        throw new Error("main.jsbundle not found in IPA root folder.");
+    }
+    // Save packageManifest.json
+    const manifestPath = path.join(outputFolder, "packageManifest.json");
+    fs.writeFileSync(manifestPath, JSON.stringify(fileHashes, null, 2));
+    (0, command_executor_1.log)(chalk.cyan(`\nSaved packageManifest.json with ${Object.keys(fileHashes).length} entries.\n`));
+    // Create zip archive with packageManifest.json and bundle file
+    const zipPath = path.join(os.tmpdir(), `CodePushBinary-${Date.now()}.zip`);
+    await createZipArchive(outputFolder, zipPath, ["packageManifest.json", "CodePush/main.jsbundle"]);
+    return zipPath;
+}
+exports.extractMetadataFromIOS = extractMetadataFromIOS;
+async function calculateHashesForDirectory(directoryPath, basePath, fileHashes) {
+    const items = fs.readdirSync(directoryPath);
+    for (const item of items) {
+        const itemPath = path.join(directoryPath, item);
+        const stat = fs.statSync(itemPath);
+        if (stat.isDirectory()) {
+            await calculateHashesForDirectory(itemPath, basePath, fileHashes);
+        }
+        else {
+            // Calculate relative path from basePath (app folder) to the file
+            const relativePath = path.relative(basePath, itemPath).replace(/\\/g, "/");
+            const hash = await (0, hash_utils_1.hashFile)(itemPath);
+            const hashKey = `CodePush/${relativePath}`;
+            fileHashes[hashKey] = hash;
+            (0, command_executor_1.log)(chalk.gray(`  ${relativePath}:${hash.substring(0, 8)}...\n`));
+        }
+    }
+}
+async function takeHashesFromMetadata(metadataPath) {
+    const content = await (0, promises_1.readFile)(metadataPath, "utf-8");
+    const metadata = JSON.parse(content);
+    if (!metadata || !metadata.manifest) {
+        throw new Error("Failed to take manifest from metadata file of APK");
+    }
+    return Object.fromEntries(metadata.manifest.map((item) => item.split(":")));
+}
+function createZipArchive(sourceFolder, zipPath, filesToInclude) {
+    return Q.Promise((resolve, reject) => {
+        const zipFile = new yazl.ZipFile();
+        const writeStream = fs.createWriteStream(zipPath);
+        zipFile.outputStream
+            .pipe(writeStream)
+            .on("error", (error) => {
+            reject(error);
+        })
+            .on("close", () => {
+            resolve();
+        });
+        for (const file of filesToInclude) {
+            const filePath = path.join(sourceFolder, file);
+            if (fs.existsSync(filePath)) {
+                zipFile.addFile(filePath, file);
+            }
+        }
+        zipFile.end();
+    });
+}
+function parseAnyPlistFile(plistPath) {
+    const buf = fs.readFileSync(plistPath);
+    if (buf.slice(0, 6).toString("ascii") === "bplist") {
+        const arr = bplist.parseBuffer(buf);
+        if (!arr?.length)
+            throw new Error("Empty binary plist");
+        return arr[0];
+    }
+    const xml = buf.toString("utf8");
+    return plist_1.default.parse(xml);
+}
+async function getIosVersion(extractFolder) {
+    const payloadFolder = path.join(extractFolder, "Payload");
+    if (!fs.existsSync(payloadFolder)) {
+        throw new Error("Invalid IPA structure: Payload folder not found.");
+    }
+    const appFolders = fs.readdirSync(payloadFolder).filter((item) => {
+        const itemPath = path.join(payloadFolder, item);
+        return fs.statSync(itemPath).isDirectory() && item.endsWith(".app");
+    });
+    if (appFolders.length === 0) {
+        throw new Error("Invalid IPA structure: No .app folder found in Payload.");
+    }
+    const appFolder = path.join(payloadFolder, appFolders[0]);
+    const plistPath = path.join(appFolder, "Info.plist");
+    const data = parseAnyPlistFile(plistPath);
+    console.log('App Version (Short):', data.CFBundleShortVersionString);
+    console.log('Build Number:', data.CFBundleVersion);
+    console.log('Bundle ID:', data.CFBundleIdentifier);
+    return {
+        version: data.CFBundleShortVersionString,
+        build: data.CFBundleVersion
+    };
+}
+exports.getIosVersion = getIosVersion;

package/bin/script/command-executor.js

@@ -2,7 +2,8 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.runReactNativeBundleCommand = exports.releaseReact = exports.release = exports.execute = exports.deploymentList = exports.createEmptyTempReleaseFolder = exports.confirm = exports.execSync = exports.spawn = exports.sdk = exports.log = void 0;
+exports.runReactNativeBundleCommand = exports.releaseNative = exports.releaseReact = exports.releaseExpo = exports.runExpoExportEmbedCommand = exports.release = exports.execute = exports.deploymentList = exports.createEmptyTempReleaseFolder = exports.confirm = exports.execSync = exports.spawn = exports.sdk = exports.log = void 0;
+const binary_utils_1 = require("./binary-utils");
 const childProcess = require("child_process");
 const debug_1 = require("./commands/debug");
 const fs = require("fs");
@@ -14,11 +15,13 @@ const Q = require("q");
 const semver = require("semver");
 const cli = require("../script/types/cli");
 const sign_1 = require("./sign");
+const ApkReader = require("@devicefarmer/adbkit-apkreader");
 const react_native_utils_1 = require("./react-native-utils");
 const file_utils_1 = require("./utils/file-utils");
 const AccountManager = require("./management-sdk");
 const wordwrap = require("wordwrap");
 var Promise = Q.Promise;
+const expo_utils_1 = require("./expo-utils");
 const g2js = require("gradle-to-js/lib/parser");
 const opener = require("opener");
 const plist = require("plist");
@@ -413,6 +416,10 @@ function execute(command) {
                 return (0, exports.release)(command);
             case cli.CommandType.releaseReact:
                 return (0, exports.releaseReact)(command);
+            case cli.CommandType.releaseExpo:
+                return (0, exports.releaseExpo)(command);
+            case cli.CommandType.releaseNative:
+                return (0, exports.releaseNative)(command);
             case cli.CommandType.rollback:
                 return rollback(command);
             case cli.CommandType.sessionList:
@@ -985,6 +992,173 @@ const release = (command) => {
     return doRelease(command, updateMetadata);
 };
 exports.release = release;
+const runExpoExportEmbedCommand = async (command, bundleName, development, 
+// entryFile: string,
+outputFolder, sourcemapOutputFolder, platform, extraBundlerOptions) => {
+    const expoBundleArgs = [];
+    const envNodeArgs = process.env.CODE_PUSH_NODE_ARGS;
+    if (typeof envNodeArgs !== "undefined") {
+        Array.prototype.push.apply(expoBundleArgs, envNodeArgs.trim().split(/\s+/));
+    }
+    const expoCliPath = (0, expo_utils_1.getExpoCliPath)();
+    Array.prototype.push.apply(expoBundleArgs, [
+        expoCliPath,
+        "export:embed",
+        "--assets-dest",
+        outputFolder,
+        "--bundle-output",
+        path.join(outputFolder, bundleName),
+        "--dev",
+        development,
+        "--platform",
+        platform,
+        "--minify",
+        false,
+        "--reset-cache",
+    ]);
+    if (sourcemapOutputFolder) {
+        let bundleSourceMapOutput = sourcemapOutputFolder;
+        if (!sourcemapOutputFolder.endsWith(".map")) {
+            // user defined directory, нужно вычислить полный путь
+            bundleSourceMapOutput = await (0, react_native_utils_1.getBundleSourceMapOutput)(command, bundleName, sourcemapOutputFolder);
+        }
+        expoBundleArgs.push("--sourcemap-output", bundleSourceMapOutput);
+    }
+    // const minifyValue = await getMinifyParams(command);
+    // Array.prototype.push.apply(expoBundleArgs, minifyValue);
+    if (extraBundlerOptions.length > 0) {
+        expoBundleArgs.push(...extraBundlerOptions);
+    }
+    (0, exports.log)(chalk.cyan('Running "expo export:embed" command:\n'));
+    const projectRoot = process.cwd();
+    expoBundleArgs.push(projectRoot);
+    (0, exports.log)("expoBundleArgs raw:" + JSON.stringify(expoBundleArgs, null, 2));
+    const expoBundleProcess = (0, exports.spawn)("node", expoBundleArgs);
+    (0, exports.log)(`node ${expoBundleArgs.join(" ")}`);
+    return Promise((resolve, reject, notify) => {
+        expoBundleProcess.stdout.on("data", (data) => {
+            (0, exports.log)(data.toString().trim());
+        });
+        expoBundleProcess.stderr.on("data", (data) => {
+            console.error(data.toString().trim());
+        });
+        expoBundleProcess.on("close", (exitCode) => {
+            if (exitCode) {
+                reject(new Error(`"expo export:embed" command exited with code ${exitCode}.`));
+            }
+            resolve(null);
+        });
+    });
+};
+exports.runExpoExportEmbedCommand = runExpoExportEmbedCommand;
+const releaseExpo = (command) => {
+    let bundleName = command.bundleName;
+    // let entryFile: string = command.entryFile;
+    const outputFolder = command.outputDir || path.join(os.tmpdir(), "CodePush");
+    const sourcemapOutputFolder = command.sourcemapOutput || path.join(os.tmpdir(), "CodePushSourceMap");
+    const baseReleaseTmpFolder = path.join(os.tmpdir(), "CodePushBaseRelease");
+    const platform = (command.platform = command.platform.toLowerCase());
+    const releaseCommand = command;
+    return exports.sdk
+        .getDeployment(command.appName, command.deploymentName)
+        .then(async () => {
+        switch (platform) {
+            case "android":
+            case "ios":
+                if (!bundleName) {
+                    bundleName = platform === "ios" ? "main.jsbundle" : `index.${platform}.bundle`;
+                }
+                break;
+            default:
+                throw new Error('Platform must be either "android" or "ios" for the "release-expo" command.');
+        }
+        releaseCommand.package = outputFolder;
+        releaseCommand.outputDir = outputFolder;
+        releaseCommand.bundleName = bundleName;
+        let projectName;
+        try {
+            const projectPackageJson = require(path.join(process.cwd(), "package.json"));
+            projectName = projectPackageJson.name;
+            if (!projectName) {
+                throw new Error('The "package.json" file in the CWD does not have the "name" field set.');
+            }
+            if (!projectPackageJson.dependencies["react-native"]) {
+                throw new Error("The project in the CWD is not a React Native project.");
+            }
+        }
+        catch (error) {
+            throw new Error('Unable to find or read "package.json" in the CWD. The "release-expo" command must be executed in a React Native project folder.');
+        }
+        // TODO: do we really need entryFile for expo?
+        // if (!entryFile) {
+        //   entryFile = `index.${platform}.js`;
+        //   if (fileDoesNotExistOrIsDirectory(entryFile)) {
+        //     entryFile = "index.js";
+        //   }
+        //
+        //   if (fileDoesNotExistOrIsDirectory(entryFile)) {
+        //     throw new Error(`Entry file "index.${platform}.js" or "index.js" does not exist.`);
+        //   }
+        // } else {
+        //   if (fileDoesNotExistOrIsDirectory(entryFile)) {
+        //     throw new Error(`Entry file "${entryFile}" does not exist.`);
+        //   }
+        // }
+        const appVersionPromise = command.appStoreVersion
+            ? Q(command.appStoreVersion)
+            : getReactNativeProjectAppVersion(command, projectName);
+        if (!sourcemapOutputFolder.endsWith(".map") && !command.sourcemapOutput) {
+            await (0, exports.createEmptyTempReleaseFolder)(sourcemapOutputFolder);
+        }
+        return appVersionPromise;
+    })
+        .then((appVersion) => {
+        throwForInvalidSemverRange(appVersion);
+        releaseCommand.appStoreVersion = appVersion;
+        return (0, exports.createEmptyTempReleaseFolder)(outputFolder);
+    })
+        .then(() => deleteFolder(`${os.tmpdir()}/react-*`))
+        .then(async () => {
+        await (0, exports.runExpoExportEmbedCommand)(command, bundleName, command.development || false, 
+        // entryFile,
+        outputFolder, sourcemapOutputFolder, platform, command.extraBundlerOptions);
+    })
+        .then(async () => {
+        const isHermes = await (0, react_native_utils_1.isHermesEnabled)(command, platform);
+        if (isHermes) {
+            await (0, exports.createEmptyTempReleaseFolder)(baseReleaseTmpFolder);
+            const baseBytecode = await (0, react_native_utils_1.takeHermesBaseBytecode)(command, baseReleaseTmpFolder, outputFolder, bundleName);
+            (0, exports.log)(chalk.cyan("\nRunning hermes compiler.\n"));
+            await (0, react_native_utils_1.runHermesEmitBinaryCommand)(command, bundleName, outputFolder, sourcemapOutputFolder, command.extraHermesFlags, command.gradleFile, baseBytecode);
+        }
+    })
+        .then(async () => {
+        if (command.privateKeyPath) {
+            (0, exports.log)(chalk.cyan("\nSigning the bundle:\n"));
+            await (0, sign_1.default)(command.privateKeyPath, outputFolder);
+        }
+        else {
+            console.log("private key was not provided");
+        }
+    })
+        .then(() => {
+        (0, exports.log)(chalk.cyan("\nReleasing update contents to CodePush:\n"));
+        return releaseReactNative(releaseCommand);
+    })
+        .then(async () => {
+        if (!command.outputDir) {
+            await deleteFolder(outputFolder);
+        }
+        if (!command.sourcemapOutput) {
+            await deleteFolder(sourcemapOutputFolder);
+        }
+        await deleteFolder(baseReleaseTmpFolder);
+    })
+        .catch(async (err) => {
+        throw err;
+    });
+};
+exports.releaseExpo = releaseExpo;
 const releaseReact = (command) => {
     let bundleName = command.bundleName;
     let entryFile = command.entryFile;
@@ -1026,6 +1200,7 @@ const releaseReact = (command) => {
         catch (error) {
             throw new Error('Unable to find or read "package.json" in the CWD. The "release-react" command must be executed in a React Native project folder.');
         }
+        // TODO: check entry file detection
         if (!entryFile) {
             entryFile = `index.${platform}.js`;
             if ((0, file_utils_1.fileDoesNotExistOrIsDirectory)(entryFile)) {
@@ -1096,6 +1271,90 @@ const releaseReact = (command) => {
     }));
 };
 exports.releaseReact = releaseReact;
+const releaseNative = (command) => {
+    const platform = command.platform.toLowerCase();
+    let bundleName = command.bundleName;
+    const targetBinaryPath = command.targetBinary;
+    const outputFolder = command.outputDir || path.join(os.tmpdir(), "CodePush");
+    const extractFolder = path.join(os.tmpdir(), "CodePushBinaryExtract");
+    // Validate platform
+    if (platform !== "ios" && platform !== "android") {
+        throw new Error('Platform must be either "ios" or "android" for the "release-native" command.');
+    }
+    // Validate target binary file exists
+    if (!(0, file_utils_1.fileExists)(targetBinaryPath)) {
+        throw new Error(`Target binary file "${targetBinaryPath}" does not exist.`);
+    }
+    // Validate file extension matches platform
+    if (platform === "ios" && !targetBinaryPath.toLowerCase().endsWith(".ipa")) {
+        throw new Error("For iOS platform, target binary must be an .ipa file.");
+    }
+    if (platform === "android" && !targetBinaryPath.toLowerCase().endsWith(".apk")) {
+        throw new Error("For Android platform, target binary must be an .apk file.");
+    }
+    return exports.sdk
+        .getDeployment(command.appName, command.deploymentName)
+        .then(async () => {
+        try {
+            await (0, exports.createEmptyTempReleaseFolder)(outputFolder);
+            await (0, exports.createEmptyTempReleaseFolder)(extractFolder);
+            if (!bundleName) {
+                bundleName = platform === "ios" ? "main.jsbundle" : `index.android.bundle`;
+            }
+            let releaseCommandPartial;
+            if (platform === "ios") {
+                (0, exports.log)(chalk.cyan(`\nExtracting IPA file:\n`));
+                await (0, file_utils_1.extractIPA)(targetBinaryPath, extractFolder);
+                const metadataZip = await (0, binary_utils_1.extractMetadataFromIOS)(extractFolder, outputFolder);
+                const buildVersion = await (0, binary_utils_1.getIosVersion)(extractFolder);
+                releaseCommandPartial = { package: metadataZip, appStoreVersion: buildVersion?.version };
+            }
+            else {
+                (0, exports.log)(chalk.cyan(`\nExtracting APK/ARR file:\n`));
+                await (0, file_utils_1.extractAPK)(targetBinaryPath, extractFolder);
+                const reader = await ApkReader.open(targetBinaryPath);
+                const { versionName: appStoreVersion } = await reader.readManifest();
+                const metadataZip = await (0, binary_utils_1.extractMetadataFromAndroid)(extractFolder, outputFolder);
+                releaseCommandPartial = { package: metadataZip, appStoreVersion };
+            }
+            const { package: metadataZip, appStoreVersion } = releaseCommandPartial;
+            // Use the zip file as package for release
+            const releaseCommand = {
+                type: cli.CommandType.release,
+                appName: command.appName,
+                deploymentName: command.deploymentName,
+                appStoreVersion: command.appStoreVersion || appStoreVersion,
+                description: command.description,
+                disabled: command.disabled,
+                mandatory: command.mandatory,
+                rollout: command.rollout,
+                initial: command.initial,
+                noDuplicateReleaseError: command.noDuplicateReleaseError,
+                platform: platform,
+                outputDir: outputFolder,
+                bundleName: bundleName,
+                package: metadataZip,
+            };
+            return doNativeRelease(releaseCommand).then(async () => {
+                // Clean up zip file
+                if (fs.existsSync(releaseCommandPartial.package)) {
+                    fs.unlinkSync(releaseCommandPartial.package);
+                }
+            });
+        }
+        finally {
+            try {
+                await deleteFolder(extractFolder);
+                await deleteFolder(outputFolder);
+            }
+            catch (ignored) { }
+        }
+    })
+        .catch(async (err) => {
+        throw err;
+    });
+};
+exports.releaseNative = releaseNative;
 const releaseReactNative = (command) => {
     // for initial release we explicitly define release as optional, disabled, without rollout, with a special description
     const updateMetadata = {
@@ -1134,6 +1393,8 @@ const doRelease = (command, updateMetadata) => {
     return exports.sdk
         .isAuthenticated(true)
         .then((isAuth) => {
+        (0, exports.log)("Release file path: " + filePath);
+        (0, exports.log)("Metadata: " + JSON.stringify(updateMetadata));
         return exports.sdk.release(command.appName, command.deploymentName, filePath, updateMetadata, uploadProgress);
     })
         .then(() => {
@@ -1149,6 +1410,48 @@ const doRelease = (command, updateMetadata) => {
     })
         .catch((err) => releaseErrorHandler(err, command));
 };
+const doNativeRelease = (releaseCommand) => {
+    throwForInvalidSemverRange(releaseCommand.appStoreVersion);
+    const filePath = releaseCommand.package;
+    const updateMetadata = {
+        description: releaseCommand.initial ? `Zero release for v${releaseCommand.appStoreVersion}` : releaseCommand.description,
+        isDisabled: releaseCommand.initial ? true : releaseCommand.disabled,
+        isMandatory: releaseCommand.initial ? false : releaseCommand.mandatory,
+        isInitial: releaseCommand.initial,
+        bundleName: releaseCommand.bundleName,
+        outputDir: releaseCommand.outputDir,
+        rollout: releaseCommand.initial ? undefined : releaseCommand.rollout,
+        appVersion: releaseCommand.appStoreVersion,
+    };
+    let lastTotalProgress = 0;
+    const progressBar = new progress("Upload progress:[:bar] :percent :etas", {
+        complete: "=",
+        incomplete: " ",
+        width: 50,
+        total: 100,
+    });
+    const uploadProgress = (currentProgress) => {
+        progressBar.tick(currentProgress - lastTotalProgress);
+        lastTotalProgress = currentProgress;
+    };
+    return exports.sdk
+        .isAuthenticated(true)
+        .then(() => {
+        return exports.sdk.releaseNative(releaseCommand.appName, releaseCommand.deploymentName, filePath, updateMetadata, uploadProgress);
+    })
+        .then(() => {
+        (0, exports.log)('Successfully released an update containing the "' +
+            releaseCommand.package +
+            '" ' +
+            "directory" +
+            ' to the "' +
+            releaseCommand.deploymentName +
+            '" deployment of the "' +
+            releaseCommand.appName +
+            '" app.');
+    })
+        .catch((err) => releaseErrorHandler(err, releaseCommand));
+};
 function rollback(command) {
     return (0, exports.confirm)().then((wasConfirmed) => {
         if (!wasConfirmed) {
@@ -1247,7 +1550,7 @@ function serializeConnectionInfo(accessKey, preserveAccessKeyOnLogout, customSer
     }
     const json = JSON.stringify(connectionInfo);
     fs.writeFileSync(configFilePath, json, { encoding: "utf8" });
-    (0, exports.log)(`\r\nSuccessfully logged-in. Your session file was written to ${chalk.cyan(configFilePath)}. You can run the ${chalk.cyan("code-push logout")} command at any time to delete this file and terminate your session.\r\n`);
+    (0, exports.log)(`\r\nSuccessfully logged-in. Your session file was written to ${chalk.cyan(configFilePath)}. You can run the ${chalk.cyan("revopush logout")} command at any time to delete this file and terminate your session.\r\n`);
 }
 function sessionList(command) {
     throwForInvalidOutputFormat(command.format);