cloudron 6.0.0 → 7.0.1

package/test/test.js

@@ -1,31 +1,28 @@
 #!/usr/bin/env node
 
-/* global it:false */
-/* global describe:false */
-/* global before:false */
-/* global after:false */
+import { after, before, describe, it } from 'mocha';
+import assert from 'node:assert/strict';
+import child_process from 'node:child_process';
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
 
-'use strict';
+import util from 'node:util';
 
-var child_process = require('child_process'),
-    crypto = require('crypto'),
-    expect = require('expect.js'),
-    fs = require('fs'),
-    path = require('path'),
-    safe = require('safetydance'),
-    util = require('util');
+import safe from '@cloudron/safetydance';
 
-var cloudron = process.env.CLOUDRON;
-var username = process.env.USERNAME;
-var password = process.env.PASSWORD;
-var applocation = 'test';
-var app;
+const cloudron = process.env.CLOUDRON;
+const username = process.env.USERNAME;
+const password = process.env.PASSWORD;
 
-var CLI = path.resolve(__dirname + '/../bin/cloudron');
+const applocation = 'test';
+let app;
+
+const CLI = path.resolve(import.meta.dirname + '/../bin/cloudron');
 
 function md5(file) {
-    var data = fs.readFileSync(file);
-    var hash = crypto.createHash('md5').update(data).digest('hex');
+    const data = fs.readFileSync(file);
+    const hash = crypto.createHash('md5').update(data).digest('hex');
     return hash;
 }
 
