cloudron 4.12.10 → 4.14.0

package/src/actions.js

@@ -1,8 +1,8 @@
 'use strict';
 
 const assert = require('assert'),
-    async = require('async'),
     config = require('./config.js'),
+    delay = require('delay'),
     ejs = require('ejs'),
     EventSource = require('eventsource'),
     fs = require('fs'),
@@ -16,19 +16,15 @@ const assert = require('assert'),
     ProgressStream = require('progress-stream'),
     querystring = require('querystring'),
     readlineSync = require('readline-sync'),
-    request = require('request'),
     safe = require('safetydance'),
     spawn = require('child_process').spawn,
     split = require('split'),
     superagent = require('superagent'),
     Table = require('easy-table'),
     tar = require('tar-fs'),
-    util = require('util'),
     zlib = require('zlib'),
     _ = require('underscore');
 
-require('colors');
-
 const exit = helper.exit;
 
 exports = module.exports = {
@@ -51,7 +47,6 @@ exports = module.exports = {
     start,
     stop,
     repair,
-    createOAuthAppCredentials,
     init,
     restore,
     importApp,
@@ -80,6 +75,18 @@ function requestOptions(options) {
     return { adminFqdn, token, rejectUnauthorized };
 }
 
+function createRequest(method, apiPath, options) {
+    const { adminFqdn, token, rejectUnauthorized } = requestOptions(options);
+
+    let url = `https://${adminFqdn}${apiPath}`;
+    if (url.includes('?')) url += '&'; else url += '?';
+    url += `access_token=${token}`;
+    const request = superagent(method, url);
+    if (rejectUnauthorized) request.disableTLSCerts();
+    request.ok(() => true);
+    return request;
+}
+
 // error for the request module
 function requestError(response) {
     if (response.statusCode === 401) return 'Invalid token. Use cloudron login again.';
@@ -87,166 +94,231 @@ function requestError(response) {
     return `${response.statusCode} message: ${response.body.message || response.body}`; // body is sometimes just a string like in 401
 }
 
-function selectDomain(location, options, callback) {
+async function selectDomain(location, options) {
     assert.strictEqual(typeof location, 'string');
     assert.strictEqual(typeof options, 'object');
-    assert.strictEqual(typeof callback, 'function');
 
-    const { adminFqdn, token, rejectUnauthorized } = requestOptions(options);
+    const { adminFqdn } = requestOptions(options);
 
-    request.get(`https://${adminFqdn}/api/v1/domains?access_token=${token}`, { rejectUnauthorized, json: true }, function (error, response) {
-        if (error) return callback(error);
-        if (response.statusCode !== 200) return callback(new Error(`Failed to list domains: ${requestError(response)}`));
+    const response = await createRequest('GET', '/api/v1/domains', options);
+    if (response.statusCode !== 200) throw new Error(`Failed to list domains: ${requestError(response)}`);
 
-        const domains = response.body.domains;
+    const domains = response.body.domains;
 
-        let domain;
-        let matchingDomain = domains
+    let domain;
+    let subdomain = location;
+    let matchingDomain = domains
+        .map(function (d) { return d.domain; } )
+        .sort(function(a, b) { return a.length < b.length; })
+        .find(function (d) { return location.endsWith(d); });
+
+    if (matchingDomain) {
+        domain = matchingDomain;
+        subdomain = location.slice(0, -matchingDomain.length-1);
+    } else { // use the admin domain
+        domain = domains
             .map(function (d) { return d.domain; } )
             .sort(function(a, b) { return a.length < b.length; })
-            .find(function (d) { return location.endsWith(d); });
-
-        if (matchingDomain) {
-            domain = matchingDomain;
-            location = location.slice(0, -matchingDomain.length-1);
-        } else { // use the admin domain
-            domain = domains
-                .map(function (d) { return d.domain; } )
-                .sort(function(a, b) { return a.length < b.length; })
-                .find(function (d) { return adminFqdn.endsWith(d); });
-        }
+            .find(function (d) { return adminFqdn.endsWith(d); });
+    }
 
-        callback(null, { location, domain });
-    });
+    return { subdomain, domain };
 }
 
-function stopActiveTask(app, options, callback) {
+async function stopActiveTask(app, options) {
     assert.strictEqual(typeof app, 'object');
     assert.strictEqual(typeof options, 'object');
-    assert.strictEqual(typeof callback, 'function');
 
-    if (!app.taskId) return callback();
+    if (!app.taskId) return;
 
     console.log(`Stopping app's current active task ${app.taskId}`);
 
-    const { adminFqdn, token, rejectUnauthorized } = requestOptions(options);
-
-    request.post(`https://${adminFqdn}/api/v1/tasks/${app.taskId}/stop?access_token=${token}`, { json: {}, rejectUnauthorized }, function (error, response) {
-        if (error) return callback(error);
-        if (response.statusCode !== 204) return exit(`Failed to stop active task: ${requestError(response)}`);
-
-        callback();
-    });
+    const response = await createRequest('POST', `/api/v1/tasks/${app.taskId}/stop`, options);
+    if (response.statusCode !== 204) throw `Failed to stop active task: ${requestError(response)}`;
 }
 
-function selectAppWithRepository(repository, options, callback) {
+async function selectAppWithRepository(repository, options) {
     assert.strictEqual(typeof repository, 'string');
     assert.strictEqual(typeof options, 'object');
-    assert.strictEqual(typeof callback, 'function');
-
-    const { adminFqdn, token, rejectUnauthorized } = requestOptions(options);
 
-    request.get(`https://${adminFqdn}/api/v1/apps?access_token=${token}`, { rejectUnauthorized, json: true }, function (error, response) {
-        if (error) return callback(error);
-        if (response.statusCode !== 200) return callback(new Error(`Failed to install app: ${requestError(response)}`));
+    const response = await createRequest('GET', '/api/v1/apps', options);
+    if (response.statusCode !== 200) throw new Error(`Failed to install app: ${requestError(response)}`);
 
-        let matchingApps = response.body.apps.filter(function (app) {
-            return !app.appStoreId && app.manifest.dockerImage.startsWith(repository); // never select apps from the store
-        });
+    let matchingApps = response.body.apps.filter(function (app) {
+        return !app.appStoreId && app.manifest.dockerImage.startsWith(repository); // never select apps from the store
+    });
 
-        if (matchingApps.length === 0) return callback(null, [ ]);
-        if (matchingApps.length === 1) return callback(null, matchingApps[0]);
+    if (matchingApps.length === 0) return [ ];
+    if (matchingApps.length === 1) return matchingApps[0];
 
-        console.log();
-        console.log('Available apps using same repository %s:', repository);
-        matchingApps.sort(function (a, b) { return a.fqdn < b.fqdn ? -1 : 1; });
-        matchingApps.forEach(function (app, index) {
-            console.log('[%s]\t%s', index, app.fqdn);
-        });
+    console.log();
+    console.log('Available apps using same repository %s:', repository);
+    matchingApps.sort(function (a, b) { return a.fqdn < b.fqdn ? -1 : 1; });
+    matchingApps.forEach(function (app, index) {
+        console.log('[%s]\t%s', index, app.fqdn);
+    });
 
-        var index = -1;
-        // eslint-disable-next-line no-constant-condition
-        while (true) {
-            index = parseInt(readlineSync.question('Choose app [0-' + (matchingApps.length-1) + ']: ', {}), 10);
-            if (isNaN(index) || index < 0 || index > matchingApps.length-1) console.log('Invalid selection'.red);
-            else break;
-        }
+    let index = -1;
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        index = parseInt(readlineSync.question('Choose app [0-' + (matchingApps.length-1) + ']: ', {}), 10);
+        if (isNaN(index) || index < 0 || index > matchingApps.length-1) console.log('Invalid selection');
+        else break;
+    }
 
-        callback(null, matchingApps[index]);
-    });
+    return matchingApps[index];
 }
 
 // appId may be the appId or the location
-function getApp(options, callback) {
+async function getApp(options) {
     assert.strictEqual(typeof options, 'object');
-    assert.strictEqual(typeof callback, 'function');
 
     const app = options.app || null;
-    const { adminFqdn, token, rejectUnauthorized } = requestOptions(options);
 
     if (!app) { // determine based on repository name given during 'build'
         const manifestFilePath = helper.locateManifest();
 
-        if (!manifestFilePath) return callback(new Error(NO_APP_FOUND_ERROR_STRING));
+        if (!manifestFilePath) throw new Error(NO_APP_FOUND_ERROR_STRING);
 
         const sourceDir = path.dirname(manifestFilePath);
         const appConfig = config.getAppConfig(sourceDir);
 
-        if (!appConfig.repository) return callback(new Error(NO_APP_FOUND_ERROR_STRING));
+        if (!appConfig.repository) throw new Error(NO_APP_FOUND_ERROR_STRING);
 
-        selectAppWithRepository(appConfig.repository, options, function (error, result) {
-            if (error || result.length === 0) return callback(null, null);
+        const [error, result] = await safe(selectAppWithRepository(appConfig.repository, options));
+        if (error || result.length === 0) return null;
 
-            callback(null, result);
-        });
+        return result;
     } else if (app.match(/.{8}-.{4}-.{4}-.{4}-.{8}/)) {  // it is an id
-        request.get(`https://${adminFqdn}/api/v1/apps/${app}?access_token=${token}`, { rejectUnauthorized, json: true }, function (error, response) {
-            if (error) return callback(error);
-            if (response.statusCode !== 200) return callback(new Error(`Failed to get app: ${requestError(response)}`));
+        const response = await createRequest('GET', `/api/v1/apps/${app}`, options);
+        if (response.statusCode !== 200) throw new Error(`Failed to get app: ${requestError(response)}`);
 
-            callback(null, response.body);
-        });
+        return response.body;
     } else { // it is a location
-        request.get(`https://${adminFqdn}/api/v1/apps?access_token=${token}`, { rejectUnauthorized, json: true }, function (error, response) {
-            if (error) return callback(error);
-            if (response.statusCode !== 200) return callback(new Error(`Failed to get apps: ${requestError(response)}`));
+        const response = await createRequest('GET', '/api/v1/apps', options);
+        if (response.statusCode !== 200) throw new Error(`Failed to get apps: ${requestError(response)}`);
 
-            let match = response.body.apps.filter(function (m) { return m.location === app || m.fqdn === app; });
-            if (match.length == 0) return callback(new Error(`App at location ${app} not found`));
+        const match = response.body.apps.filter(function (m) { return m.subdomain === app || m.location === app || m.fqdn === app; });
+        if (match.length == 0) throw new Error(`App at location ${app} not found`);
 
-            callback(null, match[0]);
-        });
+        return match[0];
     }
 }
 
-function stopApp(app, options, callback) {
-    assert.strictEqual(typeof app, 'object');
+async function waitForHealthy(appId, options) {
+    assert.strictEqual(typeof appId, 'string');
     assert.strictEqual(typeof options, 'object');
-    assert.strictEqual(typeof callback, 'function');
 
-    const { adminFqdn, token, rejectUnauthorized } = requestOptions(options);
+    if (!options.wait) return;
 
-    request.post(`https://${adminFqdn}/api/v1/apps/${app.id}/stop?access_token=${token}`, { json: {}, rejectUnauthorized }, function (error, response) {
-        if (error) return callback(error);
-        if (response.statusCode !== 202) return callback(`Failed to stop app: ${requestError(response)}`);
+    process.stdout.write('\n => ' + 'Wait for health check ');
 
-        waitForTask(response.body.taskId, options, callback);
-    });
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        await delay(1000);
+        const response = await createRequest('GET', `/api/v1/apps/${appId}`, options);
+        if (response.statusCode !== 200) throw new Error(`Failed to get app: ${requestError(response)}`);
+
+        // do not check installation state here. it can be pending_backup etc (this is a bug in box code)
+        if (response.body.health === 'healthy') return;
+
+        // skip health check if app is in debug mode
+        if (response.body.debugMode !== null) {
+            process.stdout.write(' (skipped in debug mode)');
+            return;
+        }
+
+        process.stdout.write('.');
+    }
+}
+
+async function waitForTask(taskId, options) {
+    assert.strictEqual(typeof taskId, 'string');
+    assert.strictEqual(typeof options, 'object');
+
+    let currentMessage = '';
+
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const response = await createRequest('GET', `/api/v1/tasks/${taskId}`, options);
+        if (response.statusCode !== 200) throw new Error(`Failed to get task: ${requestError(response)}`);
+
+        // TODO remove later, for now keep old behavior on if `pending` is missing
+        if (typeof response.body.pending === 'undefined') {
+            // note: for queued tasks, 'active' returns false
+            if (response.body.error || response.body.percent === 100) return response.body; // task errored or done
+        } else {
+            if (!response.body.pending && !response.body.active) return response.body;
+        }
+
+        let message = response.body.message || '';
+
+        // Backup downloading includes the filename and clutters the cli output
+        if (message.indexOf('Restore - Down') === 0) {
+            message = 'Downloading backup';
+        }
+
+        // track current progress and show progress dots
+        if (currentMessage && currentMessage === message) {
+            if (currentMessage.indexOf('Creating image') === -1 && currentMessage.indexOf('Downloading backup') === -1) process.stdout.write('.');
+        } else if (message) {
+            process.stdout.write('\n => ' + message.trim() + ' ');
+        } else {
+            process.stdout.write('\n => ' + 'Waiting to start installation ');
+        }
+
+        currentMessage = message;
+
+        await delay(1000);
+    }
 }
 
-function startApp(app, options, callback) {
+async function waitForFinishInstallation(appId, taskId, options) {
+    assert.strictEqual(typeof appId, 'string');
+    assert.strictEqual(typeof taskId, 'string');
+    assert.strictEqual(typeof options, 'object');
+
+    await waitForTask(taskId, options);
+
+    const response = await createRequest('GET', `/api/v1/apps/${appId}`, options);
+    if (response.statusCode !== 200) throw new Error(`Failed to get app: ${requestError(response)}`);
+
+    if (response.body.installationState !== 'installed') throw new Error(`Installation failed: ${response.body.error ? response.body.error.message : ''}`);
+
+    await waitForHealthy(appId, options);
+}
+
+async function waitForFinishBackup(appId, taskId, options) {
+    assert.strictEqual(typeof appId, 'string');
+    assert.strictEqual(typeof taskId, 'string');
+    assert.strictEqual(typeof options, 'object');
+
+    const result  = await waitForTask(taskId, options);
+
+    if (result.error) throw new Error(`Backup failed: ${result.error.message}`);
+
+    const response = await createRequest('GET', `/api/v1/apps/${appId}`, options);
+    if (response.statusCode !== 200) throw new Error(`Failed to get app: ${requestError(response)}`);
+}
+
+async function stopApp(app, options) {
     assert.strictEqual(typeof app, 'object');
     assert.strictEqual(typeof options, 'object');
-    assert.strictEqual(typeof callback, 'function');
 
-    const { adminFqdn, token, rejectUnauthorized } = requestOptions(options);
+    const response = await createRequest('POST', `/api/v1/apps/${app.id}/stop`, options);
+    if (response.statusCode !== 202) throw `Failed to stop app: ${requestError(response)}`;
 
-    request.post(`https://${adminFqdn}/api/v1/apps/${app.id}/start?access_token=${token}`, { json: {}, rejectUnauthorized }, function (error, response) {
-        if (error) return callback(error);
-        if (response.statusCode !== 202) return callback(`Failed to stop app: ${requestError(response)}`);
+    await waitForTask(response.body.taskId, options);
+}
 
-        waitForTask(response.body.taskId, options, callback);
-    });
+async function startApp(app, options) {
+    assert.strictEqual(typeof app, 'object');
+    assert.strictEqual(typeof options, 'object');
+
+    const response = await createRequest('POST', `/api/v1/apps/${app.id}/start`, options);
+    if (response.statusCode !== 202) throw `Failed to start app: ${requestError(response)}`;
+
+    await waitForTask(response.body.taskId, options);
 }
 
 async function authenticate(adminFqdn, username, password, options) {
@@ -271,7 +343,7 @@ async function authenticate(adminFqdn, username, password, options) {
         if (response.body.message === 'A totpToken must be provided') {
             return await authenticate(adminFqdn, username, password, { rejectUnauthorized, askForTotpToken: true });
         } else if (response.body.message === 'Invalid totpToken') {
-            console.log('Invalid 2FA Token'.red);
+            console.log('Invalid 2FA Token');
             return await authenticate(adminFqdn, username, password, { rejectUnauthorized, askForTotpToken: true });
         } else {
             throw new Error('Invalid credentials');
@@ -299,10 +371,10 @@ async function login(adminFqdn, options) {
             .ok(() => true));
         if (error) return exit(error);
         if (response.status === 200) {
-            console.log('Existing token still valid.'.green);
+            console.log('Existing token still valid.');
         } else {
             token = null;
-            console.log(`Existing token possibly expired: ${requestError(response)}`.red);
+            console.log(`Existing token possibly expired: ${requestError(response)}`);
         }
     }
 
@@ -322,7 +394,7 @@ async function login(adminFqdn, options) {
     config.setAllowSelfsigned(options.parent.allowSelfsigned || options.parent.acceptSelfsigned);
     config.set('cloudrons.default', adminFqdn);
 
-    console.log('Login successful.'.green);
+    console.log('Login successful.');
 }
 
 function logout() {
@@ -332,187 +404,70 @@ function logout() {
     console.log('Logged out.');
 }
 
-function open(options) {
-    getApp(options, function (error, app) {
-        if (error) return exit(error);
+async function open(options) {
+    const [error, app] = await safe(getApp(options));
+    if (error) return exit(error);
 
-        if (!app) return exit(NO_APP_FOUND_ERROR_STRING);
+    if (!app) return exit(NO_APP_FOUND_ERROR_STRING);
 
-        opn(`https://${app.fqdn}`);
-    });
+    opn(`https://${app.fqdn}`);
 }
 
-function list(options) {
+async function list(options) {
     helper.verifyArguments(arguments);
 
-    const { adminFqdn, token, rejectUnauthorized } = requestOptions(options);
+    const [error, response] = await safe(createRequest('GET', '/api/v1/apps', options));
+    if (error) return exit(error);
+    if (response.statusCode !== 200) return exit(`Failed to list apps: ${requestError(response)}`);
 
-    request.get(`https://${adminFqdn}/api/v1/apps?access_token=${token}`, { rejectUnauthorized, json: true }, function (error, response) {
-        if (error) return exit(error);
-        if (response.statusCode !== 200) return exit(`Failed to list apps: ${requestError(response)}`);
+    if (response.body.apps.length === 0) return console.log('No apps installed.');
 
-        if (response.body.apps.length === 0) return console.log('No apps installed.');
+    if (options.quiet) {
+        console.log(response.body.apps.map(a => a.id).join('\n'));
+        return;
+    }
 
-        if (options.quiet) {
-            console.log(response.body.apps.map(a => a.id).join('\n'));
-            return;
+    var t = new Table();
+
+    response.body.apps.forEach(function (app) {
+        t.cell('Id', app.id);
+        t.cell('Location', app.fqdn);
+        t.cell('Manifest Id', (app.manifest.id || 'customapp') + '@' + app.manifest.version);
+        var prettyState;
+        if (app.installationState === 'installed') {
+            prettyState = (app.debugMode ? 'debug' : app.runState);
+        } else if (app.installationState === 'error') {
+            prettyState = `error (${app.error.installationState})`;
+        } else {
+            prettyState = app.installationState;
         }
-
-        var t = new Table();
-
-        response.body.apps.forEach(function (app) {
-            t.cell('Id', app.id);
-            t.cell('Location', app.fqdn);
-            t.cell('Manifest Id', (app.manifest.id || 'customapp') + '@' + app.manifest.version);
-            var prettyState;
-            if (app.installationState === 'installed') {
-                prettyState = (app.debugMode ? 'debug' : app.runState);
-            } else if (app.installationState === 'error') {
-                prettyState = `error (${app.error.installationState})`;
-            } else {
-                prettyState = app.installationState;
-            }
-            t.cell('State', prettyState);
-            t.newRow();
-        });
-
-        console.log();
-        console.log(t.toString());
+        t.cell('State', prettyState);
+        t.newRow();
     });
-}
-
-function waitForHealthy(appId, options, callback) {
-    assert.strictEqual(typeof appId, 'string');
-    assert.strictEqual(typeof options, 'object');
-    assert.strictEqual(typeof callback, 'function');
-
-    if (!options.wait) return callback();
 
-    process.stdout.write('\n => ' + 'Wait for health check '.cyan);
-
-    const { adminFqdn, token, rejectUnauthorized } = requestOptions(options);
-
-    function checkStatus() {
-        request.get(`https://${adminFqdn}/api/v1/apps/${appId}?access_token=${token}`, { json: true, rejectUnauthorized }, function (error, response) {
-            if (error) return callback(error);
-            if (response.statusCode !== 200) return callback(new Error(`Failed to get app: ${requestError(response)}`));
-
-            // do not check installation state here. it can be pending_backup etc (this is a bug in box code)
-            if (response.body.health === 'healthy') return callback();
-
-            // skip health check if app is in debug mode
-            if (response.body.debugMode !== null) {
-                process.stdout.write(' (skipped in debug mode)');
-                return callback();
-            }
-
-            process.stdout.write('.');
-
-            return setTimeout(checkStatus, 1000);
-        });
-    }
-
-    setTimeout(checkStatus, 1000);
+    console.log();
+    console.log(t.toString());
 }
 
-function waitForTask(taskId, options, callback) {
-    assert.strictEqual(typeof taskId, 'string');
-    assert.strictEqual(typeof options, 'object');
-    assert.strictEqual(typeof callback, 'function');
-
-    let currentMessage = '';
-
-    const { adminFqdn, token, rejectUnauthorized } = requestOptions(options);
-
-    function checkStatus() {
-        request.get(`https://${adminFqdn}/api/v1/tasks/${taskId}?access_token=${token}`, { json: true, rejectUnauthorized }, function (error, response) {
-            if (error) return callback(error);
-            if (response.statusCode !== 200) return callback(new Error(`Failed to get task: ${requestError(response)}`));
-
-            // TODO remove later, for now keep old behavior on if `pending` is missing
-            if (typeof response.body.pending === 'undefined') {
-                // note: for queued tasks, 'active' returns false
-                if (response.body.error || response.body.percent === 100) return callback(null, response.body); // task errored or done
-            } else {
-                if (!response.body.pending && !response.body.active) return callback(null, response.body);
-            }
-
+async function querySecondaryDomains(app, manifest, options) {
+    const secondaryDomains = {};
 
-            let message = response.body.message || '';
+    if(!manifest.httpPorts) return secondaryDomains;
 
-            // Backup downloading includes the filename and clutters the cli output
-            if (message.indexOf('Restore - Down') === 0) {
-                message = 'Downloading backup';
-            }
-
-            // track current progress and show progress dots
-            if (currentMessage && currentMessage === message) {
-                if (currentMessage.indexOf('Creating image') === -1 && currentMessage.indexOf('Downloading backup') === -1) process.stdout.write('.');
-            } else if (message) {
-                process.stdout.write('\n => ' + message.trim().cyan + ' ');
-            } else {
-                process.stdout.write('\n => ' + 'Waiting to start installation '.cyan);
-            }
-
-            currentMessage = message;
-
-            setTimeout(checkStatus, 1000);
-        });
+    for (const env in manifest.httpPorts) {
+        const defaultDomain = (app && app.secondaryDomains && app.secondaryDomains[env]) ? app.secondaryDomains[env] : (manifest.httpPorts[env].defaultValue || '');
+        const input = readlineSync.question(`${manifest.httpPorts[env].description} (default: "${defaultDomain}"): `, {});
+        secondaryDomains[env] = await selectDomain(input, options);
     }
-
-    checkStatus();
-}
-
-function waitForFinishInstallation(appId, taskId, options, callback) {
-    assert.strictEqual(typeof appId, 'string');
-    assert.strictEqual(typeof taskId, 'string');
-    assert.strictEqual(typeof options, 'object');
-    assert.strictEqual(typeof callback, 'function');
-
-    waitForTask(taskId, options, function (error) {
-        if (error) return callback(error);
-
-        const { adminFqdn, token, rejectUnauthorized } = requestOptions(options);
-
-        request.get(`https://${adminFqdn}/api/v1/apps/${appId}?access_token=${token}`, { json: true, rejectUnauthorized }, function (error, response) {
-            if (error) return callback(error);
-            if (response.statusCode !== 200) return callback(new Error(`Failed to get app: ${requestError(response)}`));
-
-            if (response.body.installationState !== 'installed') return callback(new Error(`Installation failed: ${response.body.error ? response.body.error.message : ''}`));
-
-            waitForHealthy(appId, options, callback);
-        });
-    });
-}
-
-function waitForFinishBackup(appId, taskId, options, callback) {
-    assert.strictEqual(typeof appId, 'string');
-    assert.strictEqual(typeof taskId, 'string');
-    assert.strictEqual(typeof options, 'object');
-    assert.strictEqual(typeof callback, 'function');
-
-    waitForTask(taskId, options, function (error, result) {
-        if (error) return callback(error);
-
-        if (result.error) return callback(new Error(`Backup failed: ${result.error.message}`));
-
-        const { adminFqdn, token, rejectUnauthorized } = requestOptions(options);
-
-        request.get(`https://${adminFqdn}/api/v1/apps/${appId}?access_token=${token}`, { json: true, rejectUnauthorized }, function (error, response) {
-            if (error) return callback(error);
-            if (response.statusCode !== 200) return callback(new Error(`Failed to get app: ${requestError(response)}`));
-
-            callback();
-        });
-    });
+    return secondaryDomains;
 }
 
 function queryPortBindings(app, manifest) {
-    var portBindings = { };
+    const portBindings = {};
     const allPorts = _.extend({}, manifest.tcpPorts, manifest.udpPorts);
-    for (var env in allPorts) {
-        var defaultPort = (app && app.portBindings && app.portBindings[env]) ? app.portBindings[env] : (allPorts[env].defaultValue || '');
-        var port = readlineSync.question(allPorts[env].description + ' (default ' + env + '=' + defaultPort + '. "x" to disable): ', {});
+    for (const env in allPorts) {
+        const defaultPort = (app && app.portBindings && app.portBindings[env]) ? app.portBindings[env] : (allPorts[env].defaultValue || '');
+        const port = readlineSync.question(allPorts[env].description + ' (default ' + env + '=' + defaultPort + '. "x" to disable): ', {});
         if (port === '') {
             portBindings[env] = defaultPort;
         } else if (isNaN(parseInt(port, 10))) {
@@ -534,55 +489,52 @@ function parseDebugCommand(cmd) {
     return cmd.split(' '); // yet another hack
 }
 
-function downloadManifest(appstoreId, callback) {
+async function downloadManifest(appstoreId) {
     const parts = appstoreId.split('@');
     const url = config.appStoreOrigin() + '/api/v1/apps/' + parts[0] + (parts[1] ? '/versions/' + parts[1] : '');
 
-    request.get(url, { json: true }, function (error, response) {
-        if (error) return callback(error);
-        if (response.statusCode !== 200) return exit(`Failed to get app info from store: ${requestError(response)}`);
+    const [error, response] = await safe(superagent.get(url).ok(() => true));
+    if (error) throw new Error(`Failed to list apps from appstore: ${error.message}`);
+    if (response.statusCode !== 200) throw new Error(`Failed to get app info from store: ${requestError(response)}`);
 
-        callback(null, response.body.manifest, null /* manifest file path */);
-    });
+    return { manifest: response.body.manifest, manifestFilePath: null /* manifest file path */ };
 }
 
-function getManifest(appstoreId, callback) {
+async function getManifest(appstoreId) {
     assert.strictEqual(typeof appstoreId, 'string');
-    assert.strictEqual(typeof callback, 'function');
 
-    if (appstoreId) return downloadManifest(appstoreId, callback);
+    if (appstoreId) return await downloadManifest(appstoreId);
 
-    var manifestFilePath = helper.locateManifest();
-    if (!manifestFilePath) return callback(new Error('No CloudronManifest.json found'));
+    const manifestFilePath = helper.locateManifest();
+    if (!manifestFilePath) throw new Error('No CloudronManifest.json found');
 
-    var result = manifestFormat.parseFile(manifestFilePath);
-    if (result.error) return exit('Invalid CloudronManifest.json: '.red + result.error.message);
+    const result = manifestFormat.parseFile(manifestFilePath);
+    if (result.error) throw new Error(`Invalid CloudronManifest.json: ${result.error.message}`);
 
     // resolve post install message
     if (result.manifest.postInstallMessage && result.manifest.postInstallMessage.slice(0, 7) === 'file://') {
-        var postInstallFilename = result.manifest.postInstallMessage.slice(7);
+        let postInstallFilename = result.manifest.postInstallMessage.slice(7);
         // resolve filename wrt manifest
         if (manifestFilePath) postInstallFilename = path.resolve(path.dirname(manifestFilePath), postInstallFilename);
         result.manifest.postInstallMessage = safe.fs.readFileSync(postInstallFilename, 'utf8');
         if (!result.manifest.postInstallMessage) return exit('Could not read postInstallMessage file ' + postInstallFilename + ':' + safe.error.message);
     }
 
-    callback(null, result.manifest, manifestFilePath);
+    return { manifest: result.manifest, manifestFilePath };
 }
 
-function install(options) {
+async function install(options) {
     helper.verifyArguments(arguments);
 
-    if (options.app) exit('Use "cloudron update" to update an app');
-
-    getManifest(options.appstoreId || '', function (error, manifest, manifestFilePath) {
-        if (error) return exit(error);
+    try {
+        const result = await getManifest(options.appstoreId || '');
+        const { manifest, manifestFilePath } = result;
 
         if (!manifest.dockerImage) {
             const sourceDir = path.dirname(manifestFilePath);
             const image = options.image || config.getAppConfig(sourceDir).dockerImage;
 
-            if (!image) exit('No image found, please run `cloudron build` first or specify using --image');
+            if (!image) return exit('No image found, please run `cloudron build` first or specify using --image');
 
             manifest.dockerImage = image;
         }
@@ -590,340 +542,336 @@ function install(options) {
         const location = options.location || readlineSync.question('Location: ', {});
         if (!location) return exit('');
 
-        selectDomain(location, options, function (error, domainObject) {
-            if (error) return exit(error);
-
-            // port bindings
-            let portBindings = {};
-            if (options.portBindings) {
-                // ask the user for port values if the ports are different in the app and the manifest
-                if (typeof options.portBindings === 'string') {
-                    portBindings = { };
-                    options.portBindings.split(',').forEach(function (kv) {
-                        var tmp = kv.split('=');
-                        if (isNaN(parseInt(tmp[1], 10))) return; // disable the port
-                        portBindings[tmp[0]] = parseInt(tmp[1], 10);
-                    });
-                } else {
-                    portBindings = queryPortBindings(null /* existing app */, manifest);
-                }
-            } else { // just put in defaults
-                const allPorts = _.extend({}, manifest.tcpPorts, manifest.udpPorts);
-                for (let portName in allPorts) {
-                    portBindings[portName] = allPorts[portName].defaultValue;
+        const domainObject = await selectDomain(location, options);
+
+        // secondary domains
+        let secondaryDomains = {};
+        if (options.secondaryDomains) {
+            // ask the user for port values if the ports are different in the app and the manifest
+            if (typeof options.secondaryDomains === 'string') {
+                secondaryDomains = {};
+                for (const kv of options.secondaryDomains.split(',')) {
+                    const tmp = kv.split('=');
+                    secondaryDomains[tmp[0]] = await selectDomain(tmp[1], options);
                 }
+            } else {
+                secondaryDomains = await querySecondaryDomains(null /* existing app */, manifest, options);
             }
-
-            for (var binding in portBindings) {
-                console.log('%s: %s', binding, portBindings[binding]);
+        } else if (manifest.httpPorts) { // just put in defaults
+            for (const env in manifest.httpPorts) {
+                secondaryDomains[env] = await selectDomain(manifest.httpPorts[env].defaultValue, options);
             }
+        }
 
-            let data = {
-                appStoreId: options.appstoreId || '', // note case change
-                manifest: options.appstoreId ? null : manifest, // cloudron ignores manifest anyway if appStoreId is set
-                location: domainObject.location,
-                domain: domainObject.domain,
-                portBindings: portBindings,
-                accessRestriction: null
-            };
-
-            // the sso only applies for apps which allow optional sso
-            if (manifest.optionalSso) data.sso = options.sso;
-
-            if (options.debug) {
-                data.debugMode = {
-                    readonlyRootfs: options.readonly ? true : false,
-                    cmd: parseDebugCommand(options.debug)
-                };
-                data.memoryLimit = -1;
-                options.wait = false; // in debug mode, health check never succeeds
+        for (const binding in secondaryDomains) console.log(`Secondary domain ${binding}: ${secondaryDomains[binding].subdomain}.${secondaryDomains[binding].domain}`);
+
+        // port bindings
+        let portBindings = {};
+        if (options.portBindings) {
+            // ask the user for port values if the ports are different in the app and the manifest
+            if (typeof options.portBindings === 'string') {
+                portBindings = { };
+                options.portBindings.split(',').forEach(function (kv) {
+                    let tmp = kv.split('=');
+                    if (isNaN(parseInt(tmp[1], 10))) return; // disable the port
+                    portBindings[tmp[0]] = parseInt(tmp[1], 10);
+                });
+            } else {
+                portBindings = queryPortBindings(null /* existing app */, manifest);
             }
-
-            if (!options.appstoreId && manifest.icon) {
-                let iconFilename = manifest.icon.slice(0, 7) === 'file://' ? manifest.icon.slice(7) : manifest.icon;
-                iconFilename = path.resolve(path.dirname(manifestFilePath), iconFilename); // resolve filename wrt manifest
-                data.icon = safe.fs.readFileSync(iconFilename, { encoding: 'base64' });
-                if (!data.icon) return exit(`Could not read icon: ${iconFilename} message: ${safe.error.message}`);
+        } else { // just put in defaults
+            const allPorts = _.extend({}, manifest.tcpPorts, manifest.udpPorts);
+            for (let portName in allPorts) {
+                portBindings[portName] = allPorts[portName].defaultValue;
             }
+        }
 
-            const { adminFqdn, token, rejectUnauthorized } = requestOptions(options);
+        for (const binding in portBindings) console.log(`Port ${binding}: ${portBindings[binding]}`);
+
+        const data = {
+            appStoreId: options.appstoreId || '', // note case change
+            manifest: options.appstoreId ? null : manifest, // cloudron ignores manifest anyway if appStoreId is set
+            location: domainObject.subdomain, // LEGACY
+            subdomain: domainObject.subdomain,
+            domain: domainObject.domain,
+            secondaryDomains,
+            portBindings,
+            accessRestriction: null
+        };
 
-            request.post(`https://${adminFqdn}/api/v1/apps/install?access_token=${token}`, { rejectUnauthorized, json: data }, function (error, response) {
-                if (error) return exit(error);
-                if (response.statusCode !== 202) return exit(`Failed to install app: ${requestError(response)}`);
+        // the sso only applies for apps which allow optional sso
+        if (manifest.optionalSso) data.sso = options.sso;
 
-                const appId = response.body.id;
+        if (options.debug) {
+            data.debugMode = {
+                readonlyRootfs: options.readonly ? true : false,
+                cmd: parseDebugCommand(options.debug)
+            };
+            data.memoryLimit = -1;
+            options.wait = false; // in debug mode, health check never succeeds
+        }
 
-                console.log('App is being installed.');
+        if (!options.appstoreId && manifest.icon) {
+            let iconFilename = manifest.icon.slice(0, 7) === 'file://' ? manifest.icon.slice(7) : manifest.icon;
+            iconFilename = path.resolve(path.dirname(manifestFilePath), iconFilename); // resolve filename wrt manifest
+            data.icon = safe.fs.readFileSync(iconFilename, { encoding: 'base64' });
+            if (!data.icon) return exit(`Could not read icon: ${iconFilename} message: ${safe.error.message}`);
+        }
 
-                waitForFinishInstallation(appId, response.body.taskId, options, function (error) {
-                    if (error) exit('\n\nApp installation error: %s'.red, error.message);
+        const request = createRequest('POST', '/api/v1/apps/install', options);
+        const response = await request.send(data);
+        if (response.statusCode !== 202) return exit(`Failed to install app: ${requestError(response)}`);
 
-                    console.log('\n\nApp is installed.'.green);
-                });
-            });
-        });
-    });
+        const appId = response.body.id;
+
+        console.log('App is being installed.');
+
+        await waitForFinishInstallation(appId, response.body.taskId, options);
+        console.log('\n\nApp is installed.');
+    } catch (error) {
+        exit('\n\nApp installation error: %s', error.message);
+    }
 }
 
-function configure(options) {
+async function configure(options) {
     helper.verifyArguments(arguments);
 
-    getApp(options, function (error, app) {
-        if (error) return exit(error);
-
+    try {
+        const app = await getApp(options);
         if (!app) return exit(NO_APP_FOUND_ERROR_STRING);
 
         if (!options.location) options.location = readlineSync.question(`Enter new location (default: ${app.fqdn}): `, { });
         let location = options.location || app.location;
 
-        selectDomain(location, options, function (error, domainObject) {
-            if (error) exit(error);
+        const domainObject = await selectDomain(location, options);
 
-            const data = {
-                location: domainObject.location,
-                domain: domainObject.domain,
-                portBindings: app.portBindings
+        const secondaryDomains = {};
+        app.secondaryDomains.forEach(sd => {
+            secondaryDomains[sd.environmentVariable] = {
+                subdomain: sd.subdomain,
+                domain: sd.domain
             };
+        });
 
-            // port bindings
-            if (options.portBindings) {
-                var portBindings = app.portBindings;
-                // ask the user for port values if the ports are different in the app and the manifest
-                if (typeof options.portBindings === 'string') {
-                    portBindings = {};
-                    options.portBindings.split(',').forEach(function (kv) {
-                        var tmp = kv.split('=');
-                        if (isNaN(parseInt(tmp[1], 10))) return; // disable the port
-                        portBindings[tmp[0]] = parseInt(tmp[1], 10);
-                    });
-                } else {
-                    portBindings = queryPortBindings(app, app.manifest);
-                }
+        const data = {
+            location: domainObject.subdomain, // LEGACY
+            subdomain: domainObject.subdomain,
+            domain: domainObject.domain,
+            portBindings: app.portBindings,
+            secondaryDomains
+        };
 
-                for (let binding in portBindings) {
-                    console.log('%s: %s', binding, portBindings[binding]);
+        // secondary domains
+        if (options.secondaryDomains) {
+            // ask the user for port values if the ports are different in the app and the manifest
+            if (typeof options.secondaryDomains === 'string') {
+                data.secondaryDomains = {};
+                for (const kv of options.secondaryDomains.split(',')) {
+                    const tmp = kv.split('=');
+                    data.secondaryDomains[tmp[0]] = await selectDomain(tmp[1], options);
                 }
-
-                data.portBindings = portBindings;
+            } else {
+                data.secondaryDomains = await querySecondaryDomains(app, app.manifest, options);
             }
 
-            const { adminFqdn, token, rejectUnauthorized } = requestOptions(options);
+            for (const binding in data.secondaryDomains) console.log(`Secondary domain ${binding}: ${data.secondaryDomains[binding].subdomain}.${data.secondaryDomains[binding].domain}`);
+        }
 
-            request.post(`https://${adminFqdn}/api/v1/apps/${app.id}/configure/location?access_token=${token}`, { rejectUnauthorized, json: data }, function (error, response) {
-                if (error) return exit(error);
-                if (response.statusCode !== 202) return exit(`Failed to configure app: ${requestError(response)}`);
+        // port bindings
+        if (options.portBindings) {
+            let portBindings = app.portBindings;
+            // ask the user for port values if the ports are different in the app and the manifest
+            if (typeof options.portBindings === 'string') {
+                portBindings = {};
+                options.portBindings.split(',').forEach(function (kv) {
+                    const tmp = kv.split('=');
+                    if (isNaN(parseInt(tmp[1], 10))) return; // disable the port
+                    portBindings[tmp[0]] = parseInt(tmp[1], 10);
+                });
+            } else {
+                portBindings = queryPortBindings(app, app.manifest);
+            }
 
-                waitForTask(response.body.taskId, options, function (error) {
-                    if (error) return exit(error);
+            for (let binding in portBindings) {
+                console.log('%s: %s', binding, portBindings[binding]);
+            }
 
-                    waitForHealthy(app.id, options, function (error) {
-                        if (error) return exit(error);
+            data.portBindings = portBindings;
+        }
 
-                        console.log('\n\nApp configured'.green);
-                    });
-                });
-            });
-        });
-    });
+        const request = createRequest('POST', `/api/v1/apps/${app.id}/configure/location`, options);
+        const response = await request.send(data);
+        if (response.statusCode !== 202) return exit(`Failed to configure app: ${requestError(response)}`);
+
+        await waitForTask(response.body.taskId, options);
+        await waitForHealthy(app.id, options);
+        console.log('\n\nApp configured');
+    } catch (error) {
+        exit(error);
+    }
 }
 
-function update(options) {
+async function update(options) {
     helper.verifyArguments(arguments);
 
-    getApp(options, function (error, app) {
-        if (error) return exit(error);
-
+    try {
+        const app = await getApp(options);
         if (!app) return exit(NO_APP_FOUND_ERROR_STRING);
 
-        getManifest(options.appstoreId || '', function (error, manifest, manifestFilePath) {
-            if (error) return exit(error);
+        const result = await getManifest(options.appstoreId || '');
+        const { manifest, manifestFilePath } = result;
 
-            let data = {};
+        let data = {};
 
-            if (!manifest.dockerImage) {
-                const sourceDir = path.dirname(manifestFilePath);
-                const image = options.image || config.getAppConfig(sourceDir).dockerImage;
+        if (!manifest.dockerImage) {
+            const sourceDir = path.dirname(manifestFilePath);
+            const image = options.image || config.getAppConfig(sourceDir).dockerImage;
 
-                if (!image) return exit('No image found, please run `cloudron build` first or use --image');
+            if (!image) return exit('No image found, please run `cloudron build` first or use --image');
 
-                manifest.dockerImage = image;
+            manifest.dockerImage = image;
 
-                if (manifest.icon) {
-                    let iconFilename = manifest.icon.slice(0, 7) === 'file://' ? manifest.icon.slice(7) : manifest.icon;
-                    iconFilename = path.resolve(path.dirname(manifestFilePath), iconFilename); // resolve filename wrt manifest
-                    data.icon = safe.fs.readFileSync(iconFilename, { encoding: 'base64' });
-                    if (!data.icon) return exit(`Could not read icon: ${iconFilename} message: ${safe.error.message}`);
-                }
+            if (manifest.icon) {
+                let iconFilename = manifest.icon.slice(0, 7) === 'file://' ? manifest.icon.slice(7) : manifest.icon;
+                iconFilename = path.resolve(path.dirname(manifestFilePath), iconFilename); // resolve filename wrt manifest
+                data.icon = safe.fs.readFileSync(iconFilename, { encoding: 'base64' });
+                if (!data.icon) return exit(`Could not read icon: ${iconFilename} message: ${safe.error.message}`);
             }
+        }
 
-            const { adminFqdn, token, rejectUnauthorized } = requestOptions(options);
-            let url;
-
-            if (app.error && (app.error.installationState === 'pending_install')) { // install had failed. call repair to re-install
-                url = `https://${adminFqdn}/api/v1/apps/${app.id}/repair?access_token=${token}`;
-                data = _.extend(data, { manifest });
-            } else {
-                url = `https://${adminFqdn}/api/v1/apps/${app.id}/update?access_token=${token}`;
-                data = _.extend(data, {
-                    appStoreId: options.appstoreId || '', // note case change
-                    manifest: manifest,
-                    skipBackup: !options.backup,
-                    skipNotification: true,
-                    force: true // permit downgrades
-                });
-            }
+        let apiPath;
 
-            request.post(url, { rejectUnauthorized, json: data }, function (error, response) {
-                if (error) return exit(error);
-                if (response.statusCode !== 202) return exit(`Failed to update app: ${requestError(response)}`);
+        if (app.error && (app.error.installationState === 'pending_install')) { // install had failed. call repair to re-install
+            apiPath = `/api/v1/apps/${app.id}/repair`;
+            data = _.extend(data, { manifest });
+        } else {
+            apiPath = `/api/v1/apps/${app.id}/update`;
+            data = _.extend(data, {
+                appStoreId: options.appstoreId || '', // note case change
+                manifest: manifest,
+                skipBackup: !options.backup,
+                skipNotification: true,
+                force: true // permit downgrades
+            });
+        }
 
-                process.stdout.write('\n => ' + 'Waiting for app to be updated '.cyan);
+        const request = createRequest('POST', apiPath, options);
+        const response = await request.send(data);
+        if (response.statusCode !== 202) return exit(`Failed to update app: ${requestError(response)}`);
 
-                waitForFinishInstallation(app.id, response.body.taskId, options, function (error) {
-                    if (error) exit('\n\nApp update error: %s'.red, error.message);
+        process.stdout.write('\n => ' + 'Waiting for app to be updated ');
 
-                    console.log('\n\nApp is updated.'.green);
-                });
-            });
-        });
-    });
+        await waitForFinishInstallation(app.id, response.body.taskId, options);
+        console.log('\n\nApp is updated.');
+    } catch (error) {
+        exit('\n\nApp update error: %s', error.message);
+    }
 }
 
-function debug(cmd, options) {
-    getApp(options, function (error, app) {
-        if (error) return exit(error);
-
+async function debug(cmd, options) {
+    try {
+        const app = await getApp(options);
         if (!app) return exit(NO_APP_FOUND_ERROR_STRING);
 
-        var data = {
+        const data = {
             debugMode: options.disable ? null : {
                 readonlyRootfs: options.readonly ? true : false,
                 cmd: parseDebugCommand(cmd.join(' ').trim())
             }
         };
 
-        const { adminFqdn, token, rejectUnauthorized } = requestOptions(options);
-
-        request.post(`https://${adminFqdn}/api/v1/apps/${app.id}/configure/debug_mode?access_token=${token}`, { rejectUnauthorized, json: data }, function (error, response) {
-            if (error) return exit(error);
-            if (response.statusCode !== 202) return exit(`Failed to set debug mode: ${requestError(response)}`);
+        const request = createRequest('POST', `/api/v1/apps/${app.id}/configure/debug_mode`, options);
+        const response = await request.send(data);
+        if (response.statusCode !== 202) return exit(`Failed to set debug mode: ${requestError(response)}`);
 
-            waitForTask(response.body.taskId, options, function (error) {
-                if (error) return exit(error);
+        await waitForTask(response.body.taskId, options);
 
-                var memoryLimit = options.limitMemory ? 0 : -1;
+        const memoryLimit = options.limitMemory ? 0 : -1;
 
-                // skip setting memory limit if unchanged
-                if (app.memoryLimit === memoryLimit) return console.log('\n\nDone');
+        // skip setting memory limit if unchanged
+        if (app.memoryLimit === memoryLimit) return console.log('\n\nDone');
 
-                console.log('\n');
-                console.log(options.limitMemory ? 'Limiting memory' : 'Setting unlimited memory');
+        console.log('\n');
+        console.log(options.limitMemory ? 'Limiting memory' : 'Setting unlimited memory');
 
-                request.post(`https://${adminFqdn}/api/v1/apps/${app.id}/configure/memory_limit?access_token=${token}`, { rejectUnauthorized, json: { memoryLimit } }, function (error, response) {
-                    if (error) return exit(error);
-                    if (response.statusCode !== 202) return exit(`Failed to set memory limit: ${requestError(response)}`);
+        const request2 = createRequest('POST', `/api/v1/apps/${app.id}/configure/memory_limit`, options);
+        const response2 = await request2.send({ memoryLimit });
+        if (response2.statusCode !== 202) return exit(`Failed to set memory limit: ${requestError(response2)}`);
 
-                    waitForTask(response.body.taskId, options, function (error) {
-                        if (error) return exit(error);
-
-                        console.log('\n\nDone');
-                    });
-                });
-            });
-        });
-    });
+        await waitForTask(response2.body.taskId, options);
+        console.log('\n\nDone');
+    } catch (error) {
+        exit(error);
+    }
 }
 
-function repair(options) {
-    getApp(options, function (error, app) {
-        if (error) return exit(error);
-
+async function repair(options) {
+    try {
+        const app = await getApp(options);
         if (!app) return exit(NO_APP_FOUND_ERROR_STRING);
 
-        getManifest('' /* appStoreId */, function (error, manifest, manifestFilePath) {
-            let dockerImage = options.image;
-            if (!dockerImage) {
-                if (error) return exit(error);
-
-                const sourceDir = path.dirname(manifestFilePath);
-                dockerImage = config.getAppConfig(sourceDir).dockerImage;
-            }
-
-            if (!dockerImage) return exit('No image found, please run `cloudron build` first or use --image');
+        const { manifestFilePath } = await getManifest('' /* appStoreId */);
 
-            const { adminFqdn, token, rejectUnauthorized } = requestOptions(options);
-            const data = { dockerImage };
+        let dockerImage = options.image;
+        if (!dockerImage) {
+            const sourceDir = path.dirname(manifestFilePath);
+            dockerImage = config.getAppConfig(sourceDir).dockerImage;
+        }
 
-            request.post(`https://${adminFqdn}/api/v1/apps/${app.id}/repair?access_token=${token}`, { rejectUnauthorized, json: data }, function (error, response) {
-                if (error) return exit(error);
-                if (response.statusCode !== 202) return exit(`Failed to set repair mode: ${requestError(response)}`);
+        if (!dockerImage) return exit('No image found, please run `cloudron build` first or use --image');
 
-                process.stdout.write('\n => ' + 'Waiting for app to be repaired '.cyan);
+        const request = createRequest('POST', `/api/v1/apps/${app.id}/repair`, options);
+        const response = await request.send({ dockerImage });
+        if (response.statusCode !== 202) return exit(`Failed to set repair mode: ${requestError(response)}`);
 
-                waitForFinishInstallation(app.id, response.body.taskId, options, function (error) {
-                    if (error) exit('\n\nApp repair error: %s'.red, error.message);
+        process.stdout.write('\n => ' + 'Waiting for app to be repaired ');
 
-                    console.log('\n\nApp is repaired.'.green);
-                });
-            });
-        });
-    });
+        await waitForFinishInstallation(app.id, response.body.taskId, options);
+        console.log('\n\nApp is repaired.');
+    } catch (error) {
+        exit('App repair error: %s', error.message);
+    }
 }
 
-function cancel(options) {
+async function cancel(options) {
     helper.verifyArguments(arguments);
 
-    getApp(options, function (error, app) {
-        if (error) return exit(error);
-
+    try {
+        const app = await getApp(options);
         if (!app) return exit(NO_APP_FOUND_ERROR_STRING);
-
         if (!app.taskId) return exit('No active task.');
-
-        stopActiveTask(app, options, function (error) {
-            if (error) exit(error);
-
-            console.log('\nTask stopped.'.green);
-        });
-    });
+        await stopActiveTask(app, options);
+        console.log('\nTask stopped.');
+    } catch (error) {
+        exit(error);
+    }
 }
 
-function uninstall(options) {
+async function uninstall(options) {
     helper.verifyArguments(arguments);
 
-    getApp(options, function (error, app) {
-        if (error) return exit(error);
-
+    try {
+        const app = await getApp(options);
         if (!app) return exit(NO_APP_FOUND_ERROR_STRING);
 
-        stopActiveTask(app, options, function (error) {
-            if (error) exit(error);
-
-            const { adminFqdn, token, rejectUnauthorized } = requestOptions(options);
+        await stopActiveTask(app, options);
 
-            request.post(`https://${adminFqdn}/api/v1/apps/${app.id}/uninstall?access_token=${token}`, { rejectUnauthorized, json: true }, function (error, response) {
-                if (error) return exit(error);
-                if (response.statusCode !== 202) return exit(`Failed to uninstall app: ${requestError(response)}`);
+        const response = await createRequest('POST', `/api/v1/apps/${app.id}/uninstall`, options);
+        if (response.statusCode !== 202) return exit(`Failed to uninstall app: ${requestError(response)}`);
 
-                process.stdout.write('\n => ' + 'Waiting for app to be uninstalled '.cyan);
+        process.stdout.write('\n => ' + 'Waiting for app to be uninstalled ');
 
-                waitForTask(response.body.taskId, options, function (error) {
-                    if (error) return exit(error);
-
-                    request.get(`https://${adminFqdn}/api/v1/apps/${app.id}?access_token=${token}`, { rejectUnauthorized, json: true }, function (error, response) {
-                        if (error) return exit(error);
-                        if (response.statusCode === 404) {
-                            console.log('\n\nApp %s successfully uninstalled.', app.fqdn.bold);
-                        } else if (response.body.installationState === 'error') {
-                            console.log('\n\nApp uninstallation failed.\n'.red);
-                            exit(response.body.errorMessage);
-                        }
-                    });
-                });
-            });
-        });
-    });
+        await waitForTask(response.body.taskId, options);
+        const response2 = await createRequest('GET', `/api/v1/apps/${app.id}`, options);
+        if (response2.statusCode === 404) {
+            console.log('\n\nApp %s successfully uninstalled.', app.fqdn);
+        } else if (response2.body.installationState === 'error') {
+            console.log('\n\nApp uninstallation failed.\n');
+            exit(response2.body.errorMessage);
+        }
+    } catch (error) {
+        exit(error);
+    }
 }
 
 function logPrinter(obj) {
@@ -933,308 +881,253 @@ function logPrinter(obj) {
         message = '[large binary blob skipped]';
     } else if (typeof obj.message === 'string') {
         message = obj.message;
-    } else if (util.isArray(obj.message)) {
+    } else if (Array.isArray(obj.message)) {
         message = Buffer.from(obj.message).toString('utf8');
     }
 
-    var ts = new Date(obj.realtimeTimestamp/1000).toTimeString().split(' ')[0];
-    console.log('%s - %s', ts.cyan, message);
+    const ts = new Date(obj.realtimeTimestamp/1000).toTimeString().split(' ')[0];
+    console.log('%s - %s', ts, message);
 }
 
-function logs(options) {
+async function logs(options) {
     helper.verifyArguments(arguments);
 
     const { adminFqdn, token, rejectUnauthorized } = requestOptions(options);
     const lines = options.lines || 500;
     const tail = !!options.tail;
-
-    function processLogs(apiPath) {
-        if (tail) {
-            const url = `${apiPath}?access_token=${token}&lines=10`;
-            var es = new EventSource(url, { rejectUnauthorized }); // not sure why this is needed
-
-            es.on('message', function (e) { // e { type, data, lastEventId }. lastEventId is the timestamp
-                logPrinter(JSON.parse(e.data));
-            });
-
-            es.on('error', function (error) {
-                if (error.status === 401) return exit('Please login first');
-                if (error.status === 412) exit('Logs currently not available.');
-                exit(error);
-            });
-        } else {
-            const url = `${apiPath}?access_token=${token}&lines=${lines}`;
-
-            const req = request.get(url, { rejectUnauthorized }, function (error, response) {
-                if (error) return exit(error);
-                if (response.statusCode !== 200) return exit(`Failed to get logs: ${requestError(response)}`);
-            });
-
-            req.pipe(split(JSON.parse))
-                .on('data', logPrinter)
-                .on('error', process.exit)
-                .on('end', process.exit);
-        }
-    }
+    let apiPath;
 
     if (typeof options.system === 'boolean' && options.system) {
         // box
-        processLogs(`https://${adminFqdn}/api/v1/cloudron/${ tail ? 'logstream' : 'logs' }/box`);
+        apiPath = `https://${adminFqdn}/api/v1/cloudron/${ tail ? 'logstream' : 'logs' }/box`;
     } else if (typeof options.system === 'string') {
         // services
-        processLogs(`https://${adminFqdn}/api/v1/services/${options.system}/${ tail ? 'logstream' : 'logs' }`);
+        apiPath = `https://${adminFqdn}/api/v1/services/${options.system}/${ tail ? 'logstream' : 'logs' }`;
     } else {
         // apps
+        const [error, app] = await safe(getApp(options));
+        if (error) return exit(error);
+        if (!app) return exit(NO_APP_FOUND_ERROR_STRING);
+
+        apiPath = `https://${adminFqdn}/api/v1/apps/${app.id}/${ tail ? 'logstream' : 'logs' }`;
+    }
 
-        getApp(options, function (error, app) {
-            if (error) return exit(error);
-            if (!app) return exit(NO_APP_FOUND_ERROR_STRING);
+    if (tail) {
+        const url = `${apiPath}?access_token=${token}&lines=10`;
+        var es = new EventSource(url, { rejectUnauthorized }); // not sure why this is needed
 
-            processLogs(`https://${adminFqdn}/api/v1/apps/${app.id}/${ tail ? 'logstream' : 'logs' }`);
+        es.on('message', function (e) { // e { type, data, lastEventId }. lastEventId is the timestamp
+            logPrinter(JSON.parse(e.data));
         });
+
+        es.on('error', function (error) {
+            if (error.status === 401) return exit('Please login first');
+            if (error.status === 412) exit('Logs currently not available.');
+            exit(error);
+        });
+    } else {
+        const url = `${apiPath}?access_token=${token}&lines=${lines}`;
+
+        const req = superagent.get(url, { rejectUnauthorized });
+        req.on('response', function (response) {
+            if (response.statusCode !== 200) return exit(`Failed to get logs: ${requestError(response)}`);
+        });
+        req.pipe(split(JSON.parse))
+            .on('data', logPrinter)
+            .on('error', process.exit)
+            .on('end', process.exit);
     }
 }
 
-function status(options) {
+async function status(options) {
     helper.verifyArguments(arguments);
 
-    getApp(options, function (error, app) {
-        if (error) return exit(error);
-
-        if (!app) return exit(NO_APP_FOUND_ERROR_STRING);
+    const [error, app] = await safe(getApp(options));
+    if (error) return exit(error);
+    if (!app) return exit(NO_APP_FOUND_ERROR_STRING);
 
-        console.log();
-        console.log('Id: \t\t', app.id.cyan);
-        console.log('Location: \t', app.fqdn.cyan);
-        console.log('Version: \t', app.manifest.version.cyan);
-        console.log('Manifest Id: \t', (app.manifest.id || 'customapp').cyan);
-        console.log('Docker image: \t', (app.manifest.dockerImage).cyan);
-        console.log('Install state: \t', (app.installationState + (app.debugMode ? ' (debug)' : '')).cyan);
-        console.log('Run state: \t', app.runState.cyan);
-        console.log();
-
-        exit();
-    });
+    console.log();
+    console.log('Id: \t\t', app.id);
+    console.log('Location: \t', app.fqdn);
+    console.log('Version: \t', app.manifest.version);
+    console.log('Manifest Id: \t', (app.manifest.id || 'customapp'));
+    console.log('Docker image: \t', (app.manifest.dockerImage));
+    console.log('Install state: \t', (app.installationState + (app.debugMode ? ' (debug)' : '')));
+    console.log('Run state: \t', app.runState);
+    console.log();
 }
 
-function inspect(options) {
+async function inspect(options) {
     helper.verifyArguments(arguments);
 
-    const { adminFqdn, token, rejectUnauthorized } = requestOptions(options);
-
-    request.get(`https://${adminFqdn}/api/v1/apps?access_token=${token}`, { rejectUnauthorized, json: true }, function (error, response) {
-        if (error) return exit(error);
+    try {
+        const response = await createRequest('GET', '/api/v1/apps', options);
         if (response.statusCode !== 200) return exit(`Failed to list apps: ${requestError(response)}`);
 
         let apps = [];
 
-        async.eachSeries(response.body.apps, function (app, iteratorDone) {
-            request.get(`https://${adminFqdn}/api/v1/apps/${app.id}?access_token=${token}`, { rejectUnauthorized, json: true }, function (error, response) {
-                if (error) return iteratorDone(error);
-                if (response.statusCode !== 200) return iteratorDone(`Failed to list app: ${requestError(response)}`);
+        for (const app of response.body.apps) {
+            const response2 = await createRequest('GET', `/api/v1/apps/${app.id}`, options);
+            if (response2.statusCode !== 200) return exit(`Failed to list app: ${requestError(response2)}`);
+            response2.body.location = response2.body.subdomain; // LEGACY support
+            apps.push(response2.body);
+        }
 
-                apps.push(response.body);
-                iteratorDone();
-            });
-        }, function (error) {
-            if (error) exit(error);
-
-            console.log(JSON.stringify({
-                apiEndpoint: adminFqdn,
-                appStoreOrigin: config.appStoreOrigin(),
-                apps: apps
-            }, null, 4));
-        });
-    });
+        const { adminFqdn } = requestOptions(options);
+        console.log(JSON.stringify({
+            apiEndpoint: adminFqdn,
+            appStoreOrigin: config.appStoreOrigin(),
+            apps: apps
+        }, null, 4));
+    } catch (error) {
+        exit(error);
+    }
 }
 
-function restart(options) {
+async function restart(options) {
     helper.verifyArguments(arguments);
 
-    getApp(options, function (error, app) {
-        if (error) return exit(error);
-
+    try {
+        const app = await getApp(options);
         if (!app) return exit(NO_APP_FOUND_ERROR_STRING);
-
-        stopApp(app, options, function (error) {
-            if (error) exit(error);
-
-            startApp(app, options, function (error) {
-                if (error) return exit(error);
-
-                waitForHealthy(app.id, options, function (error) {
-                    if (error) return exit(error);
-
-                    console.log('\n\nApp restarted'.green);
-                });
-            });
-        });
-    });
+        await stopApp(app, options);
+        await startApp(app, options);
+        await waitForHealthy(app.id, options);
+        console.log('\n\nApp restarted');
+    } catch (error) {
+        exit(error);
+    }
 }
 
-function start(options) {
+async function start(options) {
     helper.verifyArguments(arguments);
 
-    getApp(options, function (error, app) {
-        if (error) return exit(error);
-
+    try {
+        const app = await getApp(options);
         if (!app) return exit(NO_APP_FOUND_ERROR_STRING);
-
-        startApp(app, options, function (error) {
-            if (error) return exit(error);
-
-            waitForHealthy(app.id, options, function (error) {
-                if (error) return exit(error);
-
-                console.log('\n\nApp started'.green);
-            });
-        });
-    });
+        await startApp(app, options);
+        await waitForHealthy(app.id, options);
+        console.log('\n\nApp started');
+    } catch (error) {
+        exit(error);
+    }
 }
 
-function stop(options) {
+async function stop(options) {
     helper.verifyArguments(arguments);
 
-    getApp(options, function (error, app) {
-        if (error) return exit(error);
-
+    try {
+        const app = await getApp(options);
         if (!app) return exit(NO_APP_FOUND_ERROR_STRING);
-
-        stopApp(app, options, function (error) {
-            if (error) exit(error);
-
-            console.log('\n\nApp stopped'.green);
-
-            exit();
-        });
-    });
+        await stopApp(app, options);
+        console.log('\n\nApp stopped');
+    } catch (error) {
+        exit(error);
+    }
 }
 
-function backupCreate(options) {
+async function backupCreate(options) {
     helper.verifyArguments(arguments);
 
-    getApp(options, function (error, app) {
-        if (error) return exit(error);
-
+    try {
+        const app = await getApp(options);
         if (!app) return exit(NO_APP_FOUND_ERROR_STRING);
 
-        const { adminFqdn, token, rejectUnauthorized } = requestOptions(options);
-
-        // get existing options and then remove
-        request.post(`https://${adminFqdn}/api/v1/apps/${app.id}/backup?access_token=${token}`, { json: {}, rejectUnauthorized }, function (error, response) {
-            if (error) return exit(error);
-            if (response.statusCode !== 202) return exit(`Failed to start backup: ${requestError(response)}`);
+        const response = await createRequest('POST', `/api/v1/apps/${app.id}/backup`, options);
+        if (response.statusCode !== 202) return exit(`Failed to start backup: ${requestError(response)}`);
 
-            // FIXME: this should be waitForHealthCheck but the box code incorrectly modifies the installationState
-            waitForFinishBackup(app.id, response.body.taskId, options, function (error) {
-                if (error) return exit('\n\nApp backup error: %s'.red, error.message);
-
-                console.log('\n\nApp is backed up'.green);
-            });
-        });
-    });
+        // FIXME: this should be waitForHealthCheck but the box code incorrectly modifies the installationState
+        await waitForFinishBackup(app.id, response.body.taskId, options);
+        console.log('\n\nApp is backed up');
+    } catch (error) {
+        exit('\n\nApp backup error: %s', error.message);
+    }
 }
 
-function backupList(options) {
+async function backupList(options) {
     helper.verifyArguments(arguments);
 
-    getApp(options, function (error, app) {
-        if (error) return exit(error);
-
+    try {
+        const app = await getApp(options);
         if (!app) return exit(NO_APP_FOUND_ERROR_STRING);
 
-        const { adminFqdn, token, rejectUnauthorized } = requestOptions(options);
-
-        // get existing options and then remove
-        request.get(`https://${adminFqdn}/api/v1/apps/${app.id}/backups?access_token=${token}`, { json: true, rejectUnauthorized }, function (error, response) {
-            if (error) return exit(error);
-            if (response.statusCode !== 200) return exit(`Failed to list backups: ${requestError(response)}`);
+        const response = await createRequest('GET', `/api/v1/apps/${app.id}/backups`, options);
+        if (response.statusCode !== 200) return exit(`Failed to list backups: ${requestError(response)}`);
 
-            if (options.raw) return console.log(JSON.stringify(response.body.backups, null, 4));
+        if (options.raw) return console.log(JSON.stringify(response.body.backups, null, 4));
 
-            if (response.body.backups.length === 0) return console.log('No backups.');
+        if (response.body.backups.length === 0) return console.log('No backups.');
 
-            response.body.backups = response.body.backups.map(function (backup) {
-                backup.creationTime = new Date(backup.creationTime);
-                return backup;
-            }).sort(function (a, b) { return b.creationTime - a.creationTime; });
-
-            var t = new Table();
+        response.body.backups = response.body.backups.map(function (backup) {
+            backup.creationTime = new Date(backup.creationTime);
+            return backup;
+        }).sort(function (a, b) { return b.creationTime - a.creationTime; });
 
-            response.body.backups.forEach(function (backup) {
-                t.cell('Id', backup.id);
-                t.cell('Creation Time', backup.creationTime);
-                t.cell('Version', backup.packageVersion);
+        var t = new Table();
 
-                t.newRow();
-            });
+        response.body.backups.forEach(function (backup) {
+            t.cell('Id', backup.id);
+            t.cell('Creation Time', backup.creationTime);
+            t.cell('Version', backup.packageVersion);
 
-            console.log();
-            console.log(t.toString());
+            t.newRow();
         });
-    });
-}
 
-function getLastBackup(app, options, callback) {
-    const { adminFqdn, token, rejectUnauthorized } = requestOptions(options);
+        console.log();
+        console.log(t.toString());
+    } catch (error) {
+        exit(error);
+    }
+}
 
-    // get existing options and then remove
-    request.get(`https://${adminFqdn}/api/v1/apps/${app.id}/backups?access_token=${token}`, { json: true, rejectUnauthorized }, function (error, response) {
-        if (error) return exit(error);
-        if (response.statusCode !== 200) return callback(new Error(`Failed to list backups: ${requestError(response)}`));
-        if (response.body.backups.length === 0) return callback(new Error('No backups'));
+async function getLastBackup(app, options) {
+    const response = await createRequest('GET', `/api/v1/apps/${app.id}/backups`, options);
+    if (response.statusCode !== 200) throw new Error(`Failed to list backups: ${requestError(response)}`);
+    if (response.body.backups.length === 0) throw new Error('No backups');
 
-        response.body.backups = response.body.backups.map(function (backup) {
-            backup.creationTime = new Date(backup.creationTime);
-            return backup;
-        }).sort(function (a, b) { return b.creationTime - a.creationTime; });
+    response.body.backups = response.body.backups.map(function (backup) {
+        backup.creationTime = new Date(backup.creationTime);
+        return backup;
+    }).sort(function (a, b) { return b.creationTime - a.creationTime; });
 
-        return callback(null, response.body.backups[0].id);
-    });
+    return response.body.backups[0].id;
 }
 
-function restore(options) {
+async function restore(options) {
     helper.verifyArguments(arguments);
 
-    getApp(options, function (error, app) {
-        if (error) return exit(error);
-
+    try {
+        const app = await getApp(options);
         if (!app) return exit(NO_APP_FOUND_ERROR_STRING);
 
-        var func = !options.backup ? getLastBackup.bind(null, app, options) : function (next) { next(null, options.backup); };
-
-        func(function (error, backupId) {
-            if (error) return exit(error);
+        let backupId;
+        if (!options.backup) {
+            backupId = await getLastBackup(app, options);
+        } else {
+            backupId = options.backup;
+        }
 
-            const { adminFqdn, token, rejectUnauthorized } = requestOptions(options);
+        const request = createRequest('POST', `/api/v1/apps/${app.id}/restore`, options);
+        const response = await request.send({ backupId });
+        if (response.statusCode !== 202) return exit(`Failed to restore app: ${requestError(response)}`);
 
-            // get existing options and then remove
-            request.post(`https://${adminFqdn}/api/v1/apps/${app.id}/restore?access_token=${token}`, { json: { backupId }, rejectUnauthorized }, function (error, response) {
-                if (error) return exit(error);
-                if (response.statusCode !== 202) return exit(`Failed to restore app: ${requestError(response)}`);
+        // FIXME: this should be waitForHealthCheck but the box code incorrectly modifies the installationState
+        await waitForFinishInstallation(app.id, response.body.taskId, options);
 
-                // FIXME: this should be waitForHealthCheck but the box code incorrectly modifies the installationState
-                waitForFinishInstallation(app.id, response.body.taskId, options, function (error) {
-                    if (error) {
-                        return exit('\n\nApp restore error: %s'.red, error.message);
-                    }
+        console.log('\n\nApp is restored');
 
-                    console.log('\n\nApp is restored'.green);
-                });
-            });
-        });
-    });
+    } catch (error) {
+        exit('\n\nApp restore error: %s', error.message);
+    }
 }
 
-function importApp(options) {
+async function importApp(options) {
     helper.verifyArguments(arguments);
 
-    getApp(options, function (error, app) {
-        if (error) return exit(error);
-
+    try {
+        const app = await getApp(options);
         if (!app) return exit(NO_APP_FOUND_ERROR_STRING);
 
-        const { adminFqdn, token, rejectUnauthorized } = requestOptions(options);
         let data = {};
 
         if (!options.inPlace) {
@@ -1274,90 +1167,83 @@ function importApp(options) {
             if (backupKey) data.backupConfig.key = backupKey;
         }
 
-        request.post(`https://${adminFqdn}/api/v1/apps/${app.id}/import?access_token=${token}`, { rejectUnauthorized, json: data }, function (error, response) {
-            if (error) return exit(error);
-            if (response.statusCode !== 202) return exit(`Failed to import app: ${requestError(response)}`);
+        const response = await createRequest('POST', `/api/v1/apps/${app.id}/import`, options);
+        if (response.statusCode !== 202) return exit(`Failed to import app: ${requestError(response)}`);
 
-            waitForFinishInstallation(app.id, response.body.taskId, options, function (error) {
-                if (error) return exit('\n\nApp import error: %s'.red, error.message);
-
-                console.log('\n\nApp is restored'.green);
-            });
-        });
-    });
+        await waitForFinishInstallation(app.id, response.body.taskId, options);
+        console.log('\n\nApp is restored');
+    } catch (error) {
+        exit('\n\nApp import error: %s', error.message);
+    }
 }
 
-function exportApp(options) {
+async function exportApp(options) {
     helper.verifyArguments(arguments);
 
-    getApp(options, function (error, app) {
-        if (error) return exit(error);
-
+    try {
+        const app = await getApp(options);
         if (!app) return exit(NO_APP_FOUND_ERROR_STRING);
 
-        const { adminFqdn, token, rejectUnauthorized } = requestOptions(options);
         let data = {};
 
         if (!options.snapshot) return exit('--snapshot is required');
 
-        request.post(`https://${adminFqdn}/api/v1/apps/${app.id}/export?access_token=${token}`, { rejectUnauthorized, json: data }, function (error, response) {
-            if (error) return exit(error);
-            if (response.statusCode !== 202) return exit(`Failed to export app: ${requestError(response)}`);
+        const request = createRequest('POST', `/api/v1/apps/${app.id}/export`, options);
+        const response = await request.send(data);
+        if (response.statusCode !== 202) return exit(`Failed to export app: ${requestError(response)}`);
 
-            waitForFinishInstallation(app.id, response.body.taskId, options, function (error) {
-                if (error) return exit('\n\nApp export error: %s'.red, error.message);
-
-                console.log('\n\nApp is exported'.green);
-            });
-        });
-    });
+        await waitForFinishInstallation(app.id, response.body.taskId, options);
+        console.log('\n\nApp is exported');
+    } catch (error) {
+        exit('\n\nApp export error: %s', error.message);
+    }
 }
 
-function clone(options) {
+async function clone(options) {
     helper.verifyArguments(arguments);
 
-    getApp(options, function (error, app) {
-        if (error) return exit(error);
-
+    try {
+        const app = await getApp(options);
         if (!app) return exit(NO_APP_FOUND_ERROR_STRING);
-        if (!options.backup) return exit('Use --backup to specify the backup id');
-
-        let location = options.location || readlineSync.question('Cloned app location: ', {});
-        let portBindings = queryPortBindings(app, app.manifest);
-        let backupId = options.backup;
-
-        selectDomain(location, options, function (error, domainObject) {
-            if (error) return exit(error);
-
-            const { adminFqdn, token, rejectUnauthorized } = requestOptions(options);
-
-            const data = { backupId, domain: domainObject.domain, location: domainObject.location, portBindings: portBindings };
-
-            request.post(`https://${adminFqdn}/api/v1/apps/${app.id}/clone?access_token=${token}`, { rejectUnauthorized, json: data }, function (error, response) {
-                if (error) return exit(error);
-                if (response.statusCode !== 201) return exit(`Failed to list apps: ${requestError(response)}`);
 
-                // FIXME: this should be waitForHealthCheck but the box code incorrectly modifies the installationState
-                console.log('App cloned as id ' + response.body.id);
-                waitForFinishInstallation(response.body.id, response.body.taskId, options, function (error) {
-                    if (error) return exit(`\n\nClone error: ${error.message}`);
+        if (!options.backup) return exit('Use --backup to specify the backup id');
 
-                    console.log('\n\nApp is cloned'.green);
-                });
-            });
-        });
-    });
+        const location = options.location || readlineSync.question('Cloned app location: ', {});
+        const secondaryDomains = await querySecondaryDomains(app, app.manifest, options);
+        const portBindings = queryPortBindings(app, app.manifest);
+        const backupId = options.backup;
+
+        const domainObject = await selectDomain(location, options);
+        const data = {
+            backupId,
+            location: domainObject.subdomain, // LEGACY
+            subdomain: domainObject.subdomain,
+            domain: domainObject.domain,
+            secondaryDomains,
+            portBindings
+        };
+        const request = createRequest('POST', `/api/v1/apps/${app.id}/clone`, options);
+        const response = await request.send(data);
+        if (response.statusCode !== 201) return exit(`Failed to list apps: ${requestError(response)}`);
+
+        // FIXME: this should be waitForHealthCheck but the box code incorrectly modifies the installationState
+        console.log('App cloned as id ' + response.body.id);
+        await waitForFinishInstallation(response.body.id, response.body.taskId, options);
+        console.log('\n\nApp is cloned');
+    } catch (error) {
+        exit(`\n\nClone error: ${error.message}`);
+    }
 }
 
 // taken from docker-modem
 function demuxStream(stream, stdout, stderr) {
-    var header = null;
+    let header = null;
 
     stream.on('readable', function() {
         header = header || stream.read(8);
         while (header !== null) {
-            var type = header.readUInt8(0);
-            var payload = stream.read(header.readUInt32BE(4));
+            const type = header.readUInt8(0);
+            const payload = stream.read(header.readUInt32BE(4));
             if (payload === null) break;
             if (type == 2) {
                 stderr.write(payload);
@@ -1375,96 +1261,94 @@ function demuxStream(stream, stdout, stderr) {
 // echo "sauce" | cloudron exec -- bash -c "cat - > /app/data/sauce" - test with binary files. should disable tty
 // cat ~/tmp/fantome.tar.gz | cloudron exec -- bash -c "tar xvf - -C /tmp" - must show an error
 // cat ~/tmp/fantome.tar.gz | cloudron exec -- bash -c "tar zxf - -C /tmp" - must extrack ok
-function exec(cmd, options) {
-    var stdin = options._stdin || process.stdin; // hack for 'push', 'pull' to reuse this function
-    var stdout = options._stdout || process.stdout;
+async function exec(cmd, options) {
+    let stdin = options._stdin || process.stdin; // hack for 'push', 'pull' to reuse this function
+    let stdout = options._stdout || process.stdout;
 
-    var tty = !!options.tty;
+    let tty = !!options.const;
 
-    getApp(options, function (error, app) {
-        if (error) return exit(error);
+    const [error, app] = await safe(getApp(options));
+    if (error) return exit(error);
+    if (!app) return exit(NO_APP_FOUND_ERROR_STRING);
 
-        if (!app) return exit(NO_APP_FOUND_ERROR_STRING);
-
-        if (app.installationState !== 'installed') exit('App is not yet running. Try again later.');
-
-        if (cmd.length === 0) {
-            cmd = [ '/bin/bash' ];
-            tty = true; // override
-        }
+    if (app.installationState !== 'installed') exit('App is not yet running. Try again later.');
 
-        if (tty && !stdin.isTTY) exit('stdin is not tty');
+    if (cmd.length === 0) {
+        cmd = [ '/bin/bash' ];
+        tty = true; // override
+    }
 
-        const { adminFqdn, token, rejectUnauthorized } = requestOptions(options);
+    if (tty && !stdin.isTTY) exit('stdin is not tty');
 
-        var query = {
-            rows: stdout.rows,
-            columns: stdout.columns,
-            access_token: token,
-            cmd: JSON.stringify(cmd),
-            tty: tty
-        };
+    const { adminFqdn, token, rejectUnauthorized } = requestOptions(options);
 
-        var req = https.request({
-            hostname: adminFqdn,
-            path: `/api/v1/apps/${app.id}/exec?` + querystring.stringify(query),
-            method: 'GET',
-            headers: {
-                'Connection': 'Upgrade',
-                'Upgrade': 'tcp'
-            },
-            rejectUnauthorized
-        }, function handler(res) {
-            if (res.statusCode === 403) exit('Unauthorized.'.red); // only admin or only owner (for docker addon)
-
-            exit('Could not upgrade connection to tcp. http status:', res.statusCode);
-        });
+    const query = {
+        rows: stdout.rows,
+        columns: stdout.columns,
+        access_token: token,
+        cmd: JSON.stringify(cmd),
+        tty: tty
+    };
 
-        req.on('upgrade', function (resThatShouldNotBeUsed, socket /*, upgradeHead*/) {
-            // do not use res here! it's all socket from here on
-            socket.on('error', exit);
-
-            socket.setNoDelay(true);
-            socket.setKeepAlive(true);
-
-            if (tty) {
-                stdin.setRawMode(true);
-                stdin.pipe(socket, { end: false }); // the remote will close the connection
-                socket.pipe(stdout); // in tty mode, stdout/stderr is merged
-                socket.on('end', exit); // server closed the socket
-            } else {// create stdin process on demand
-                if (typeof stdin === 'function') stdin = stdin();
-
-                stdin.on('data', function (d) {
-                    var buf = Buffer.alloc(4);
-                    buf.writeUInt32BE(d.length, 0 /* offset */);
-                    socket.write(buf);
-                    socket.write(d);
-                });
-                stdin.on('end', function () {
-                    var buf = Buffer.alloc(4);
-                    buf.writeUInt32BE(0, 0 /* offset */);
-                    socket.write(buf);
-                });
+    const req = https.request({
+        hostname: adminFqdn,
+        path: `/api/v1/apps/${app.id}/exec?` + querystring.stringify(query),
+        method: 'GET',
+        headers: {
+            'Connection': 'Upgrade',
+            'Upgrade': 'tcp'
+        },
+        rejectUnauthorized
+    }, function handler(res) {
+        if (res.statusCode === 403) exit('Unauthorized.'); // only admin or only owner (for docker addon)
+
+        exit('Could not upgrade connection to tcp. http status:', res.statusCode);
+    });
 
-                stdout.on('close', () => process.exit()); // this is only emitted when stdout is a file and not the terminal
+    req.on('upgrade', function (resThatShouldNotBeUsed, socket /*, upgradeHead*/) {
+        // do not use res here! it's all socket from here on
+        socket.on('error', exit);
+
+        socket.setNoDelay(true);
+        socket.setKeepAlive(true);
+
+        if (tty) {
+            stdin.setRawMode(true);
+            stdin.pipe(socket, { end: false }); // the remote will close the connection
+            socket.pipe(stdout); // in tty mode, stdout/stderr is merged
+            socket.on('end', exit); // server closed the socket
+        } else {// create stdin process on demand
+            if (typeof stdin === 'function') stdin = stdin();
+
+            stdin.on('data', function (d) {
+                var buf = Buffer.alloc(4);
+                buf.writeUInt32BE(d.length, 0 /* offset */);
+                socket.write(buf);
+                socket.write(d);
+            });
+            stdin.on('end', function () {
+                var buf = Buffer.alloc(4);
+                buf.writeUInt32BE(0, 0 /* offset */);
+                socket.write(buf);
+            });
 
-                demuxStream(socket, stdout, process.stderr); // can get separate streams in non-tty mode
-                socket.on('end', function () {  // server closed the socket
-                    stdin.end(); // required for this process to 'exit' cleanly. do not call exit() because writes may not have finished
-                    if (stdout !== process.stdout) stdout.end(); // for push stream
+            stdout.on('close', () => process.exit()); // this is only emitted when stdout is a file and not the terminal
 
-                    socket.end();
+            demuxStream(socket, stdout, process.stderr); // can get separate streams in non-tty mode
+            socket.on('end', function () {  // server closed the socket
+                stdin.end(); // required for this process to 'exit' cleanly. do not call exit() because writes may not have finished
+                if (stdout !== process.stdout) stdout.end(); // for push stream
 
-                    // process._getActiveHandles(); process._getActiveRequests();
-                    if (stdout === process.stdout) setImmediate(() => process.exit()); // otherwise, we rely on the 'close' event above
-                });
-            }
-        });
+                socket.end();
 
-        req.on('error', exit); // could not make a request
-        req.end(); // this makes the request
+                // process._getActiveHandles(); process._getActiveRequests();
+                if (stdout === process.stdout) setImmediate(() => process.exit()); // otherwise, we rely on the 'close' event above
+            });
+        }
     });
+
+    req.on('error', exit); // could not make a request
+    req.end(); // this makes the request
 }
 
 function push(localDir, remote, options) {
@@ -1537,184 +1421,132 @@ function pull(remote, local, options) {
     }
 }
 
-function createOAuthAppCredentials(options) {
-    const { adminFqdn, token, rejectUnauthorized } = requestOptions(options);
-
-    const data = { appId: 'localdevelopment', redirectURI: options.redirectUri, scope: options.scope };
-
-    request.post(`https://${adminFqdn}/api/v1/clients?access_token=${token}`, { json: data, rejectUnauthorized }, function (error, response) {
-        if (error) return exit(error);
-        if (response.statusCode !== 201) return exit(`Failed to create oauth app credentials: ${requestError(response)}`);
-
-        if (options.shell) {
-            console.log('export CLOUDRON_CLIENT_ID="%s";\nexport CLOUDRON_CLIENT_SECRET="%s";\nexport CLOUDRON_REDIRECT_URI="%s"\nexport CLOUDRON_API_ORIGIN="%s"',
-                response.body.id, response.body.clientSecret, response.body.redirectURI, `https://${adminFqdn}`);
-        } else {
-            console.log();
-            console.log('Useful OAuth information:'.bold);
-            console.log(`apiOrigin:        https://${adminFqdn}`);
-            console.log(`authorizationURL: https://${adminFqdn}/api/v1/oauth/dialog/authorize`);
-            console.log(`tokenURL:         https://${adminFqdn}/api/v1/oauth/token`);
-            console.log();
-            console.log('New oauth app credentials:'.bold);
-            console.log('ClientId:         %s', response.body.id.cyan);
-            console.log('ClientSecret:     %s', response.body.clientSecret.cyan);
-            console.log('RedirectURI:      %s', response.body.redirectURI.cyan);
-            console.log();
-            console.log('Gulp development:'.bold);
-            console.log(`gulp develop --api-origin https://${adminFqdn} --client-id ${response.body.id} --client-secret ${response.body.clientSecret}`);
-        }
-    });
-}
-
 function init() {
-    var manifestFilePath = helper.locateManifest();
-    if (manifestFilePath && path.dirname(manifestFilePath) === process.cwd()) return exit('CloudronManifest.json already exists in current directory'.red);
+    const manifestFilePath = helper.locateManifest();
+    if (manifestFilePath && path.dirname(manifestFilePath) === process.cwd()) return exit('CloudronManifest.json already exists in current directory');
 
-    var manifestTemplate = fs.readFileSync(path.join(__dirname, 'templates/', 'CloudronManifest.json.ejs'), 'utf8');
-    var dockerfileTemplate = fs.readFileSync(path.join(__dirname, 'templates/', 'Dockerfile.ejs'), 'utf8');
-    var dockerignoreTemplate = fs.readFileSync(path.join(__dirname, 'templates/', 'dockerignore.ejs'), 'utf8');
+    const manifestTemplate = fs.readFileSync(path.join(__dirname, 'templates/', 'CloudronManifest.json.ejs'), 'utf8');
+    const dockerfileTemplate = fs.readFileSync(path.join(__dirname, 'templates/', 'Dockerfile.ejs'), 'utf8');
+    const dockerignoreTemplate = fs.readFileSync(path.join(__dirname, 'templates/', 'dockerignore.ejs'), 'utf8');
 
-    var data = {
+    const data = {
         version: '0.1.0',
         title: 'App title',
         httpPort: 3000
     };
 
-    var manifest = ejs.render(manifestTemplate, data);
+    const manifest = ejs.render(manifestTemplate, data);
     fs.writeFileSync('CloudronManifest.json', manifest, 'utf8');
 
     if (fs.existsSync('Dockerfile')) {
         console.log('Dockerfile already exists, skipping');
     } else {
-        var dockerfile = ejs.render(dockerfileTemplate, data);
+        const dockerfile = ejs.render(dockerfileTemplate, data);
         fs.writeFileSync('Dockerfile', dockerfile, 'utf8');
     }
 
     if (fs.existsSync('.dockerignore')) {
         console.log('.dockerignore already exists, skipping');
     } else {
-        var dockerignore = ejs.render(dockerignoreTemplate, data);
+        const dockerignore = ejs.render(dockerignoreTemplate, data);
         fs.writeFileSync('.dockerignore', dockerignore, 'utf8');
     }
 
     console.log();
-    console.log('Now edit the CloudronManifest.json'.yellow.bold);
+    console.log('Now edit the CloudronManifest.json');
     console.log();
 }
 
-function setEnv(app, env, options, callback) {
+async function setEnv(app, env, options) {
     assert.strictEqual(typeof app, 'object');
     assert.strictEqual(typeof env, 'object');
     assert.strictEqual(typeof options, 'object');
-    assert.strictEqual(typeof callback, 'function');
 
-    const { adminFqdn, token, rejectUnauthorized } = requestOptions(options);
-
-    // get existing options first and then merge
-    request.post(`https://${adminFqdn}/api/v1/apps/${app.id}/configure/env?access_token=${token}`, { json: { env }, rejectUnauthorized }, function (error, response) {
-        if (error) return exit(error);
-        if (response.statusCode !== 202) return exit(`Failed to set env: ${requestError(response)}`);
-
-        waitForTask(response.body.taskId, options, function (error) {
-            if (error) return callback(error);
+    const request = createRequest('POST', `/api/v1/apps/${app.id}/configure/env`, options);
+    const response = await request.send({ env });
+    if (response.statusCode !== 202) return exit(`Failed to set env: ${requestError(response)}`);
 
-            console.log('\n');
-        });
-    });
+    await waitForTask(response.body.taskId, options);
+    console.log('\n');
 }
 
-function envSet(envVars, options) {
-    getApp(options, function (error, app) {
-        if (error) return exit(error);
-
+async function envSet(envVars, options) {
+    try {
+        const app = await getApp(options);
         if (!app) return exit(NO_APP_FOUND_ERROR_STRING);
 
-        const { adminFqdn, token, rejectUnauthorized } = requestOptions(options);
-
-        // get existing options first and then merge
-        request.get(`https://${adminFqdn}/api/v1/apps/${app.id}?access_token=${token}`, { json: true, rejectUnauthorized }, function (error, response) {
-            if (error) return exit(error);
-            if (response.statusCode !== 200) return exit(`Failed to get app: ${requestError(response)}`);
-
-            let env = response.body.env;
-            envVars.forEach(envVar => {
-                let m = envVar.match(/(.*?)=(.*)/);
-                if (!m) return exit(`Expecting KEY=VALUE pattern. Got ${envVar}`);
-                env[m[1]] = m[2];
-            });
+        const response = await createRequest('GET', `/api/v1/apps/${app.id}`, options);
+        if (response.statusCode !== 200) return exit(`Failed to get app: ${requestError(response)}`);
 
-            setEnv(app, env, options, exit);
+        let env = response.body.env;
+        envVars.forEach(envVar => {
+            let m = envVar.match(/(.*?)=(.*)/);
+            if (!m) return exit(`Expecting KEY=VALUE pattern. Got ${envVar}`);
+            env[m[1]] = m[2];
         });
-    });
-}
 
-function envUnset(envNames, options) {
-    getApp(options, function (error, app) {
-        if (error) return exit(error);
+        await setEnv(app, env, options);
+    } catch (error) {
+        exit(error);
+    }
+}
 
+async function envUnset(envNames, options) {
+    try {
+        const app = await getApp(options);
         if (!app) return exit(NO_APP_FOUND_ERROR_STRING);
 
-        const { adminFqdn, token, rejectUnauthorized } = requestOptions(options);
-
-        // get existing options and then remove
-        request.get(`https://${adminFqdn}/api/v1/apps/${app.id}?access_token=${token}`, { json: true, rejectUnauthorized }, function (error, response) {
-            if (error) return exit(error);
-            if (response.statusCode !== 200) return exit(`Failed to get app: ${requestError(response)}`);
+        const response = await createRequest('GET', `/api/v1/apps/${app.id}`, options);
+        if (response.statusCode !== 200) return exit(`Failed to get app: ${requestError(response)}`);
 
-            let env = response.body.env;
-            envNames.forEach(name => delete env[name]);
+        let env = response.body.env;
+        envNames.forEach(name => delete env[name]);
 
-            setEnv(app, env, options, exit);
-        });
-    });
+        await setEnv(app, env, options);
+    } catch (error) {
+        exit(error);
+    }
 }
 
-function envList(options) {
+async function envList(options) {
     helper.verifyArguments(arguments);
 
-    getApp(options, function (error, app) {
-        if (error) return exit(error);
-
+    try {
+        const app = await getApp(options);
         if (!app) return exit(NO_APP_FOUND_ERROR_STRING);
 
-        const { adminFqdn, token, rejectUnauthorized } = requestOptions(options);
+        const response = await createRequest('GET', `/api/v1/apps/${app.id}`, options);
+        if (response.statusCode !== 200) return exit(`Failed to get app: ${requestError(response)}`);
 
-        request.get(`https://${adminFqdn}/api/v1/apps/${app.id}?access_token=${token}`, { json: true, rejectUnauthorized }, function (error, response) {
-            if (error) return exit(error);
-            if (response.statusCode !== 200) return exit(`Failed to get app: ${requestError(response)}`);
+        const t = new Table();
 
-            var t = new Table();
+        const envNames = Object.keys(response.body.env);
+        if (envNames.length === 0) return console.log('No custom environment variables');
 
-            const envNames = Object.keys(response.body.env);
-            if (envNames.length === 0) return console.log('No custom environment variables');
+        envNames.forEach(function (envName) {
+            t.cell('Name', envName);
+            t.cell('Value', response.body.env[envName]);
 
-            envNames.forEach(function (envName) {
-                t.cell('Name', envName);
-                t.cell('Value', response.body.env[envName]);
-
-                t.newRow();
-            });
-
-            console.log();
-            console.log(t.toString());
+            t.newRow();
         });
-    });
-}
 
-function envGet(envName, options) {
-    getApp(options, function (error, app) {
-        if (error) return exit(error);
+        console.log();
+        console.log(t.toString());
+    } catch (error) {
+        exit(error);
+    }
+}
 
+async function envGet(envName, options) {
+    try {
+        const app = await getApp(options);
         if (!app) return exit(NO_APP_FOUND_ERROR_STRING);
 
-        const { adminFqdn, token, rejectUnauthorized } = requestOptions(options);
-
-        request.get(`https://${adminFqdn}/api/v1/apps/${app.id}?access_token=${token}`, { json: true, rejectUnauthorized }, function (error, response) {
-            if (error) return exit(error);
-            if (response.statusCode !== 200) return exit(`Failed to get app: ${requestError(response)}`);
+        const response = await createRequest('GET', `/api/v1/apps/${app.id}`, options);
+        if (response.statusCode !== 200) return exit(`Failed to get app: ${requestError(response)}`);
 
-            console.log(response.body.env[envName]);
-        });
-    });
+        console.log(response.body.env[envName]);
+    } catch (error) {
+        exit(error);
+    }
 }