hfs 0.1.6 → 0.26.2

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,53 @@
+#!/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 };
+};
+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"));
+(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 = ['hfs-keys-test'];
+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((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,226 @@
+"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.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");
+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())
+        (0, open_1.default)('http://localhost' + (port === 80 ? '' : ':' + port) + 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`);
+        });
+});
+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)
+            continue;
+        const filteredNets = nets.filter(n => !n.internal);
+        if (!filteredNets.length || ignore.test(name))
+            continue;
+        console.log('network', name);
+        for (const net of nets) {
+            if (net.internal)
+                continue;
+            const appendPort = port === (proto === 'https' ? 443 : 80) ? '' : ':' + port;
+            let { address } = net;
+            if (address.includes(':'))
+                address = '[' + address + ']';
+            console.log('-', proto + '://' + address + appendPort);
+        }
+    }
+}

package/src/log.js

@@ -0,0 +1,137 @@
+"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.log = exports.loggers = void 0;
+const config_1 = require("./config");
+const fs_1 = require("fs");
+const util = __importStar(require("util"));
+const promises_1 = require("fs/promises");
+const const_1 = require("./const");
+const events_1 = __importDefault(require("./events"));
+const lodash_1 = __importDefault(require("lodash"));
+const path_1 = require("path");
+const perm_1 = require("./perm");
+class Logger {
+    constructor(name) {
+        this.name = name;
+        this.path = '';
+    }
+    async setPath(path) {
+        var _a;
+        this.path = path;
+        (_a = this.stream) === null || _a === void 0 ? void 0 : _a.end();
+        this.last = undefined;
+        if (!path)
+            return this.stream = undefined;
+        try {
+            const stats = await (0, promises_1.stat)(path);
+            this.last = stats.mtime || stats.ctime;
+        }
+        catch (_b) {
+            await (0, promises_1.mkdir)((0, path_1.dirname)(path), { recursive: true })
+                .catch(() => console.log("cannot create folder for", path));
+        }
+        this.reopen();
+    }
+    reopen() {
+        return this.stream = (0, fs_1.createWriteStream)(this.path, { flags: 'a' })
+            .on('error', () => this.stream = undefined);
+    }
+}
+// we'll have names same as config keys. These are used also by the get_log api.
+const accessLogger = new Logger('log');
+const accessErrorLog = new Logger('error_log');
+exports.loggers = [accessLogger, accessErrorLog];
+(0, config_1.defineConfig)('log', 'logs/access.log').sub(path => {
+    console.debug('access log file: ' + (path || 'disabled'));
+    accessLogger.setPath(path);
+});
+const errorLogFile = (0, config_1.defineConfig)(accessErrorLog.name, 'logs/access-error.log');
+errorLogFile.sub(path => {
+    console.debug('access error log: ' + (path || 'disabled'));
+    accessErrorLog.setPath(path);
+});
+const logRotation = (0, config_1.defineConfig)('log_rotation', 'weekly');
+function log() {
+    const debounce = lodash_1.default.debounce(cb => cb(), 1000);
+    return async (ctx, next) => {
+        var _a;
+        await next();
+        const isError = ctx.status >= 400;
+        const logger = isError && accessErrorLog || accessLogger;
+        const rotate = (_a = logRotation.get()) === null || _a === void 0 ? void 0 : _a[0];
+        let { stream, last, path } = logger;
+        if (!stream)
+            return;
+        const now = new Date();
+        const a = now.toString().split(' ');
+        logger.last = now;
+        if (rotate && last) { // rotation enabled and a file exists?
+            const passed = Number(now) - Number(last)
+                - 3600000; // be pessimistic and count a possible DST change
+            if (rotate === 'm' && (passed >= 31 * const_1.DAY || now.getMonth() !== last.getMonth())
+                || rotate === 'd' && (passed >= const_1.DAY || now.getDate() !== last.getDate()) // checking passed will solve the case when the day of the month is the same but a month has passed
+                || rotate === 'w' && (passed >= 7 * const_1.DAY || now.getDay() < last.getDay())) {
+                stream.end();
+                const postfix = last.getFullYear() + '-' + doubleDigit(last.getMonth() + 1) + '-' + doubleDigit(last.getDate());
+                try { // other logging requests shouldn't happen while we are renaming. Since this is very infrequent we can tolerate solving this by making it sync.
+                    (0, fs_1.renameSync)(path, path + '-' + postfix);
+                }
+                catch (e) { // ok, rename failed, but this doesn't mean we ain't gonna log
+                    console.error(e);
+                }
+                stream = logger.reopen(); // keep variable updated
+                if (!stream)
+                    return;
+            }
+        }
+        const format = '%s - %s [%s] "%s %s HTTP/%s" %d %s\n'; // Apache's Common Log Format
+        const date = a[2] + '/' + a[1] + '/' + a[3] + ':' + a[4] + ' ' + a[5].slice(3);
+        const user = (0, perm_1.getCurrentUsername)(ctx);
+        events_1.default.emit(logger.name, Object.assign(lodash_1.default.pick(ctx, ['ip', 'method', 'status', 'length']), { user, ts: now, uri: ctx.path }));
+        console.debug(ctx.status, ctx.method, ctx.path);
+        debounce(() => // once in a while we check if the file is still good (not deleted, etc), or we'll reopen it
+         (0, promises_1.stat)(logger.path).catch(() => logger.reopen())); // async = smoother but we may lose some entries
+        stream.write(util.format(format, ctx.ip, user || '-', date, ctx.method, ctx.path, ctx.req.httpVersion, ctx.status, ctx.length ? ctx.length.toString() : '-'));
+    };
+}
+exports.log = log;
+function doubleDigit(n) {
+    return n > 9 ? n : '0' + n;
+}
+// dump console.error to file
+const debugLogFile = (0, fs_1.createWriteStream)('debug.log', { flags: 'a' });
+debugLogFile.on('open', () => {
+    const was = console.error;
+    console.error = function (...args) {
+        was.apply(this, args);
+        const params = args.map(x => typeof x === 'string' ? x : JSON.stringify(x)).join(' ');
+        debugLogFile.write(new Date().toLocaleString() + ': ' + params + '\n');
+    };
+}).on('error', () => console.log("cannot create debug.log"));