@@ -36,7 +33,7 @@ function cli(args, options) {
     args = args.map(function (e) { return e[0] === '"' ? e.slice(1, -1) : e; }); // remove the quotes
 
     try {
-        var cp = child_process.spawnSync(CLI, args, { stdio: [ options.stdin || 'pipe', options.stdout || 'pipe', 'pipe' ], encoding: options.encoding || 'utf8' });
+        const cp = child_process.spawnSync(CLI, args, { stdio: [ options.stdin || 'pipe', options.stdout || 'pipe', 'pipe' ], encoding: options.encoding || 'utf8' });
         return cp;
     } catch (e) {
         console.error(e);
@@ -44,250 +41,224 @@ function cli(args, options) {
     }
 }
 
-before(function (done) {
-    if (!process.env.CLOUDRON) return done(new Error('CLOUDRON env var not set'));
-    if (!process.env.USERNAME) return done(new Error('USERNAME env var not set'));
-    if (!process.env.PASSWORD) return done(new Error('PASSWORD env var not set'));
-
-    done();
+before(() => {
+    if (!process.env.CLOUDRON) throw new Error('CLOUDRON env const not set');
+    if (!process.env.USERNAME) throw new Error('USERNAME env const not set');
+    if (!process.env.PASSWORD) throw new Error('PASSWORD env const not set');
 });
 
-after(function (done) {
-    done();
-});
-
-describe('Login', function () {
-    it('can login', function (done) {
-        var out = cli(util.format('login %s --username %s --password %s', cloudron, username, password));
-
-        if (out.stdout.indexOf('Existing token still valid.') !== -1) return done();
+describe('Login', () => {
+    it('can login', () => {
+        const out = cli(util.format('login %s --username %s --password %s', cloudron, username, password));
 
-        expect(out.stdout.indexOf('Login successful')).to.not.be(-1);
+        if (out.stdout.indexOf('Existing token still valid.') !== -1) return;
 
-        done();
+        assert.ok(out.stdout.includes('Login successful'));
     });
 });
 
 describe('App install', function () {
-    this.timeout(60000);
-
-    it('can install app', function () {
+    it('can install app', () => {
         console.log('Installing app, this can take a while');
-        var out = cli('install --appstore-id com.hastebin.cloudronapp --location ' + applocation);
-        expect(out.stdout).to.contain('App is installed');
+        const out = cli('install --appstore-id com.hastebin.cloudronapp --location ' + applocation);
+        assert.ok(out.stdout.includes('App is installed'));
     });
 });
 
-describe('Inspect', function () {
-    it('can inspect app', function () {
-        var inspect = JSON.parse(cli('inspect').stdout);
+describe('Inspect', () => {
+    it('can inspect app', () => {
+        const inspect = JSON.parse(cli('inspect').stdout);
         app = inspect.apps.filter(function (a) { return a.location === applocation; })[0];
-        expect(app).to.not.be(null);
+        assert.notStrictEqual(app, undefined);
     });
 });
 
 describe('Exec', function () {
-    this.timeout(30000);
-
-    it('can execute a command and see stdout', function () {
-        var out = cli(util.format('exec --app %s -- ls -l /app/code', app.id));
-        expect(out.stdout).to.contain('total');
+    it('can execute a command and see stdout', () => {
+        const out = cli(util.format('exec --app %s -- ls -l /app/code', app.id));
+        assert.ok(out.stdout.includes('total'));
     });
 
-    it('can execute a command and see stderr', function () {
-        var out = cli(util.format('exec --app %s -- ls /blah', app.id));
-        expect(out.stderr).to.contain('ls: cannot access');
+    it('can execute a command and see stderr', () => {
+        const out = cli(util.format('exec --app %s -- ls /blah', app.id));
+        assert.ok(out.stderr.includes('ls: cannot access'));
     });
 
-    it('can get binary file in stdout', function (done) {
-        var outstream = fs.createWriteStream('/tmp/clitest.ls');
-        outstream.on('open', function () { // execSync underlying stream needs an fd which is available only after open event
-            cli(util.format('exec --app %s -- cat /bin/ls', app.id), { stdout: outstream, encoding: 'binary' });
-            var result = cli(util.format('exec --app %s md5sum /bin/ls', app.id));
+    it('can get binary file in stdout', async () => {
+        const outstream = fs.createWriteStream('/tmp/clitest.ls');
+        await new Promise((resolve) => outstream.on('open', resolve));
+
+        cli(util.format('exec --app %s -- cat /bin/ls', app.id), { stdout: outstream, encoding: 'binary' });
+        const result = cli(util.format('exec --app %s md5sum /bin/ls', app.id));
 
-            expect(result.output[1]).to.contain(md5('/tmp/clitest.ls'));
+        assert.ok(result.output[1].includes(md5('/tmp/clitest.ls')));
 
-            fs.unlinkSync('/tmp/clitest.ls');
-            done();
-        });
+        fs.unlinkSync('/tmp/clitest.ls');
     });
 
-    it('can pipe stdin to exec command', function (done) {
-        var randomBytes = require('crypto').randomBytes(256);
+    it('can pipe stdin to exec command', async () => {
+        const randomBytes = crypto.randomBytes(256);
         fs.writeFileSync('/tmp/randombytes', randomBytes);
-        var randomBytesMd5 = crypto.createHash('md5').update(randomBytes).digest('hex');
-
-        var instream = fs.createReadStream('/tmp/randombytes');
-        instream.on('open', function () {
-            cli(util.format('exec --app %s -- bash -c "cat - > /app/data/sauce"', app.id), { stdin: instream });
-            var out = cli(util.format('exec --app %s md5sum /app/data/sauce', app.id));
-            expect(out.stdout).to.contain(randomBytesMd5);
-            done();
-        });
+        const randomBytesMd5 = crypto.createHash('md5').update(randomBytes).digest('hex');
+
+        const instream = fs.createReadStream('/tmp/randombytes');
+        await new Promise((resolve) => instream.on('open', resolve));
+
+        cli(util.format('exec --app %s -- bash -c "cat - > /app/data/sauce"', app.id), { stdin: instream });
+        const out = cli(util.format('exec --app %s md5sum /app/data/sauce', app.id));
+        assert.ok(out.stdout.includes(randomBytesMd5));
     });
 });
 
 describe('Push', function () {
-    this.timeout(30000);
+    const RANDOM_FILE = '/tmp/randombytes';
 
-    var RANDOM_FILE = '/tmp/randombytes';
-
-    it('can push a binary file', function () {
-        var randomBytes = crypto.randomBytes(500);
+    it('can push a binary file', () => {
+        const randomBytes = crypto.randomBytes(500);
         fs.writeFileSync(RANDOM_FILE, randomBytes);
 
         cli(util.format('push --app %s %s /tmp/push1', app.id, RANDOM_FILE));
-        var out = cli(util.format('exec --app %s md5sum /tmp/push1', app.id));
-        expect(out.stdout).to.contain(md5(RANDOM_FILE));
+        const out = cli(util.format('exec --app %s md5sum /tmp/push1', app.id));
+        assert.ok(out.stdout.includes(md5(RANDOM_FILE)));
         fs.unlinkSync(RANDOM_FILE);
     });
 
-    it('can push to directory', function () {
-        var testFile = __dirname + '/test.js';
+    it('can push to directory', () => {
+        const testFile = import.meta.dirname + '/test.js';
         cli(util.format('push --app %s %s /tmp/', app.id, testFile));
-        var out = cli(util.format('exec --app %s md5sum /tmp/test.js', app.id));
-        expect(out.stdout).to.contain(md5(testFile));
+        const out = cli(util.format('exec --app %s md5sum /tmp/test.js', app.id));
+        assert.ok(out.stdout.includes(md5(testFile)));
     });
 
-    it('can push stdin', function (done) {
-        var randomBytes = crypto.randomBytes(500);
+    it('can push stdin', async () => {
+        const randomBytes = crypto.randomBytes(500);
         fs.writeFileSync(RANDOM_FILE, randomBytes);
 
-        var istream = fs.createReadStream(RANDOM_FILE);
-        istream.on('open', function () { // exec requires underlying fd
-            cli(util.format('push --app %s - /run/testcopy.js', app.id), { stdin: istream });
-            var out = cli(util.format('exec --app %s md5sum /run/testcopy.js', app.id));
-            expect(out.stdout).to.contain(md5(RANDOM_FILE));
-            fs.unlinkSync(RANDOM_FILE);
-            done();
-        });
+        const istream = fs.createReadStream(RANDOM_FILE);
+        await new Promise((resolve) => istream.on('open', resolve));
+
+        cli(util.format('push --app %s - /run/testcopy.js', app.id), { stdin: istream });
+        const out = cli(util.format('exec --app %s md5sum /run/testcopy.js', app.id));
+        assert.ok(out.stdout.includes(md5(RANDOM_FILE)));
+        fs.unlinkSync(RANDOM_FILE);
     });
 
-    it('can push a directory', function () {
-        var testDir = __dirname, testFile = __dirname + '/test.js';
+    it('can push a directory', () => {
+        const testDir = import.meta.dirname, testFile = import.meta.dirname + '/test.js';
         cli(util.format('push --app %s %s /run', app.id, testDir));
-        var out = cli(util.format('exec --app %s md5sum /run/' + path.basename(__dirname) + '/test.js', app.id));
-        expect(out.stdout).to.contain(md5(testFile));
+        const out = cli(util.format('exec --app %s md5sum /run/' + path.basename(import.meta.dirname) + '/test.js', app.id));
+        assert.ok(out.stdout.includes(md5(testFile)));
     });
 
-    it('can push a large file', function () {
+    it('can push a large file', () => {
         child_process.execSync('dd if=/dev/urandom of=' + RANDOM_FILE + ' bs=10M count=1');
         cli(util.format('push --app %s %s /tmp/push1', app.id, RANDOM_FILE));
-        var out = cli(util.format('exec --app %s md5sum /tmp/push1', app.id));
-        expect(out.stdout).to.contain(md5(RANDOM_FILE));
+        const out = cli(util.format('exec --app %s md5sum /tmp/push1', app.id));
+        assert.ok(out.stdout.includes(md5(RANDOM_FILE)));
         fs.unlinkSync(RANDOM_FILE);
     });
 });
 
 describe('Pull', function () {
-    this.timeout(30000);
+    const RANDOM_FILE = '/tmp/randombytes';
 
-    var RANDOM_FILE = '/tmp/randombytes';
-
-    before(function () {
-        var randomBytes = crypto.randomBytes(20000);
+    before(() => {
+        const randomBytes = crypto.randomBytes(20000);
         fs.writeFileSync(RANDOM_FILE, randomBytes);
 
         cli(util.format('push --app %s /tmp/randombytes /tmp/randombytes', app.id));
     });
 
-    after(function () {
+    after(() => {
         fs.unlinkSync(RANDOM_FILE);
     });
 
-    it('can pull a binary file', function () {
+    it('can pull a binary file', () => {
         cli(util.format('pull --app %s /tmp/randombytes /tmp/pullfiletest', app.id));
-        expect(md5('/tmp/pullfiletest')).to.be(md5('/tmp/randombytes'));
+        assert.strictEqual(md5('/tmp/pullfiletest'), md5('/tmp/randombytes'));
         fs.unlinkSync('/tmp/pullfiletest');
     });
 
-    it('can pull a directory', function () {
+    it('can pull a directory', () => {
         fs.rmSync('/tmp/pulldir', { recursive: true, force: true });
         safe.fs.mkdirSync('/tmp/pulldir');
         cli(util.format('pull --app %s /app/code/ /tmp/pulldir', app.id));
-        expect(fs.existsSync('/tmp/pulldir/README.md')).to.be.ok();
-        expect(fs.existsSync('/tmp/pulldir/static/robots.txt')).to.be.ok();
-        expect(fs.existsSync('/tmp/pulldir/.gitignore')).to.be.ok();
+        assert.ok(fs.existsSync('/tmp/pulldir/README.md'));
+        assert.ok(fs.existsSync('/tmp/pulldir/static/robots.txt'));
+        assert.ok(fs.existsSync('/tmp/pulldir/.gitignore'));
 
-        var result = cli(util.format('exec --app %s md5sum /app/code/node_modules/uglify-js/bin/uglifyjs', app.id));
-        expect(result.output[1]).to.contain(md5('/tmp/pulldir/node_modules/uglify-js/bin/uglifyjs'));
+        const result = cli(util.format('exec --app %s md5sum /app/code/node_modules/uglify-js/bin/uglifyjs', app.id));
+        assert.ok(result.output[1].includes(md5('/tmp/pulldir/node_modules/uglify-js/bin/uglifyjs')));
 
         fs.rmSync('/tmp/pulldir', { recursive: true, force: true });
     });
 
-    it('can pull to directory', function () {
+    it('can pull to directory', () => {
         safe.fs.unlinkSync('/tmp/pulledreadme.md');
         cli(util.format('pull --app %s /app/code/README.md /tmp/pulledreadme.md', app.id));
 
-        var result = cli(util.format('exec --app %s md5sum /app/code/README.md', app.id));
-        expect(result.output[1]).to.contain(md5('/tmp/pulledreadme.md'));
+        const result = cli(util.format('exec --app %s md5sum /app/code/README.md', app.id));
+        assert.ok(result.output[1].includes(md5('/tmp/pulledreadme.md')));
 
         fs.unlinkSync('/tmp/pulledreadme.md');
     });
 
-    it('can pull to stdout', function (done) {
+    it('can pull to stdout', async () => {
         safe.fs.unlinkSync('/tmp/pullfiletest');
-        var ostream = fs.createWriteStream('/tmp/pullfiletest');
-        ostream.on('open', function () { // exec requires underlying fd
-            cli(util.format('pull --app %s /tmp/randombytes -', app.id), { stdout: ostream });
-            expect(md5('/tmp/pullfiletest')).to.be(md5('/tmp/randombytes'));
-            fs.unlinkSync('/tmp/pullfiletest');
-            done();
-        });
+        const ostream = fs.createWriteStream('/tmp/pullfiletest');
+        await new Promise((resolve) => ostream.on('open', resolve));
+
+        cli(util.format('pull --app %s /tmp/randombytes -', app.id), { stdout: ostream });
+        assert.strictEqual(md5('/tmp/pullfiletest'), md5('/tmp/randombytes'));
+        fs.unlinkSync('/tmp/pullfiletest');
     });
 });
 
-describe('Status', function () {
-    it('can get status', function () {
-        var out = cli('status --app ' + app.id);
-        expect(out.stdout).to.contain('running');
+describe('Status', () => {
+    it('can get status', () => {
+        const out = cli('status --app ' + app.id);
+        assert.ok(out.stdout.includes('running'));
     });
 });
 
 describe('Backup', function () {
-    this.timeout(30000);
-
-    var backupId;
-
-    it('create succeeds', function () {
-        var out = cli('backup create --app ' + app.id);
-        expect(out.stdout).to.contain('App is backed up');
+    it('create succeeds', () => {
+        const out = cli('backup create --app ' + app.id);
+        assert.ok(out.stdout.includes('App is backed up'));
     });
 
-    it('list succeeds', function () {
-        var out = cli('backup list --app ' + app.id);
-        expect(out.stdout).to.contain(app.id);
+    it('list succeeds', () => {
+        const out = cli('backup list --app ' + app.id);
+        assert.ok(out.stdout.includes(app.id));
 
-        backupId = out.stdout.split('\n').reverse().filter(function (b) { return b; })[0].split(' ')[0];
+        /* backupId = */ out.stdout.split('\n').reverse().filter(function (b) { return b; })[0].split(' ')[0];
     });
 });
 
-describe('list apps', function () {
-    it('succeeds', function () {
-        var out = cli('list');
-        expect(out.stdout).to.contain(app.id);
+describe('list apps', () => {
+    it('succeeds', () => {
+        const out = cli('list');
+        assert.ok(out.stdout.includes(app.id));
     });
 });
 
-describe('app logs', function () {
-    it('succeeds', function () {
-        var out = cli('logs --app ' + app.id);
-        expect(out.stdout).to.contain('listening on');
+describe('app logs', () => {
+    it('succeeds', () => {
+        const out = cli('logs --app ' + app.id);
+        assert.ok(out.stdout.includes('listening on'));
     });
 });
 
 describe('Uninstall', function () {
-    this.timeout(30000);
-
-    it('can uninstall', function () {
-        var out = cli('uninstall --app ' + app.id);
-        expect(out.stdout).to.contain('successfully uninstalled');
+    it('can uninstall', () => {
+        const out = cli('uninstall --app ' + app.id);
+        assert.ok(out.stdout.includes('successfully uninstalled'));
     });
 });
 
-describe('Logout', function () {
-    it('can logout', function () {
-        var out = cli('logout');
-        expect(out.stdout).to.contain('Logged out');
+describe('Logout', () => {
+    it('can logout', () => {
+        const out = cli('logout');
+        assert.ok(out.stdout.includes('Logged out'));
     });
 });

package/src/superagent.js

@@ -1,225 +0,0 @@
-'use strict';
-
-exports = module.exports = {
-    head,
-    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 {
-    #boundary;
-    #redirectCount;
-    #retryCount;
-    #timer;
-    #body;
-    #okFunc;
-    #options;
-    #url;
-
-    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 = Buffer.alloc(0);
-        this.#redirectCount = 5;
-        this.#boundary = null; // multipart only
-    }
-
-    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);
-            });
-
-            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;
-    }
-
-    field(name, value) {
-        if (!this.#boundary) this.#boundary = '----WebKitFormBoundary' + Math.random().toString(36).substring(2);
-
-        const partHeader = Buffer.from(`--${this.#boundary}\r\nContent-Disposition: form-data; name="${name}"\r\n\r\n`, 'utf8');
-        const partData = Buffer.from(value, 'utf8');
-        this.#body = Buffer.concat([this.#body, partHeader, partData, Buffer.from('\r\n', 'utf8')]);
-
-        return this;
-    }
-
-    attach(name, filepathOrBuffer) { // this is only used in tests and thus simplistic
-        if (!this.#boundary) this.#boundary = '----WebKitFormBoundary' + Math.random().toString(36).substring(2);
-
-        const filename = Buffer.isBuffer(filepathOrBuffer) ? name : path.basename(filepathOrBuffer);
-        const partHeader = Buffer.from(`--${this.#boundary}\r\nContent-Disposition: form-data; name="${name}" filename="${filename}"\r\n\r\n`, 'utf8');
-        const partData = Buffer.isBuffer(filepathOrBuffer) ? filepathOrBuffer : fs.readFileSync(filepathOrBuffer);
-        this.#body = Buffer.concat([this.#body, partHeader, partData, Buffer.from('\r\n', 'utf8')]);
-
-        return this;
-    }
-
-    then(onFulfilled, onRejected) {
-        if (this.#boundary) {
-            const partTrailer = Buffer.from(`--${this.#boundary}--\r\n`, 'utf8');
-            this.#body = Buffer.concat([this.#body, partTrailer]);
-
-            this.#options.headers['content-type'] = `multipart/form-data; boundary=${this.#boundary}`;
-            this.#options.headers['content-length'] = this.#body.byteLength;
-        }
-
-        this._start().then(onFulfilled, onRejected);
-    }
-}
-
-function head(url) { return new Request('HEAD', url); }
-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); }