hfs 0.26.8 → 0.26.9

package/src/const.js

@@ -0,0 +1,83 @@
+"use strict";
+// This file is part of HFS - Copyright 2021-2022, Massimo Melina <a@rejetto.com> - License https://www.gnu.org/licenses/gpl-3.0.txt
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APP_PATH = exports.IS_WINDOWS = exports.UNAUTHORIZED = exports.FORBIDDEN = exports.NO_CONTENT = exports.METHOD_NOT_ALLOWED = exports.PLUGINS_PUB_URI = exports.API_URI = exports.ADMIN_URI = exports.FRONTEND_URI = exports.SPECIAL_URI = exports.COMPATIBLE_API_VERSION = exports.API_VERSION = exports.SESSION_DURATION = exports.DAY = exports.VERSION = exports.BUILD_TIMESTAMP = exports.HFS_STARTED = exports.ORIGINAL_CWD = exports.DEV = exports.argv = void 0;
+const minimist_1 = __importDefault(require("minimist"));
+const fs = __importStar(require("fs"));
+const os_1 = require("os");
+const fs_1 = require("fs");
+const path_1 = require("path");
+exports.argv = (0, minimist_1.default)(process.argv.slice(2));
+exports.DEV = process.env.DEV || exports.argv.dev ? 'DEV' : '';
+exports.ORIGINAL_CWD = process.cwd();
+exports.HFS_STARTED = new Date();
+const PKG_PATH = (0, path_1.join)(__dirname, '..', 'package.json');
+exports.BUILD_TIMESTAMP = fs.statSync(PKG_PATH).mtime.toISOString();
+const pkg = JSON.parse(fs.readFileSync(PKG_PATH, 'utf8'));
+exports.VERSION = pkg.version;
+exports.DAY = 86400000;
+exports.SESSION_DURATION = exports.DAY;
+exports.API_VERSION = 4.1; // array.$width
+exports.COMPATIBLE_API_VERSION = 1; // while changes in the api are not breaking, this number stays the same, otherwise is made equal to API_VERSION
+exports.SPECIAL_URI = '/~/';
+exports.FRONTEND_URI = exports.SPECIAL_URI + 'frontend/';
+exports.ADMIN_URI = exports.SPECIAL_URI + 'admin/';
+exports.API_URI = exports.SPECIAL_URI + 'api/';
+exports.PLUGINS_PUB_URI = exports.SPECIAL_URI + 'plugins/';
+exports.METHOD_NOT_ALLOWED = 405;
+exports.NO_CONTENT = 204;
+exports.FORBIDDEN = 403;
+exports.UNAUTHORIZED = 401;
+exports.IS_WINDOWS = process.platform === 'win32';
+const IS_BINARY = !(0, path_1.basename)(process.argv0).includes('node'); // this won't be node if pkg was used
+exports.APP_PATH = (0, path_1.dirname)(IS_BINARY ? process.argv0 : __dirname);
+// we want this to be the first stuff to be printed, then we print it in this module, that is executed at the beginning
+if (exports.DEV)
+    console.clear();
+else
+    console.debug = () => { };
+console.log(`HFS ~ HTTP File Server - Copyright 2021-2022, Massimo Melina <a@rejetto.com>`);
+console.log(`License https://www.gnu.org/licenses/gpl-3.0.txt`);
+console.log('started', exports.HFS_STARTED.toLocaleString(), exports.DEV);
+console.log('version', exports.VERSION || '-');
+console.log('build', exports.BUILD_TIMESTAMP || '-');
+if (exports.argv.cwd)
+    process.chdir(exports.argv.cwd);
+else if (!process.argv0.endsWith('.exe')) { // still considering whether to use this behavior with Windows users, who may be less accustomed to it
+    const dir = (0, path_1.join)((0, os_1.homedir)(), '.hfs');
+    try {
+        (0, fs_1.mkdirSync)(dir);
+    }
+    catch (e) {
+        if (e.code !== 'EEXIST')
+            console.error(e);
+    }
+    process.chdir(dir);
+}
+console.log('cwd', process.cwd());

package/src/crypt.js

