cloudron 6.0.0 → 7.0.1

package/src/actions.js

@@ -1,59 +1,25 @@
-'use strict';
-
-const assert = require('assert'),
-    config = require('./config.js'),
-    ejs = require('ejs'),
-    { exit, locateManifest } = require('./helper.js'),
-    { EventSource } = require('eventsource'),
-    fs = require('fs'),
-    https = require('https'),
-    manifestFormat = require('@cloudron/manifest-format'),
-    os = require('os'),
-    path = require('path'),
-    readline = require('./readline.js'),
-    safe = require('safetydance'),
-    spawn = require('child_process').spawn,
-    semver = require('semver'),
-    superagent = require('@cloudron/superagent'),
-    Table = require('easy-table'),
-    tar = require('tar-fs'),
-    timers = require('timers/promises'),
-    zlib = require('zlib');
-
-exports = module.exports = {
-    list,
-    login,
-    logout,
-    open,
-    install,
-    setLocation,
-    debug,
-    update,
-    uninstall,
-    logs,
-    exec,
-    status,
-    inspect,
-    pull,
-    push,
-    restart,
-    start,
-    stop,
-    repair,
-    init,
-    restore,
-    importApp,
-    exportApp,
-    clone,
-    backupCreate,
-    backupList,
-    cancel,
-
-    envGet,
-    envSet,
-    envList,
-    envUnset
-};
+import assert from 'assert';
+import { dockerignoreMatcher } from './build-actions.js';
+import * as config from './config.js';
+import ejs from 'ejs';
+import { exit, locateManifest, performOidcLogin } from './helper.js';
+import { EventSource } from 'eventsource';
+import fs from 'fs';
+import https from 'https';
+import manifestFormat from '@cloudron/manifest-format';
+import os from 'os';
+import path from 'path';
+import * as readline from './readline.js';
+import safe from '@cloudron/safetydance';
+import { spawn } from 'child_process';
+import semver from 'semver';
+import stream from 'stream/promises';
+import superagent from '@cloudron/superagent';
+import Table from 'easy-table';
+import tar from 'tar-fs';
+import timers from 'timers/promises';
+import zlib from 'zlib';
+import open from 'open';
 
 const NO_APP_FOUND_ERROR_STRING = 'Could not determine app. Use --app to specify the app\n';
 
@@ -158,7 +124,7 @@ async function selectAppWithRepository(repository, options) {
         console.log('[%s]\t%s', index, app.fqdn);
     });
 
