cloudron 5.12.0 → 5.13.0

package/bin/cloudron-appstore

@@ -54,6 +54,10 @@ program.command('upload')
     .option('-f, --force', 'Update existing version')
     .action(appstoreActions.upload);
 
+program.command('verify-manifest')
+    .description('Verify if manifest is ready to be upload/published')
+    .action(appstoreActions.verifyManifest);
+
 program.command('versions')
     .alias('list')
     .description('List published versions')

package/eslint.config.js

@@ -0,0 +1,21 @@
+const js = require('@eslint/js');
+const globals = require('globals');
+
+module.exports = [
+    js.configs.recommended,
+    {
+        files: ["**/*.js"],
+        languageOptions: {
+            globals: {
+                ...globals.node,
+            },
+            ecmaVersion: 13,
+            sourceType: "commonjs"
+        },
+        rules: {
+            semi: "error",
+            "prefer-const": "error"
+        }
+    }
+];
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cloudron",
-  "version": "5.12.0",
+  "version": "5.13.0",
   "license": "MIT",
   "description": "Cloudron Commandline Tool",
   "main": "main.js",
@@ -17,29 +17,25 @@
   },
   "author": "Cloudron Developers <support@cloudron.io>",
   "dependencies": {
-    "async": "^3.2.6",
     "cloudron-manifestformat": "^5.26.2",
-    "commander": "^12.1.0",
-    "debug": "^4.3.7",
+    "commander": "^13.1.0",
+    "debug": "^4.4.0",
     "easy-table": "^1.2.0",
     "ejs": "^3.1.10",
-    "eventsource": "^2.0.2",
+    "eventsource": "^3.0.5",
     "micromatch": "^4.0.8",
     "open": "^10.1.0",
-    "progress": "^2.0.3",
-    "progress-stream": "^2.0.0",
-    "readline-sync": "^1.4.10",
-    "safetydance": "^2.4.0",
-    "split2": "^4.2.0",
+    "safetydance": "^2.5.0",
     "superagent": "^10.1.1",
-    "tar-fs": "https://registry.npmjs.org/tar-fs/-/tar-fs-1.12.0.tgz",
-    "underscore": "^1.13.7"
+    "tar-fs": "^3.0.8"
   },
   "engines": {
     "node": ">= 18.x.x"
   },
   "devDependencies": {
+    "@eslint/js": "^9.20.0",
+    "eslint": "^9.20.1",
     "expect.js": "^0.3.1",
-    "mocha": "^10.8.2"
+    "mocha": "^11.1.0"
   }
 }

package/src/actions.js

@@ -4,25 +4,22 @@ const assert = require('assert'),
     config = require('./config.js'),
     ejs = require('ejs'),
     { exit, locateManifest } = require('./helper.js'),
-    EventSource = require('eventsource'),
+    { EventSource } = require('eventsource'),
     fs = require('fs'),
     https = require('https'),
+    LineStream = require('./line-stream.js'),
     manifestFormat = require('cloudron-manifestformat'),
     os = require('os'),
     path = require('path'),
-    ProgressBar = require('progress'),
-    ProgressStream = require('progress-stream'),
-    readlineSync = require('readline-sync'),
+    readline = require('./readline.js'),
     safe = require('safetydance'),
     spawn = require('child_process').spawn,
     semver = require('semver'),
-    split = require('split2'),
     superagent = require('superagent'),
     Table = require('easy-table'),
     tar = require('tar-fs'),
     timers = require('timers/promises'),