@@ -0,0 +1,21 @@
+"use strict";
+// This file is part of HFS - Copyright 2021-2022, Massimo Melina <a@rejetto.com> - License https://www.gnu.org/licenses/gpl-3.0.txt
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyPassword = exports.hashPassword = void 0;
+// simple wrapper
+// @ts-ignore
+const pbkdf2_1 = require("./pbkdf2");
+const assert_1 = __importDefault(require("assert"));
+async function hashPassword(s) {
+    return 'p2:' + await (0, pbkdf2_1.pbkdf2)(s);
+}
+exports.hashPassword = hashPassword;
+async function verifyPassword(hashed, given) {
+    const i = hashed.indexOf(':');
+    (0, assert_1.default)(i > 0, 'bad hashed');
+    return await (0, pbkdf2_1.pbkdf2Verify)(hashed.slice(i + 1), given); // for the time being we totally ignore the "method" part
+}
+exports.verifyPassword = verifyPassword;

package/src/debounceAsync.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// like lodash.debounce, but also avoids async invocations to overlap
+function debounceAsync(callback, wait = 100, { leading = false, maxWait = Infinity } = {}) {
+    let started = 0; // latest callback invocation
+    let runningCallback; // latest callback invocation result
+    let runningDebouncer; // latest wrapper invocation
+    let waitingSince = 0; // we are delaying invocation since
+    let whoIsWaiting; // args' array object identifies the pending instance, and incidentally stores args
+    const interceptingWrapper = (...args) => runningDebouncer = debouncer.apply(null, args);
+    return Object.assign(interceptingWrapper, {
+        cancel: () => {
+            waitingSince = 0;
+            whoIsWaiting = undefined;
+        },
+        flush: () => runningCallback !== null && runningCallback !== void 0 ? runningCallback : exec(),
+    });
+    async function debouncer(...args) {
+        if (runningCallback)
+            return await runningCallback;
+        whoIsWaiting = args;
+        waitingSince || (waitingSince = Date.now());
+        const waitingCap = maxWait - (Date.now() - (waitingSince || started));
+        const waitFor = Math.min(waitingCap, leading ? wait - (Date.now() - started) : wait);
+        if (waitFor > 0)
+            await new Promise(resolve => setTimeout(resolve, waitFor));
+        if (!whoIsWaiting) // canceled
+            return void (waitingSince = 0);
+        if (whoIsWaiting !== args) // another fresher call is waiting
+            return runningDebouncer;
+        return await exec();
+    }
+    async function exec() {
+        if (!whoIsWaiting)
+            return;
+        waitingSince = 0;
+        started = Date.now();
+        try {
+            runningCallback = callback.apply(null, whoIsWaiting);
+            return await runningCallback;
+        }
+        finally {
+            whoIsWaiting = undefined;
+            runningCallback = undefined;
+        }
+    }
+}
+exports.default = debounceAsync;

package/src/events.js

@@ -0,0 +1,9 @@
+"use strict";
+// This file is part of HFS - Copyright 2021-2022, Massimo Melina <a@rejetto.com> - License https://www.gnu.org/licenses/gpl-3.0.txt
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const events_1 = __importDefault(require("events"));
+// app-wide events
+exports.default = new events_1.default();

package/src/frontEndApis.js

@@ -0,0 +1,38 @@
+"use strict";
+// This file is part of HFS - Copyright 2021-2022, Massimo Melina <a@rejetto.com> - License https://www.gnu.org/licenses/gpl-3.0.txt
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.frontEndApis = void 0;
+const api_file_list_1 = require("./api.file_list");
+const api_auth = __importStar(require("./api.auth"));
+const config_1 = require("./config");
+const customHeader = (0, config_1.defineConfig)('custom_header');
+exports.frontEndApis = {
+    file_list: api_file_list_1.file_list,
+    ...api_auth,
+    config() {
+        return Object.fromEntries([customHeader].map(x => [x.key(), x.get()]));
+    }
+};

package/src/github.js