-    let index = -1;
+    let index;
     while (true) {
         index = parseInt(await readline.question('Choose app [0-' + (matchingApps.length-1) + ']: ', {}), 10);
         if (isNaN(index) || index < 0 || index > matchingApps.length-1) console.log('Invalid selection');
@@ -180,7 +146,7 @@ async function getApp(options) {
         if (!manifestFilePath) throw new Error(NO_APP_FOUND_ERROR_STRING);
 
         const sourceDir = path.dirname(manifestFilePath);
-        const appConfig = config.getAppConfig(sourceDir);
+        const appConfig = config.getAppBuildConfig(sourceDir);
 
         if (!appConfig.repository) throw new Error(NO_APP_FOUND_ERROR_STRING);
 
@@ -300,7 +266,7 @@ async function stopApp(app, options) {
     const response = await request.send({});
     if (response.status !== 202) throw `Failed to stop app: ${requestError(response)}`;
 
-    await waitForTask(response.body.taskId, options);
+    return response.body.taskId;
 }
 
 async function startApp(app, options) {
@@ -311,7 +277,7 @@ async function startApp(app, options) {
     const response = await request.send({});
     if (response.status !== 202) throw `Failed to start app: ${requestError(response)}`;
 
-    await waitForTask(response.body.taskId, options);
+    return response.body.taskId;
 }
 
 async function restartApp(app, options) {
@@ -322,7 +288,7 @@ async function restartApp(app, options) {
     const response = await request.send({});
     if (response.status !== 202) throw `Failed to restart app: ${requestError(response)}`;
 
-    await waitForTask(response.body.taskId, options);
+    return response.body.taskId;
 }
 
 async function authenticate(adminFqdn, username, password, options) {
@@ -389,12 +355,24 @@ async function login(adminFqdn, localOptions, cmd) {
     }
 
     if (!token) {
-        const username = options.username || await readline.question('Username: ', {});
-        const password = options.password || await readline.question('Password: ', { noEchoBack: true });
+        // oidc cli login is possible from 9.1 on
+        const request = superagent.get(`https://${adminFqdn}/api/v1/cloudron/status`).ok(() => true);
+        if (!rejectUnauthorized) request.disableTLSCerts();
 
-        const [error, result] = await safe(authenticate(adminFqdn, username, password, { rejectUnauthorized, askForTotpToken: false }));
-        if (error) return exit(`Failed to login: ${error.message}`);
-        token = result;
+        const [error, response] = await safe(request);
+        if (error) return exit(error);
+        if (response.status !== 200) return exit(`Failed to get cloudron status: ${requestError(response)}`);
+
+        if (semver.gte(response.body.version, '9.1.0')) {
+            token = await performOidcLogin(adminFqdn, { rejectUnauthorized });
+        } else {
+            const username = options.username || await readline.question('Username: ', {});
+            const password = options.password || await readline.question('Password: ', { noEchoBack: true });
+
+            const [authError, result] = await safe(authenticate(adminFqdn, username, password, { rejectUnauthorized, askForTotpToken: false }));
+            if (authError) return exit(`Failed to login: ${authError.message}`);
+            token = result;
+        }
     }
 
     config.setActive(adminFqdn);
@@ -404,6 +382,8 @@ async function login(adminFqdn, localOptions, cmd) {
     config.set('cloudrons.default', adminFqdn);
 
     console.log('Login successful.');
+
+    process.exit(0);
 }
 
 function logout() {
@@ -413,15 +393,14 @@ function logout() {
     console.log('Logged out.');
 }
 
-async function open(localOptions, cmd) {
+async function openApp(localOptions, cmd) {
     const options = cmd.optsWithGlobals();
     const [error, app] = await safe(getApp(options));
     if (error) return exit(error);
 
     if (!app) return exit(NO_APP_FOUND_ERROR_STRING);
 
-    // pure esm module
-    (await import('open')).default(`https://${app.fqdn}`);
+    open(`https://${app.fqdn}`);
 }
 
 async function list(localOptions, cmd) {
@@ -448,12 +427,12 @@ async function list(localOptions, cmd) {
     responses.forEach(function (result) {
         if (result.status !== 'fulfilled') return exit(`Failed to list app: ${requestError(result.value)}`);
 
-        const response = result.value;
+        const appResponse = result.value;
 
-        if (response.status !== 200) return exit(`Failed to list app: ${requestError(response)}`);
-        response.body.location = response.body.location || response.body.subdomain; // LEGACY support
+        if (appResponse.status !== 200) return exit(`Failed to list app: ${requestError(appResponse)}`);
+        appResponse.body.location = appResponse.body.location || appResponse.body.subdomain; // LEGACY support
 
-        const detailedApp = response.body;
+        const detailedApp = appResponse.body;
 
         t.cell('Id', detailedApp.id);
         t.cell('Location', detailedApp.fqdn);
@@ -578,13 +557,32 @@ async function install(localOptions, cmd) {
         const result = await getManifest(options.appstoreId || '');
         const { manifest, manifestFilePath } = result;
 
+        let sourceArchiveFilePath = null; // will be set if we need to send a tarball
+
         if (!manifest.dockerImage) { // not a manifest from appstore
             const sourceDir = path.dirname(manifestFilePath);
-            const image = options.image || config.getAppConfig(sourceDir).dockerImage;
+            const image = options.image || config.getAppBuildConfig(sourceDir).dockerImage;
 
-            if (!image) return exit('No image found, please run `cloudron build` first or specify using --image');
+            if (!image) {
+                console.log('No build detected. This package will be built on the server.');
 
-            manifest.dockerImage = image;
+                const dockerignoreFilePath = path.join(sourceDir, '.dockerignore');
+                const ignoreMatcher = dockerignoreMatcher(dockerignoreFilePath);
+
+                const tarStream = tar.pack(sourceDir, {
+                    ignore: function (name) {
+                        return ignoreMatcher(name.slice(sourceDir.length + 1)); // make name as relative path
+                    }
+                });
+
+                sourceArchiveFilePath = path.join(os.tmpdir(), `cloudron-source-${Date.now()}.tar`);
+                const sourceArchiveStream = fs.createWriteStream(sourceArchiveFilePath);
+
+                const [tarError] = await safe(stream.pipeline(tarStream, sourceArchiveStream));
+                if (tarError) return exit(`Could not create source archive: ${tarError.message}`);
+            } else {
+                manifest.dockerImage = image;
+            }
         }
 
         const location = options.location || await readline.question('Location: ', {});
@@ -689,14 +687,43 @@ async function install(localOptions, cmd) {
             if (!data.icon) return exit(`Could not read icon: ${iconFilename} message: ${safe.error.message}`);
         }
 
-        const request = createRequest('POST', '/api/v1/apps/install', options);
-        const response = await request.send(data);
+        const request = createRequest('POST', '/api/v1/apps', options);
+
+        let response;
+        if (sourceArchiveFilePath) {
+            // Send as multipart form-data with source archive
+            request.field('appStoreId', data.appStoreId);
+            request.field('manifest', JSON.stringify(data.manifest));
+            request.field('location', data.location);
+            request.field('subdomain', data.subdomain);
+            request.field('domain', data.domain);
+            request.field('secondaryDomains', JSON.stringify(data.secondaryDomains));
+            request.field('aliasDomains', JSON.stringify(data.aliasDomains));
+            request.field('ports', JSON.stringify(data.ports));
+            request.field('accessRestriction', JSON.stringify(data.accessRestriction));
+            request.field('memoryLimit', String(data.memoryLimit));
+            request.field('env', JSON.stringify(data.env));
+            if (data.sso !== undefined) request.field('sso', String(data.sso));
+            if (data.debugMode) request.field('debugMode', JSON.stringify(data.debugMode));
+            if (data.icon) request.field('icon', data.icon);
+            request.attach('sourceArchive', sourceArchiveFilePath);
+
+            response = await request;
+
+            // Clean up temp file
+            safe.fs.unlinkSync(sourceArchiveFilePath);
+        } else {
+            response = await request.send(data);
+        }
+
         if (response.status !== 202) return exit(`Failed to install app: ${requestError(response)}`);
 
         const appId = response.body.id;
 
         console.log('App is being installed.');
 
+        if (!options.wait) return;
+
         await waitForFinishInstallation(appId, response.body.taskId, options);
         console.log('\n\nApp is installed.');
     } catch (error) {
@@ -766,30 +793,32 @@ async function setLocation(localOptions, cmd) {
 
         // port bindings
         if (options.portBindings) {
-            let ports;
+            let userPorts;
             // ask the user for port values if the ports are different in the app and the manifest
             if (typeof options.portBindings === 'string') {
-                ports = {};
+                userPorts = {};
                 options.portBindings.split(',').forEach(function (kv) {
                     const tmp = kv.split('=');
                     if (isNaN(parseInt(tmp[1], 10))) return; // disable the port
-                    ports[tmp[0]] = parseInt(tmp[1], 10);
+                    userPorts[tmp[0]] = parseInt(tmp[1], 10);
                 });
             } else {
-                ports = await queryPortBindings(app, app.manifest);
+                userPorts = await queryPortBindings(app, app.manifest);
             }
 
-            for (const port in ports) {
-                console.log('%s: %s', port, ports[port]);
+            for (const port in userPorts) {
+                console.log('%s: %s', port, userPorts[port]);
             }
 
-            data.ports = ports;
+            data.ports = userPorts;
         }
 
         const request = createRequest('POST', `/api/v1/apps/${app.id}/configure/location`, options);
         const response = await request.send(data);
         if (response.status !== 202) return exit(`Failed to configure app: ${requestError(response)}`);
 
+        if (!options.wait) return;
+
         await waitForTask(response.body.taskId, options);
         await waitForHealthy(app.id, options);
         console.log('\n\nApp configured');
@@ -803,20 +832,37 @@ async function update(localOptions, cmd) {
 
     try {
         const app = await getApp(options);
-        if (!app) return exit(NO_APP_FOUND_ERROR_STRING);
 
         const result = await getManifest(options.appstoreId || '');
         const { manifest, manifestFilePath } = result;
 
         let data = {};
+        let sourceArchiveFilePath = null; // will be set if we need to send a tarball
 
         if (!manifest.dockerImage) { // not a manifest from appstore
             const sourceDir = path.dirname(manifestFilePath);
-            const image = options.image || config.getAppConfig(sourceDir).dockerImage;
+            const image = options.image || config.getAppBuildConfig(sourceDir).dockerImage;
 
-            if (!image) return exit('No image found, please run `cloudron build` first or use --image');
+            if (!image) {
+                console.log('No docker image detected. Creating source archive from this folder.');
 
-            manifest.dockerImage = image;
+                const dockerignoreFilePath = path.join(sourceDir, '.dockerignore');
+                const ignoreMatcher = dockerignoreMatcher(dockerignoreFilePath);
+
+                const tarStream = tar.pack(sourceDir, {
+                    ignore: function (name) {
+                        return ignoreMatcher(name.slice(sourceDir.length + 1)); // make name as relative path
+                    }
+                });
+
+                sourceArchiveFilePath = path.join(os.tmpdir(), `cloudron-source-${Date.now()}.tar`);
+                const sourceArchiveStream = fs.createWriteStream(sourceArchiveFilePath);
+
+                const [tarError] = await safe(stream.pipeline(tarStream, sourceArchiveStream));
+                if (tarError) return exit(`Could not create source archive: ${tarError.message}`);
+            } else {
+                manifest.dockerImage = image;
+            }
 
             if (manifest.icon) {
                 let iconFilename = manifest.icon.slice(0, 7) === 'file://' ? manifest.icon.slice(7) : manifest.icon;
@@ -826,24 +872,32 @@ async function update(localOptions, cmd) {
             }
         }
 
-        let apiPath;
+        data = Object.assign(data, {
+            appStoreId: options.appstoreId || '', // note case change
+            manifest: manifest,
+            skipBackup: !options.backup,
+            skipNotification: true,
+            force: true // permit downgrades
+        });
+
+        const request = createRequest('POST', `/api/v1/apps/${app.id}/update`, options);
+
+        let response;
+        if (sourceArchiveFilePath) {
+            request.field('appStoreId', data.appStoreId);
+            request.field('manifest', JSON.stringify(data.manifest));
+            request.field('skipBackup', String(data.skipBackup));
+            request.field('skipNotification', String(data.skipNotification));
+            request.field('force', String(data.force));
+            if (data.icon) request.field('icon', data.icon);
+            request.attach('sourceArchive', sourceArchiveFilePath);
 
-        if (app.error && (app.error.installationState === 'pending_install')) { // install had failed. call repair to re-install
-            apiPath = `/api/v1/apps/${app.id}/repair`;
-            data = Object.assign(data, { manifest });
+            response = await request;
+
+            safe.fs.unlinkSync(sourceArchiveFilePath);
         } else {
-            apiPath = `/api/v1/apps/${app.id}/update`;
-            data = Object.assign(data, {
-                appStoreId: options.appstoreId || '', // note case change
-                manifest: manifest,
-                skipBackup: !options.backup,
-                skipNotification: true,
-                force: true // permit downgrades
-            });
+            response = await request.send(data);
         }
-
-        const request = createRequest('POST', apiPath, options);
-        const response = await request.send(data);
         if (response.status !== 202) return exit(`Failed to update app: ${requestError(response)}`);
 
         process.stdout.write('\n => ' + 'Waiting for app to be updated ');
@@ -851,12 +905,11 @@ async function update(localOptions, cmd) {
         await waitForFinishInstallation(app.id, response.body.taskId, options);
         console.log('\n\nApp is updated.');
     } catch (error) {
-        console.log(error);
-        exit(`\n\nApp update error: ${error.message}`);
+        exit(`\nApp update error: ${error.message}`);
     }
 }
 
-async function debug(args, localOptions, cmd) {
+async function debugApp(args, localOptions, cmd) {
     try {
         const options = cmd.optsWithGlobals();
         const app = await getApp(options);
@@ -875,6 +928,8 @@ async function debug(args, localOptions, cmd) {
         const response = await request.send(data);
         if (response.status !== 202) return exit(`Failed to set debug mode: ${requestError(response)}`);
 
+        if (!options.wait) return;
+
         await waitForTask(response.body.taskId, options);
 
         const memoryLimit = options.limitMemory ? 0 : -1;
@@ -909,6 +964,8 @@ async function repair(localOptions, cmd) {
         const response = await request.send(data);
         if (response.status !== 202) return exit(`Failed to set repair mode: ${requestError(response)}`);
 
+        if (!options.wait) return;
+
         process.stdout.write('\n => ' + 'Waiting for app to be repaired ');
 
         await waitForFinishInstallation(app.id, response.body.taskId, options);
@@ -943,6 +1000,8 @@ async function uninstall(localOptions, cmd) {
         const response = await request.send({});
         if (response.status !== 202) return exit(`Failed to uninstall app: ${requestError(response)}`);
 
+        if (!options.wait) return;
+
         process.stdout.write('\n => ' + 'Waiting for app to be uninstalled ');
 
         await waitForTask(response.body.taskId, options);
@@ -1068,7 +1127,9 @@ async function restart(localOptions, cmd) {
         const options = cmd.optsWithGlobals();
         const app = await getApp(options);
         if (!app) return exit(NO_APP_FOUND_ERROR_STRING);
-        await restartApp(app, options);
+        const taskId = await restartApp(app, options);
+        if (!options.wait) return;
+        await waitForTask(taskId, options);
         await waitForHealthy(app.id, options);
         console.log('\n\nApp restarted');
     } catch (error) {
@@ -1081,7 +1142,9 @@ async function start(localOptions, cmd) {
         const options = cmd.optsWithGlobals();
         const app = await getApp(options);
         if (!app) return exit(NO_APP_FOUND_ERROR_STRING);
-        await startApp(app, options);
+        const taskId = await startApp(app, options);
+        if (!options.wait) return;
+        await waitForTask(taskId, options);
         await waitForHealthy(app.id, options);
         console.log('\n\nApp started');
     } catch (error) {
@@ -1094,7 +1157,9 @@ async function stop(localOptions, cmd) {
         const options = cmd.optsWithGlobals();
         const app = await getApp(options);
         if (!app) return exit(NO_APP_FOUND_ERROR_STRING);
-        await stopApp(app, options);
+        const taskId = await stopApp(app, options);
+        if (!options.wait) return;
+        await waitForTask(taskId, options);
         console.log('\n\nApp stopped');
     } catch (error) {
         exit(error);
@@ -1120,6 +1185,8 @@ async function backupCreate(localOptions, cmd) {
         const response = await request.send({ backupSiteId });
         if (response.status !== 202) return exit(`Failed to start backup: ${requestError(response)}`);
 
+        if (!options.wait) return;
+
         // 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');
@@ -1319,21 +1386,21 @@ async function clone(localOptions, cmd) {
 }
 
 // taken from docker-modem
-function demuxStream(stream, stdout, stderr) {
+function demuxStream(inputStream, stdout, stderr) {
     let header = null;
 
-    stream.on('readable', function() {
-        header = header || stream.read(8);
+    inputStream.on('readable', function() {
+        header = header || inputStream.read(8);
         while (header !== null) {
             const type = header.readUInt8(0);
-            const payload = stream.read(header.readUInt32BE(4));
+            const payload = inputStream.read(header.readUInt32BE(4));
             if (payload === null) break;
             if (type == 2) {
                 stderr.write(payload);
             } else {
                 stdout.write(payload);
             }
-            header = stream.read(8);
+            header = inputStream.read(8);
         }
     });
 }
@@ -1344,7 +1411,7 @@ 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
-async function exec(args, localOptions, cmd) {
+async function execApp(args, localOptions, cmd) {
     let stdin = localOptions._stdin || process.stdin; // hack for 'push', 'pull' to reuse this function
     const stdout = localOptions._stdout || process.stdout; // hack for 'push', 'pull' to reuse this function
 
@@ -1378,12 +1445,12 @@ async function exec(args, localOptions, cmd) {
         process.exit(response2.body.exitCode);
     }
 
-    const { adminFqdn, token, rejectUnauthorized } = requestOptions(cmd.optsWithGlobals());
+    const { adminFqdn, token: reqToken, rejectUnauthorized } = requestOptions(cmd.optsWithGlobals());
 
     const searchParams = new URLSearchParams({
         rows: stdout.rows || 24,
         columns: stdout.columns || 80,
-        access_token: token,
+        access_token: reqToken,
         tty
     });
 
@@ -1448,7 +1515,7 @@ async function exec(args, localOptions, cmd) {
     req.end(); // this makes the request
 }
 
-function push(localDir, remote, localOptions, cmd) {
+function pushApp(localDir, remote, localOptions, cmd) {
     // deal with paths prefixed with ~
     const local = localDir.replace(/^~(?=$|\/|\\)/, os.homedir());
     const stat = fs.existsSync(path.resolve(local)) ? fs.lstatSync(local) : null;
@@ -1461,7 +1528,7 @@ function push(localDir, remote, localOptions, cmd) {
             return tarzip.stdout;
         };
 
-        exec(['tar', 'zxvf', '-', '-C', remote], localOptions, cmd);
+        execApp(['tar', 'zxvf', '-', '-C', remote], localOptions, cmd);
     } else {
         if (local === '-') {
             localOptions._stdin = process.stdin;
@@ -1477,7 +1544,7 @@ function push(localDir, remote, localOptions, cmd) {
             remote = remote + '/' + path.basename(local); // do not use path.join as we want this to be a UNIX path
         }
 
-        exec(['bash', '-c', `cat - > "${remote}"`], localOptions, cmd);
+        execApp(['bash', '-c', `cat - > "${remote}"`], localOptions, cmd);
     }
 }
 
@@ -1489,7 +1556,7 @@ function pull(remote, local, localOptions, cmd) {
         unzip.pipe(untar);
         localOptions._stdout = unzip;
 
-        exec(['tar', 'zcf', '-', '-C', remote, '.'], localOptions, cmd);
+        execApp(['tar', 'zcf', '-', '-C', remote, '.'], localOptions, cmd);
     } else {
         if (fs.existsSync(local) && fs.lstatSync(local).isDirectory()) {
             local = path.join(local, path.basename(remote));
@@ -1502,7 +1569,7 @@ function pull(remote, local, localOptions, cmd) {
 
         localOptions._stdout.on('error', function (error) { exit('Error pulling', error); });
 
-        exec(['cat', remote], localOptions, cmd);
+        execApp(['cat', remote], localOptions, cmd);
     }
 }
 
@@ -1513,10 +1580,10 @@ function init(localOptions, cmd) {
 
     const manifestTemplateFilename = options.appstore ? 'CloudronManifest.appstore.json.ejs' : 'CloudronManifest.json.ejs';
 
-    const manifestTemplate = fs.readFileSync(path.join(__dirname, 'templates/', manifestTemplateFilename), 'utf8');
-    const dockerfileTemplate = fs.readFileSync(path.join(__dirname, 'templates/', 'Dockerfile.ejs'), 'utf8');
-    const dockerignoreTemplate = fs.readFileSync(path.join(__dirname, 'templates/', 'dockerignore.ejs'), 'utf8');
-    const startShTemplate = fs.readFileSync(path.join(__dirname, 'templates/', 'start.sh.ejs'), 'utf8');
+    const manifestTemplate = fs.readFileSync(path.join(import.meta.dirname, 'templates/', manifestTemplateFilename), 'utf8');
+    const dockerfileTemplate = fs.readFileSync(path.join(import.meta.dirname, 'templates/', 'Dockerfile.ejs'), 'utf8');
+    const dockerignoreTemplate = fs.readFileSync(path.join(import.meta.dirname, 'templates/', 'dockerignore.ejs'), 'utf8');
+    const startShTemplate = fs.readFileSync(path.join(import.meta.dirname, 'templates/', 'start.sh.ejs'), 'utf8');
 
     const data = {
         version: '0.1.0',
@@ -1549,7 +1616,7 @@ function init(localOptions, cmd) {
         fs.chmodSync('start.sh', 0o0775);
     }
 
-    fs.copyFileSync(path.join(__dirname, 'templates/', 'logo.png'), 'logo.png');
+    fs.copyFileSync(path.join(import.meta.dirname, 'templates/', 'logo.png'), 'logo.png');
 
     if (options.appstore) {
         if (!fs.existsSync('.gitignore')) fs.writeFileSync('.gitignore', 'node_modules/\n', 'utf8');
@@ -1658,3 +1725,38 @@ async function envGet(envName, localOptions, cmd) {
         exit(error);
     }
 }
+
+export default {
+    list,
+    login,
+    logout,
+    open: openApp,
+    install,
+    setLocation,
+    debug: debugApp,
+    update,
+    uninstall,
+    logs,
+    exec: execApp,
+    status,
+    inspect,
+    pull,
+    push: pushApp,
+    restart,
+    start,
+    stop,
+    repair,
+    init,
+    restore,
+    importApp,
+    exportApp,
+    clone,
+    backupCreate,
+    backupList,
+    cancel,
+
+    envGet,
+    envSet,
+    envList,
+    envUnset
+};