-    zlib = require('zlib'),
-    _ = require('underscore');
+    zlib = require('zlib');
 
 exports = module.exports = {
     list,
@@ -163,7 +160,7 @@ async function selectAppWithRepository(repository, options) {
 
     let index = -1;
     while (true) {
-        index = parseInt(readlineSync.question('Choose app [0-' + (matchingApps.length-1) + ']: ', {}), 10);
+        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');
         else break;
     }
@@ -334,7 +331,7 @@ async function authenticate(adminFqdn, username, password, options) {
     let totpToken;
 
     const { rejectUnauthorized, askForTotpToken } = options;
-    if (askForTotpToken) totpToken = readlineSync.question('2FA Token: ', {});
+    if (askForTotpToken) totpToken = await readline.question('2FA Token: ', {});
 
     const request = superagent.post(`https://${adminFqdn}/api/v1/auth/login`)
         .timeout(60000)
@@ -360,7 +357,7 @@ async function authenticate(adminFqdn, username, password, options) {
 }
 
 async function login(adminFqdn, localOptions, cmd) {
-    if (!adminFqdn) adminFqdn = readlineSync.question('Cloudron Domain (e.g. my.example.com): ', {});
+    if (!adminFqdn) adminFqdn = await readline.question('Cloudron Domain (e.g. my.example.com): ', {});
     if (!adminFqdn) return exit('');
 
     if (adminFqdn.indexOf('https://') === 0) adminFqdn = adminFqdn.slice('https://'.length);
@@ -389,8 +386,8 @@ async function login(adminFqdn, localOptions, cmd) {
     }
 
     if (!token) {
-        const username = options.username || readlineSync.question('Username: ', {});
-        const password = options.password || readlineSync.question('Password: ', { noEchoBack: true });
+        const username = options.username || await readline.question('Username: ', {});
+        const password = options.password || await readline.question('Password: ', { noEchoBack: true });
 
         const [error, result] = await safe(authenticate(adminFqdn, username, password, { rejectUnauthorized, askForTotpToken: false }));
         if (error) return exit(`Failed to login: ${error.message}`);
@@ -458,7 +455,7 @@ async function list(localOptions, cmd) {
         t.cell('Id', detailedApp.id);
         t.cell('Location', detailedApp.fqdn);
         t.cell('Manifest Id', (detailedApp.manifest.id || 'customapp') + '@' + detailedApp.manifest.version);
-        var prettyState;
+        let prettyState;
         if (detailedApp.installationState === 'installed') {
             prettyState = (detailedApp.debugMode ? 'debug' : detailedApp.runState);
         } else if (detailedApp.installationState === 'error') {
@@ -481,18 +478,19 @@ async function querySecondaryDomains(app, manifest, options) {
 
     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}"): `, {});
+        const input = await readline.question(`${manifest.httpPorts[env].description} (default: "${defaultDomain}"): `, {});
         secondaryDomains[env] = await selectDomain(input, options);
     }
     return secondaryDomains;
 }
 
-function queryPortBindings(app, manifest) {
+async function queryPortBindings(app, manifest) {
     const portBindings = {};
-    const allPorts = _.extend({}, manifest.tcpPorts, manifest.udpPorts);
+    const allPorts = Object.assign({}, manifest.tcpPorts, manifest.udpPorts);
+
     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): ', {});
+        const port = await readline.question(allPorts[env].description + ' (default ' + env + '=' + defaultPort + '. "x" to disable): ', {});
         if (port === '') {
             portBindings[env] = defaultPort;
         } else if (isNaN(parseInt(port, 10))) {
@@ -559,7 +557,7 @@ async function install(localOptions, cmd) {
             manifest.dockerImage = image;
         }
 
-        const location = options.location || readlineSync.question('Location: ', {});
+        const location = options.location || await readline.question('Location: ', {});
         if (!location) return exit('');
 
         const domainObject = await selectDomain(location, options);
@@ -604,10 +602,10 @@ async function install(localOptions, cmd) {
                     ports[tmp[0]] = parseInt(tmp[1], 10);
                 });
             } else {
-                ports = queryPortBindings(null /* existing app */, manifest);
+                ports = await queryPortBindings(null /* existing app */, manifest);
             }
         } else { // just put in defaults
-            const allPorts = _.extend({}, manifest.tcpPorts, manifest.udpPorts);
+            const allPorts = Object.assign({}, manifest.tcpPorts, manifest.udpPorts);
             for (const portName in allPorts) {
                 ports[portName] = allPorts[portName].defaultValue;
             }
@@ -669,7 +667,7 @@ async function setLocation(localOptions, cmd) {
         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}): `, { });
+        if (!options.location) options.location = await readline.question(`Enter new location (default: ${app.fqdn}): `, { });
         const location = options.location || app.subdomain;
 
         const domainObject = await selectDomain(location, options);
@@ -734,7 +732,7 @@ async function setLocation(localOptions, cmd) {
                     ports[tmp[0]] = parseInt(tmp[1], 10);
                 });
             } else {
-                ports = queryPortBindings(app, app.manifest);
+                ports = await queryPortBindings(app, app.manifest);
             }
 
             for (const port in ports) {
@@ -788,10 +786,10 @@ async function update(localOptions, cmd) {
 
         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 });
+            data = Object.assign(data, { manifest });
         } else {
             apiPath = `/api/v1/apps/${app.id}/update`;
-            data = _.extend(data, {
+            data = Object.assign(data, {
                 appStoreId: options.appstoreId || '', // note case change
                 manifest: manifest,
                 skipBackup: !options.backup,
@@ -954,13 +952,13 @@ async function logs(localOptions, cmd) {
 
     if (tail) {
         const url = `${apiPath}?access_token=${token}&lines=10&format=json`;
-        var es = new EventSource(url, { rejectUnauthorized }); // not sure why this is needed
+        const es = new EventSource(url, { rejectUnauthorized }); // not sure why this is needed
 
-        es.on('message', function (e) { // e { type, data, lastEventId }. lastEventId is the timestamp
+        es.addEventListener('message', function (e) { // e { type, data, lastEventId }. lastEventId is the timestamp
             logPrinter(JSON.parse(e.data));
         });
 
-        es.on('error', function (error) {
+        es.addEventListener('error', function (error) {
             if (error.status === 401) return exit('Please login first');
             if (error.status === 412) exit('Logs currently not available.');
             exit(error);
@@ -974,13 +972,13 @@ async function logs(localOptions, cmd) {
         });
         req.on('error', (error) => exit(`Pipe error: ${error.message}`));
 
-        const jsonStream = split((line) => JSON.parse(line));
-        jsonStream
-            .on('data', logPrinter)
+        const lineStream = new LineStream();
+        lineStream
+            .on('line', (line) => { logPrinter(JSON.parse(line)); } )
             .on('error', (error) => exit(`JSON parse error: ${error.message}`))
             .on('end', process.exit);
 
-        req.pipe(jsonStream);
+        req.pipe(lineStream);
     }
 }
 
@@ -1100,7 +1098,7 @@ async function backupList(localOptions, cmd) {
             return backup;
         }).sort(function (a, b) { return b.creationTime - a.creationTime; });
 
-        var t = new Table();
+        const t = new Table();
 
         response.body.backups.forEach(function (backup) {
             t.cell('Id', backup.id);
@@ -1242,9 +1240,9 @@ async function clone(localOptions, cmd) {
 
         if (!options.backup) return exit('Use --backup to specify the backup id');
 
-        const location = options.location || readlineSync.question('Cloned app location: ', {});
+        const location = options.location || await readline.question('Cloned app location: ', {});
         const secondaryDomains = await querySecondaryDomains(app, app.manifest, options);
-        const ports = queryPortBindings(app, app.manifest);
+        const ports = await queryPortBindings(app, app.manifest);
         const backupId = options.backup;
 
         const domainObject = await selectDomain(location, options);
@@ -1417,19 +1415,7 @@ function push(localDir, remote, localOptions, cmd) {
         if (local === '-') {
             localOptions._stdin = process.stdin;
         } else if (stat) {
-            const progress = new ProgressStream({ length: stat.size, time: 1000 });
-
-            localOptions._stdin = progress;
-            fs.createReadStream(local).pipe(progress);
-
-            const bar = new ProgressBar('Uploading [:bar] :percent: :etas', {
-                complete: '=',
-                incomplete: ' ',
-                width: 100,
-                total: stat.size
-            });
-
-            progress.on('progress', function (p) { bar.update(p.percentage / 100); /* bar.tick(p.transferred - bar.curr); */ });
+            localOptions._stdin = fs.createReadStream(local);
         } else {
             exit('local file ' + local + ' does not exist');
         }

package/src/appstore-actions.js

@@ -9,9 +9,8 @@ const assert = require('assert'),
     { exit, locateManifest } = require('./helper.js'),
     manifestFormat = require('cloudron-manifestformat'),
     path = require('path'),
-    readlineSync = require('readline-sync'),
+    readline = require('./readline.js'),
     safe = require('safetydance'),
-    semver = require('semver'),
     superagent = require('superagent'),
     Table = require('easy-table');
 
@@ -24,6 +23,7 @@ exports = module.exports = {
     upload,
     revoke,
     approve,
+    verifyManifest,
 
     notify
 };
@@ -71,8 +71,8 @@ async function authenticate(options) { // maybe we can use options.token to vali
         console.log(`${webDomain} login` + ` (If you do not have one, sign up at https://${webDomain}/console.html#/register)`);
     }
 
-    const email = options.email || readlineSync.question('Email: ', {});
-    const password = options.password || readlineSync.question('Password: ', { noEchoBack: true });
+    const email = options.email || await readline.question('Email: ', {});
+    const password = options.password || await readline.question('Password: ', { noEchoBack: true });
 
     config.setAppStoreToken(null);
 
@@ -80,7 +80,7 @@ async function authenticate(options) { // maybe we can use options.token to vali
     if (response.statusCode === 401 && response.body.message.indexOf('TOTP') !== -1) {
         if (response.body.message === 'TOTP token missing') console.log('A 2FA TOTP Token is required for this account.');
 
-        options.totpToken = readlineSync.question('2FA token: ', {});
+        options.totpToken = await readline.question('2FA token: ', {});
         options.email = email;
         options.password = password;
         options.hideBanner = true;
@@ -265,6 +265,36 @@ async function updateVersion(manifest, baseDir, options) {
     if (response.statusCode !== 204) throw new Error(`Failed to publish version: ${requestError(response)}`);
 }
 
+async function verifyManifest(localOptions, cmd) {
+    const options = cmd.optsWithGlobals();
+    // try to find the manifest of this project
+    const manifestFilePath = locateManifest();
+    if (!manifestFilePath) return exit(NO_MANIFEST_FOUND_ERROR_STRING);
+
+    const result = manifestFormat.parseFile(manifestFilePath);
+    if (result.error) return exit(result.error.message);
+
+    const manifest = result.manifest;
+
+    const sourceDir = path.dirname(manifestFilePath);
+    const appConfig = config.getAppConfig(sourceDir);
+
+    // image can be passed in options for buildbot
+    if (options.image) {
+        manifest.dockerImage = options.image;
+    } else {
+        manifest.dockerImage = appConfig.dockerImage;
+    }
+
+    if (!manifest.dockerImage) exit('No docker image found, run `cloudron build` first');
+
+    // ensure we remove the docker hub handle
+    if (manifest.dockerImage.indexOf('docker.io/') === 0) manifest.dockerImage = manifest.dockerImage.slice('docker.io/'.length);
+
+    const error = manifestFormat.checkAppstoreRequirements(manifest);
+    if (error) return exit(error);
+}
+
 async function upload(localOptions, cmd) {
     const options = cmd.optsWithGlobals();
     // try to find the manifest of this project
@@ -384,7 +414,7 @@ async function approve(localOptions, cmd) {
         if (safe.error) return exit(`Failed to get head of ${defaultBranch}: ${safe.error.message}`);
         latestTagSha = latestTagSha.trim();
 
-        if (defaultBranchSha !== latestTagSha) return exit(`Latest tag ${latestTag} does not match HEAD of ${defaultBranch}`);
+        if (defaultBranchSha !== latestTagSha) console.warn(`Latest tag ${latestTag} does not match HEAD of ${defaultBranch}`);
     }
 
     const response = await createRequest('POST', `/api/v1/developers/apps/${appstoreId}/versions/${version}/approve`, options);

package/src/backup-tools.js

@@ -11,7 +11,6 @@ exports = module.exports = {
 };
 
 const assert = require('assert'),
-    async = require('async'),
     crypto = require('crypto'),
     debug = require('debug')('cloudron-backup'),
     fs = require('fs'),
@@ -268,15 +267,16 @@ async function decryptDir(inDir, outDir, options) {
     const outDirAbs = path.resolve(process.cwd(), outDir);
 
     const tbd = [ '' ]; // only has paths relative to inDirAbs
-    async.whilst((done) => done(null, tbd.length !== 0), function iteratee(whilstCallback) {
+    while (true) {
         const cur = tbd.pop();
         const entries = fs.readdirSync(path.join(inDirAbs, cur), { withFileTypes: true });
-        async.eachSeries(entries, async function (entry) {
+
+        for (const entry of entries) {
             if (entry.isDirectory()) {
                 tbd.push(path.join(cur, entry.name));
-                return;
+                continue;
             } else if (!entry.isFile()) {
-                return;
+                continue;
             }
 
             const encryptedFilePath = path.join(cur, entry.name);
@@ -298,8 +298,10 @@ async function decryptDir(inDir, outDir, options) {
                 safe.fs.rmSync(outfile);
                 throw new Error(`Could not decrypt ${infile}: ${decryptError.message}`);
             }
-        }, whilstCallback);
-    }, exit);
+        }
+
+        if (tbd.length === 0) break;
+    }
 }
 
 async function decryptFilename(filePath, options) {

package/src/build-actions.js

@@ -11,14 +11,14 @@ exports = module.exports = {
 const assert = require('assert'),
     config = require('./config.js'),
     crypto = require('crypto'),
-    EventSource = require('eventsource'),
+    { EventSource } = require('eventsource'),
     execSync = require('child_process').execSync,
     exit = require('./helper.js').exit,
     fs = require('fs'),
     helper = require('./helper.js'),
     manifestFormat = require('cloudron-manifestformat'),
     micromatch = require('micromatch'),
-    readlineSync = require('readline-sync'),
+    readline = require('./readline.js'),
     superagent = require('superagent'),
     os = require('os'),
     path = require('path'),
@@ -34,7 +34,7 @@ function requestError(response) {
 }
 
 // analyzes options and merges with any existing build service config
-function getBuildServiceConfig(options) {
+async function resolveBuildServiceConfig(options) {
     const buildService = config.getBuildServiceConfig();
     if (!buildService.type) buildService.type = 'local'; // default
 
@@ -49,7 +49,7 @@ function getBuildServiceConfig(options) {
         if (typeof options.setBuildService === 'string') {
             url = options.setBuildService;
         } else {
-            url = readlineSync.question('Enter build service URL: ', { });
+            url = await readline.question('Enter build service URL: ', { });
         }
 
         if (url.indexOf('://') === -1) url = `https://${url}`;
@@ -66,11 +66,11 @@ function getBuildServiceConfig(options) {
 async function login(localOptions, cmd) {
     const options = cmd.optsWithGlobals();
 
-    const buildServiceConfig = getBuildServiceConfig(options);
+    const buildServiceConfig = await resolveBuildServiceConfig(options);
 
     console.log('Build Service login' + ` (${buildServiceConfig.url}):`);
 
-    const token = options.buildServiceToken || readlineSync.question('Token: ', {});
+    const token = options.buildServiceToken || await readline.question('Token: ', {});
 
     const response = await superagent.get(`${buildServiceConfig.url}/api/v1/profile`).query({ accessToken: token }).ok(() => true);
     if (response.statusCode === 401 || response.statusCode === 403) return exit(`Authentication error: ${requestError(response)}`);
@@ -93,7 +93,7 @@ async function followBuildLog(buildId, raw) {
     const es = new EventSource(`${tmp.href}api/v1/builds/${buildId}/logstream?accessToken=${config.getBuildServiceConfig().token}`);
     let prevId = null, prevWasStatus = false;
 
-    es.on('message', function (e) {
+    es.addEventListener('message', function (e) {
         if (raw) return console.dir(e);
 
         const data = safe.JSON.parse(e.data);
@@ -138,15 +138,15 @@ async function followBuildLog(buildId, raw) {
     });
 
     let didConnect = false;
-    es.once('open', () => didConnect = true);
+    es.addEventListener('open', () => didConnect = true, { once: true });
 
     return new Promise((resolve, reject) => {
-        es.once('error', function (error) { // server close or network error or some interruption
+        es.addEventListener('error', function (error) { // server close or network error or some interruption
             if (raw) console.dir(error);
 
             es.close();
             if (didConnect) resolve(); else reject(new Error('Failed to connect'));
-        });
+        }, { once: true });
     });
 }
 
@@ -315,14 +315,14 @@ async function build(localOptions, cmd) {
     const sourceDir = path.dirname(manifestFilePath);
 
     const appConfig = config.getAppConfig(sourceDir);
-    const buildServiceConfig = getBuildServiceConfig(options);
+    const buildServiceConfig = await resolveBuildServiceConfig(options);
 
     let repository = appConfig.repository;
     if (!repository || options.setRepository) {
         if (typeof options.setRepository === 'string') {
             repository = options.setRepository;
         } else {
-            repository = readlineSync.question(`Enter docker repository (e.g registry/username/${manifest.id || path.basename(sourceDir)}): `, {});
+            repository = await readline.question(`Enter docker repository (e.g registry/username/${manifest.id || path.basename(sourceDir)}): `, {});
             if (!repository) exit('No repository provided');
             console.log();
         }
@@ -374,7 +374,7 @@ async function push(localOptions, cmd) {
         tag = options.tag;
     }
 
-    const buildServiceConfig = getBuildServiceConfig(options);
+    const buildServiceConfig = await resolveBuildServiceConfig(options);
 
     const response = await superagent.post(`${buildServiceConfig.url}/api/v1/builds/${options.id}/push`)
         .query({ accessToken: buildServiceConfig.token })

package/src/line-stream.js

@@ -0,0 +1,30 @@
+'use strict';
+
+const { Transform } = require('stream');
+
+class LineStream extends Transform {
+    constructor(options) {
+      super();
+      this._buffer = '';
+    }
+
+    _transform(chunk, encoding, callback) {
+        this._buffer += chunk.toString('utf8');
+
+        const lines = this._buffer.split('\n');
+        this._buffer = lines.pop(); // maybe incomplete line
+
+        for (const line of lines) {
+            this.emit('line', line);
+        }
+
+        callback();
+    }
+
+    _flush(callback) {
+      if (this._buffer) this.emit('line', this.buff_bufferer);
+      callback();
+    }
+}
+
+exports = module.exports = LineStream;

package/src/readline.js

@@ -0,0 +1,21 @@
+'use strict';
+
+exports = module.exports = {
+    question
+};
+
+const readline = require('node:readline/promises'),
+    { Writable } = require('node:stream');
+
+async function question(query, options) {
+    const output = options.noEchoBack
+        ? new Writable({ write: function (chunk, encoding, callback) { callback(); } })
+        : process.stdout;
+    process.stdin.setRawMode(options.noEchoBack); // raw mode gives each keypress as opposd to line based cooked mode
+    const rl = readline.createInterface({ input: process.stdin, output });
+    if (options.noEchoBack) process.stdout.write(query);
+    const answer = await rl.question(query, options);
+    rl.close();
+    if (options.noEchoBack) process.stdout.write('\n');
+    return answer;
+}

package/src/superagent.js

@@ -0,0 +1,198 @@
+'use strict';
+
+exports = module.exports = {
+    get,
+    put,
+    post,
+    patch,
+    del,
+    options,
+    request
+};
+
+// IMPORTANT: do not require box code here . This is used by migration scripts
+const assert = require('assert'),
+    consumers = require('node:stream/consumers'),
+    debug = require('debug')('box:superagent'),
+    fs = require('fs'),
+    http = require('http'),
+    https = require('https'),
+    path = require('path'),
+    safe = require('safetydance');
+
+class Request {
+    constructor(method, url) {
+        assert.strictEqual(typeof url, 'string');
+
+        this.url = new URL(url);
+        this.options = {
+            method,
+            headers: {},
+            signal: null // set for timeouts
+        };
+        this.okFunc = ({ status }) => status >=200 && status <= 299;
+        this.timer = { timeout: 0, id: null, controller: null };
+        this.retryCount = 0;
+        this.body = null;
+        this.redirectCount = 5;
+    }
+
+    async _handleResponse(url, response) {
+        // const contentLength = response.headers['content-length'];
+        // if (!contentLength || contentLength > 5*1024*1024*1024) throw new Error(`Response size unknown or too large: ${contentLength}`);
+        const [consumeError, data] = await safe(consumers.buffer(response)); // have to drain response
+        if (consumeError) throw new Error(`Error consuming body stream: ${consumeError.message}`);
+        if (!response.complete) throw new Error('Incomplete response');
+        const contentType = response.headers['content-type'];
+
+        const result = {
+            url: new URL(response.headers['location'] || '', url),
+            status: response.statusCode,
+            headers: response.headers,
+            body: null,
+            text: null
+        };
+
+        if (contentType?.includes('application/json')) {
+            result.text = data.toString('utf8');
+            if (data.byteLength !== 0) result.body = safe.JSON.parse(result.text) || {};
+        } else if (contentType?.includes('application/x-www-form-urlencoded')) {
+            result.text = data.toString('utf8');
+            const searchParams = new URLSearchParams(data);
+            result.body = Object.fromEntries(searchParams.entries());
+        } else if (!contentType || contentType.startsWith('text/')) {
+            result.body = data;
+            result.text = result.body.toString('utf8');
+        } else {
+            result.body = data;
+            result.text = `<binary data (${data.byteLength} bytes)>`;
+        }
+
+        return result;
+    }
+
+    async _makeRequest(url) {
+        return new Promise((resolve, reject) => {
+            const proto = url.protocol === 'https:' ? https : http;
+            const request = proto.request(url, this.options); // ClientRequest
+
+            request.on('error', reject); // network error, dns error
+            request.on('response', async (response) => {
+                const [error, result] = await safe(this._handleResponse(url, response));
+                if (error) reject(error); else resolve(result);
+            });
+
+            if (this.body) request.write(this.body);
+
+            request.end();
+        });
+    }
+
+    async _start() {
+        let error;
+
+        for (let i = 0; i < this.retryCount+1; i++) {
+            if (this.timer.timeout) this.timer.id = setTimeout(() => this.timer.controller.abort(), this.timer.timeout);
+            debug(`${this.options.method} ${this.url.toString()}` + (i ? ` try ${i+1}` : ''));
+
+            let response, url = this.url;
+            for (let redirects = 0; redirects < this.redirectCount+1; redirects++) {
+                [error, response] = await safe(this._makeRequest(url));
+                if (error || (response.status < 300 || response.status > 399) || (this.options.method !== 'GET')) break;
+                url = response.url; // follow
+            }
+
+            if (!error && !this.okFunc({ status: response.status })) {
+                error = new Error(`${response.status} ${http.STATUS_CODES[response.status]}`);
+                Object.assign(error, response);
+            }
+
+            if (error) debug(`${this.options.method} ${this.url.toString()} ${error.message}`);
+            if (this.timer.timeout) clearTimeout(this.timer.id);
+            if (!error) return response;
+        }
+
+        throw error;
+    }
+
+    set(name, value) {
+        this.options.headers[name.toLowerCase()] = value;
+        return this;
+    }
+
+    query(data) {
+        Object.entries(data).forEach(([key, value]) => this.url.searchParams.append(key, value));
+        return this;
+    }
+
+    redirects(count) {
+        this.redirectCount = count;
+        return this;
+    }
+
+    send(data) {
+        const contentType = this.options.headers['content-type'];
+        if (!contentType || contentType === 'application/json') {
+            this.options.headers['content-type'] = 'application/json';
+            this.body = Buffer.from(JSON.stringify(data), 'utf8');
+            this.options.headers['content-length'] = this.body.byteLength;
+        } else if (contentType === 'application/x-www-form-urlencoded') {
+            this.body = Buffer.from((new URLSearchParams(data)).toString(), 'utf8');
+            this.options.headers['content-length'] = this.body.byteLength;
+        }
+        return this;
+    }
+
+    timeout(msecs) {
+        this.timer.controller = new AbortController();
+        this.timer.timeout = msecs;
+        this.options.signal = this.timer.controller.signal;
+        return this;
+    }
+
+    retry(count) {
+        this.retryCount = Math.max(0, count);
+        return this;
+    }
+
+    ok(func) {
+        this.okFunc = func;
+        return this;
+    }
+
+    disableTLSCerts() {
+        this.options.rejectUnauthorized = true;
+        return this;
+    }
+
+    auth(username, password) {
+        this.set('Authorization', 'Basic ' + btoa(`${username}:${password}`));
+        return this;
+    }
+
+    attach(name, filepath) { // this is only used in tests and thus simplistic
+        const boundary = '----WebKitFormBoundary' + Math.random().toString(36).substring(2);
+
+        const partHeader = Buffer.from(`--${boundary}\r\nContent-Disposition: form-data; name="${name}" filename="${path.basename(filepath)}"\r\n\r\n`, 'utf8');
+        const partData = fs.readFileSync(filepath);
+        const partTrailer = Buffer.from(`\r\n--${boundary}--\r\n`, 'utf8');
+        this.body = Buffer.concat([partHeader, partData, partTrailer]);
+
+        this.options.headers['content-type'] = `multipart/form-data; boundary=${boundary}`;
+        this.options.headers['content-length'] = this.body.byteLength;
+
+        return this;
+    }
+
+    then(onFulfilled, onRejected) {
+        this._start().then(onFulfilled, onRejected);
+    }
+}
+
+function get(url) { return new Request('GET', url); }
+function put(url) { return new Request('PUT', url); }
+function post(url) { return new Request('POST', url); }
+function patch(url) { return new Request('PATCH', url); }
+function del(url) { return new Request('DELETE', url); }
+function options(url) { return new Request('OPTIONS', url); }
+function request(method, url) { return new Request(method, url); }

package/test/test.js

@@ -32,7 +32,7 @@ function md5(file) {
 function cli(args, options) {
     // https://github.com/nodejs/node-v0.x-archive/issues/9265
     options = options || { };
-    args = util.isArray(args) ? args : args.match(/[^\s"]+|"([^"]+)"/g);
+    args = Array.isArray(args) ? args : args.match(/[^\s"]+|"([^"]+)"/g);
     args = args.map(function (e) { return e[0] === '"' ? e.slice(1, -1) : e; }); // remove the quotes
 
     try {