@@ -0,0 +1,102 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.searchPlugins = exports.getFolder2repo = exports.readOnlinePlugin = exports.getRepoInfo = exports.downloadPlugin = void 0;
+const events_1 = __importDefault(require("./events"));
+const misc_1 = require("./misc");
+const plugins_1 = require("./plugins");
+const apiMiddleware_1 = require("./apiMiddleware");
+const lodash_1 = __importDefault(require("lodash"));
+const DIST_ROOT = 'dist/';
+const downloading = {};
+function downloadProgress(id, status) {
+    if (status === undefined)
+        delete downloading[id];
+    else
+        downloading[id] = status;
+    events_1.default.emit('pluginDownload_' + id, status);
+}
+async function downloadPlugin(repo, branch = '', overwrite) {
+    if (downloading[repo])
+        return new apiMiddleware_1.ApiError(409, "already downloading");
+    downloadProgress(repo, true);
+    const rec = await getRepoInfo(repo);
+    if (!branch)
+        branch = rec.default_branch;
+    const short = repo.split('/')[1]; // second part, repo without the owner
+    const folder2repo = getFolder2repo();
+    const folder = overwrite ? lodash_1.default.findKey(folder2repo, x => x === repo) // use existing folder
+        : short in folder2repo ? repo.replace('/', '-') // longer form only if another plugin is using short form
+            : short;
+    const installPath = plugins_1.PATH + '/' + folder;
+    const GITHUB_ZIP_ROOT = short + '-' + branch; // GitHub puts everything within this folder
+    const rootWithinZip = GITHUB_ZIP_ROOT + '/' + DIST_ROOT;
+    const stream = await (0, misc_1.httpsStream)(`https://github.com/${repo}/archive/refs/heads/${branch}.zip`);
+    await (0, misc_1.unzip)(stream, path => path.startsWith(rootWithinZip) && installPath + '/' + path.slice(rootWithinZip.length));
+    downloadProgress(repo, undefined);
+    await (0, plugins_1.rescan)(); // workaround: for some reason, operations are not triggering the rescan of the watched folder. Let's invoke it.
+    return folder;
+}
+exports.downloadPlugin = downloadPlugin;
+function getRepoInfo(id) {
+    return apiGithub('repos/' + id);
+}
+exports.getRepoInfo = getRepoInfo;
+async function readOnlinePlugin(repoInfo, branch = '') {
+    const url = `https://raw.githubusercontent.com/${repoInfo.full_name}/${branch || repoInfo.default_branch}/${DIST_ROOT}plugin.js`;
+    const res = await (0, misc_1.httpsString)(url);
+    if (!res.ok)
+        throw res.statusCode;
+    const pl = (0, plugins_1.parsePluginSource)(repoInfo.full_name, res.body); // use 'repo' as 'id' client-side
+    pl.branch = branch || undefined;
+    return pl;
+}
+exports.readOnlinePlugin = readOnlinePlugin;
+function getFolder2repo() {
+    const ret = Object.fromEntries((0, plugins_1.getAvailablePlugins)().map(x => [x.id, x.repo]));
+    Object.assign(ret, Object.fromEntries((0, plugins_1.mapPlugins)(x => [x.id, x.getData().repo])));
+    return ret;
+}
+exports.getFolder2repo = getFolder2repo;
+async function apiGithub(uri) {
+    const res = await (0, misc_1.httpsString)('https://api.github.com/' + uri, {
+        headers: {
+            'User-Agent': 'HFS',
+            Accept: 'application/vnd.github.v3+json',
+        }
+    });
+    if (!res.ok)
+        throw res.statusCode;
+    return JSON.parse(res.body);
+}
+async function* searchPlugins(text) {
+    var _a;
+    const res = await apiGithub('search/repositories?q=topic:hfs-plugin+' + encodeURI(text));
+    for (const it of res.items) {
+        const repo = it.full_name;
+        let pl = await readOnlinePlugin(it);
+        if (!pl.apiRequired)
+            continue; // mandatory field
+        if (pl.badApi) { // we try other branches (starting with 'api')
+            const branches = (await apiGithub('repos/' + it.full_name + '/branches'))
+                .map((x) => x.name).filter((x) => x.startsWith('api')).sort();
+            for (const branch of branches) {
+                pl = await readOnlinePlugin(it, branch);
+                if (!pl.apiRequired)
+                    pl.badApi = '-';
+                if (!pl.badApi)
+                    break;
+            }
+        }
+        if (pl.badApi)
+            continue;
+        Object.assign(pl, {
+            downloading: downloading[repo],
+            license: (_a = it.license) === null || _a === void 0 ? void 0 : _a.spdx_id,
+        }, lodash_1.default.pick(it, ['pushed_at', 'stargazers_count']));
+        yield pl;
+    }
+}
+exports.searchPlugins = searchPlugins;

package/src/index.js

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+"use strict";
+// This file is part of HFS - Copyright 2021-2022, Massimo Melina <a@rejetto.com> - License https://www.gnu.org/licenses/gpl-3.0.txt
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.app = void 0;
+const koa_1 = __importDefault(require("koa"));
+const koa_mount_1 = __importDefault(require("koa-mount"));
+const apiMiddleware_1 = require("./apiMiddleware");
+const const_1 = require("./const");
+const frontEndApis_1 = require("./frontEndApis");
+const log_1 = require("./log");
+const plugins_1 = require("./plugins");
+const throttler_1 = require("./throttler");
+const middlewares_1 = require("./middlewares");
+require("./listen");
+require("./commands");
+const adminApis_1 = require("./adminApis");
+const config_1 = require("./config");
+const assert_1 = require("assert");
+const lodash_1 = __importDefault(require("lodash"));
+const misc_1 = require("./misc");
+(0, assert_1.ok)(lodash_1.default.intersection(Object.keys(frontEndApis_1.frontEndApis), Object.keys(adminApis_1.adminApis)).length === 0); // they share same endpoints
+const keys = ((_a = process.env.COOKIE_SIGN_KEYS) === null || _a === void 0 ? void 0 : _a.split(',')) || [(0, misc_1.randomId)(30)];
+exports.app = new koa_1.default({ keys });
+exports.app.use(middlewares_1.someSecurity)
+    .use((0, middlewares_1.sessions)(exports.app))
+    .use(middlewares_1.prepareState)
+    .use(middlewares_1.headRequests)
+    .use((0, log_1.log)())
+    .use(throttler_1.throttler)
+    .use(middlewares_1.gzipper)
+    .use(middlewares_1.paramsDecoder)
+    .use((0, plugins_1.pluginsMiddleware)())
+    .use((0, koa_mount_1.default)(const_1.API_URI, (0, apiMiddleware_1.apiMiddleware)({ ...frontEndApis_1.frontEndApis, ...adminApis_1.adminApis })))
+    .use(middlewares_1.serveGuiAndSharedFiles)
+    .on('error', errorHandler);
+function errorHandler(err) {
+    const { code } = err;
+    if (const_1.DEV && code === 'ENOENT' && err.path.endsWith('sockjs-node'))
+        return; // spam out dev stuff
+    if (code === 'ECANCELED' || code === 'ECONNRESET' || code === 'ECONNABORTED' || code === 'EPIPE')
+        return; // someone interrupted, don't care
+    console.error('server error', err);
+}
+process.on('uncaughtException', err => {
+    if (err.syscall !== 'watch')
+        console.error(err);
+});
+(0, config_1.defineConfig)('proxies', 0).sub(n => {
+    exports.app.proxy = n > 0;
+    exports.app.maxIpsCount = n;
+});

package/src/listen.js

@@ -0,0 +1,235 @@
+"use strict";
+// This file is part of HFS - Copyright 2021-2022, Massimo Melina <a@rejetto.com> - License https://www.gnu.org/licenses/gpl-3.0.txt
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUrls = exports.getStatus = exports.httpsPortCfg = exports.openAdmin = exports.portCfg = void 0;
+const http = __importStar(require("http"));
+const config_1 = require("./config");
+const index_1 = require("./index");
+const https = __importStar(require("https"));
+const watchLoad_1 = require("./watchLoad");
+const os_1 = require("os");
+const connections_1 = require("./connections");
+const open_1 = __importDefault(require("open"));
+const misc_1 = require("./misc");
+const const_1 = require("./const");
+const find_process_1 = __importDefault(require("find-process"));
+const perm_1 = require("./perm");
+const lodash_1 = __importDefault(require("lodash"));
+let httpSrv;
+let httpsSrv;
+const openBrowserAtStart = (0, config_1.defineConfig)('open_browser_at_start', !const_1.DEV);
+exports.portCfg = (0, config_1.defineConfig)('port', 80);
+exports.portCfg.sub(async (port) => {
+    while (!index_1.app)
+        await (0, misc_1.wait)(100);
+    stopServer(httpSrv).then();
+    httpSrv = Object.assign(http.createServer(index_1.app.callback()), { name: 'http' });
+    port = await startServer(httpSrv, { port });
+    if (!port)
+        return;
+    httpSrv.on('connection', connections_1.newConnection);
+    printUrls(port, 'http');
+    if (openBrowserAtStart.get())
+        openAdmin();
+});
+function openAdmin() {
+    for (const srv of [httpSrv, httpsSrv]) {
+        const a = srv.address();
+        if (!a || typeof a === 'string')
+            continue;
+        const baseUrl = srv.name + '://localhost:' + a.port;
+        (0, open_1.default)(baseUrl + const_1.ADMIN_URI, { wait: true }).catch(e => {
+            console.debug(String(e));
+            console.warn("cannot launch browser on this machine >PLEASE< open your browser and reach one of these (you may need a different address)", ...Object.values(getUrls()).flat().map(x => '\n - ' + x + const_1.ADMIN_URI));
+            if (!(0, perm_1.anyAccountCanLoginAdmin)())
+                console.log(`HINT: you can enter command: create-admin YOUR_PASSWORD`);
+        });
+        return true;
+    }
+    console.log("openAdmin failed");
+}
+exports.openAdmin = openAdmin;
+const considerHttps = (0, misc_1.debounceAsync)(async () => {
+    var _a, _b;
+    stopServer(httpsSrv).then();
+    let port = exports.httpsPortCfg.get();
+    try {
+        while (!index_1.app)
+            await (0, misc_1.wait)(100);
+        httpsSrv = Object.assign(https.createServer(port < 0 ? {} : { key: httpsOptions.private_key, cert: httpsOptions.cert }, index_1.app.callback()), { name: 'https', error: undefined });
+        if (port >= 0) {
+            const namesForOutput = { cert: 'certificate', private_key: 'private key' };
+            const missing = (_a = httpsNeeds.find(x => !x.get())) === null || _a === void 0 ? void 0 : _a.key();
+            if (missing)
+                return httpsSrv.error = "missing " + namesForOutput[missing];
+            const cantRead = (_b = httpsNeeds.find(x => !httpsOptions[x.key()])) === null || _b === void 0 ? void 0 : _b.key();
+            if (cantRead)
+                return httpsSrv.error = "cannot read " + namesForOutput[cantRead];
+        }
+    }
+    catch (e) {
+        httpsSrv.error = "bad private key or certificate";
+        console.log("failed to create https server: check your private key and certificate", String(e));
+        return;
+    }
+    port = await startServer(httpsSrv, { port });
+    if (!port)
+        return;
+    httpsSrv.on('connection', connections_1.newConnection);
+    printUrls(port, 'https');
+});
+const cert = (0, config_1.defineConfig)('cert');
+const privateKey = (0, config_1.defineConfig)('private_key');
+const httpsNeeds = [cert, privateKey];
+const httpsOptions = { cert: '', private_key: '' };
+for (const cfg of httpsNeeds) {
+    let unwatch;
+    cfg.sub(async (v) => {
+        unwatch === null || unwatch === void 0 ? void 0 : unwatch();
+        const k = cfg.key();
+        httpsOptions[k] = v;
+        if (!v || v.includes('\n'))
+            return considerHttps();
+        // v is a path
+        httpsOptions[k] = '';
+        unwatch = (0, watchLoad_1.watchLoad)(v, data => {
+            httpsOptions[k] = data;
+            considerHttps();
+        }).unwatch;
+        await considerHttps();
+    });
+}
+exports.httpsPortCfg = (0, config_1.defineConfig)('https_port', -1);
+exports.httpsPortCfg.sub(considerHttps);
+function startServer(srv, { port, host }) {
+    return new Promise(async (resolve) => {
+        try {
+            if (port < 0 || !host && !await testIpV4()) // !host means ipV4+6, and if v4 port alone is busy we won't be notified of the failure, so we'll first test it on its own
+                return resolve(0);
+            port = await listen(host);
+            if (port)
+                console.log(srv.name, "serving on", host || "any network", ':', port);
+            resolve(port);
+        }
+        catch (e) {
+            srv.error = String(e);
+            console.error(srv.name, "couldn't listen on port", port, srv.error);
+            resolve(0);
+        }
+    });
+    async function testIpV4() {
+        const res = await listen('0.0.0.0');
+        await new Promise(res => srv.close(res));
+        return res > 0;
+    }
+    function listen(host) {
+        return new Promise(async (resolve, reject) => {
+            srv.listen({ port, host }, () => {
+                const ad = srv.address();
+                if (!ad)
+                    return reject('no address');
+                if (typeof ad === 'string') {
+                    srv.close();
+                    return reject('type of socket not supported');
+                }
+                resolve(ad.port);
+            }).on('error', async (e) => {
+                srv.error = String(e);
+                srv.busy = undefined;
+                const { code } = e;
+                if (code === 'EADDRINUSE') {
+                    srv.busy = (0, find_process_1.default)('port', port).then(res => { var _a; return ((_a = res === null || res === void 0 ? void 0 : res[0]) === null || _a === void 0 ? void 0 : _a.name) || ''; }, () => '');
+                    srv.error = `port ${port} busy: ${await srv.busy || "unknown process"}`;
+                }
+                console.error(srv.name, srv.error);
+                const k = (srv === httpSrv ? exports.portCfg : exports.httpsPortCfg).key();
+                console.log(` >> try specifying a different port, enter this command: config ${k} 8011`);
+                resolve(0);
+            });
+        });
+    }
+}
+function stopServer(srv) {
+    return new Promise(resolve => {
+        if (!(srv === null || srv === void 0 ? void 0 : srv.listening))
+            return resolve(null);
+        const ad = srv.address();
+        if (ad && typeof ad !== 'string')
+            console.log("stopped port", ad.port);
+        srv.close(err => {
+            if (err && err.code !== 'ERR_SERVER_NOT_RUNNING')
+                console.debug("failed to stop server", String(err));
+            resolve(err);
+        });
+    });
+}
+function getStatus() {
+    return {
+        httpSrv,
+        httpsSrv,
+    };
+}
+exports.getStatus = getStatus;
+const ignore = /^(lo|.*loopback.*|virtualbox.*|.*\(wsl\).*|llw\d|awdl\d|utun\d|anpi\d)$/i; // avoid giving too much information
+function getUrls() {
+    return Object.fromEntries((0, misc_1.onlyTruthy)([httpSrv, httpsSrv].map(srv => {
+        var _a;
+        if (!(srv === null || srv === void 0 ? void 0 : srv.listening))
+            return false;
+        const port = (_a = srv === null || srv === void 0 ? void 0 : srv.address()) === null || _a === void 0 ? void 0 : _a.port;
+        const appendPort = port === (srv.name === 'https' ? 443 : 80) ? '' : ':' + port;
+        const urls = (0, misc_1.onlyTruthy)(Object.entries((0, os_1.networkInterfaces)()).map(([name, nets]) => nets && !ignore.test(name) && nets.map(net => {
+            if (net.internal)
+                return;
+            let { address } = net;
+            if (address.includes(':'))
+                address = '[' + address + ']';
+            return srv.name + '://' + address + appendPort;
+        })).flat());
+        return urls.length && [srv.name, urls];
+    })));
+}
+exports.getUrls = getUrls;
+function printUrls(port, proto) {
+    if (!port)
+        return;
+    for (const [name, nets] of Object.entries((0, os_1.networkInterfaces)())) {
+        if (!nets || ignore.test(name))
+            continue;
+        lodash_1.default.remove(nets, 'internal');
+        if (!nets.length)
+            continue;
+        const best = lodash_1.default.find(nets, { family: 'IPv4' }) || nets[0];
+        const appendPort = port === (proto === 'https' ? 443 : 80) ? '' : ':' + port;
+        let { address } = best;
+        if (address.includes(':'))
+            address = '[' + address + ']';
+        console.log('network', name, proto + '://' + address + appendPort);
+    }
+}