#!/usr/bin/env node
var _wiki_js_cli;
(function (_wiki_js_cli) {
    var helpers;
    (function (helpers) {
        var string;
        (function (string) {
            /**
             */
            function coin(template, arguments_) {
                let result = template;
                Object.entries(arguments_).forEach(([key, value]) => {
                    result = result.replace(new RegExp("{{" + key + "}}", "g"), value);
                });
                return result;
            }
            string.coin = coin;
        })(string = helpers.string || (helpers.string = {}));
    })(helpers = _wiki_js_cli.helpers || (_wiki_js_cli.helpers = {}));
})(_wiki_js_cli || (_wiki_js_cli = {}));
var _wiki_js_cli;
(function (_wiki_js_cli) {
    var helpers;
    (function (helpers) {
        var file;
        (function (file) {
            /**
             */
            function read(path) {
                const nm_fs = require("fs");
                return (new Promise((resolve, reject) => {
                    nm_fs.readFile(path, {}, (err, data) => {
                        if (err) {
                            reject(err);
                        }
                        else {
                            resolve(data.toString());
                        }
                    });
                }));
            }
            file.read = read;
        })(file = helpers.file || (helpers.file = {}));
    })(helpers = _wiki_js_cli.helpers || (_wiki_js_cli.helpers = {}));
})(_wiki_js_cli || (_wiki_js_cli = {}));
var _wiki_js_cli;
(function (_wiki_js_cli) {
    var helpers;
    (function (helpers) {
        var log;
        (function (log) {
            /**
             */
            let enum_level;
            (function (enum_level) {
                enum_level["debug"] = "debug";
                enum_level["info"] = "info";
                enum_level["notice"] = "notice";
                enum_level["warning"] = "warning";
                enum_level["error"] = "error";
            })(enum_level = log.enum_level || (log.enum_level = {}));
            /**
             */
            const _level_order = [
                enum_level.debug,
                enum_level.info,
                enum_level.notice,
                enum_level.warning,
                enum_level.error,
            ];
            /**
             */
            var _threshold = enum_level.info;
            /**
             */
            function setup(threshold) {
                _threshold = threshold;
                return Promise.resolve(undefined);
            }
            log.setup = setup;
            /**
             */
            function write(level, incident, details) {
                if (_level_order.indexOf(level) < _level_order.indexOf(_threshold)) {
                    // do nothing
                }
                else {
                    process.stderr.write(_wiki_js_cli.helpers.string.coin("\n<{{datetime}}> [{{level}}] {{incident}}\n{{details}}\n\n", {
                        "datetime": (new Date()).toISOString(),
                        "level": level,
                        "incident": incident,
                        "details": JSON.stringify(details, undefined, "\t"),
                    }));
                }
            }
            log.write = write;
        })(log = helpers.log || (helpers.log = {}));
    })(helpers = _wiki_js_cli.helpers || (_wiki_js_cli.helpers = {}));
})(_wiki_js_cli || (_wiki_js_cli = {}));
var _wiki_js_cli;
(function (_wiki_js_cli) {
    var helpers;
    (function (helpers) {
        var http;
        (function (http) {
            /**
             */
            async function call(http_request) {
                _wiki_js_cli.helpers.log.write(_wiki_js_cli.helpers.log.enum_level.debug, "http_call_request", http_request);
                const fetch_request = new Request(http_request.target, {
                    "method": http_request.method,
                    "headers": http_request.headers,
                    "body": http_request.body,
                });
                const fetch_response = await fetch(fetch_request);
                const http_response = {
                    "status_code": fetch_response.status,
                    "headers": Object.fromEntries(fetch_response.headers.entries()),
                    "body": await fetch_response.text(),
                };
                _wiki_js_cli.helpers.log.write(_wiki_js_cli.helpers.log.enum_level.debug, "http_call_response", http_response);
                return http_response;
            }
            http.call = call;
        })(http = helpers.http || (helpers.http = {}));
    })(helpers = _wiki_js_cli.helpers || (_wiki_js_cli.helpers = {}));
})(_wiki_js_cli || (_wiki_js_cli = {}));
var _wiki_js_cli;
(function (_wiki_js_cli) {
    var helpers;
    (function (helpers) {
        var args;
        (function (args) {
            /**
             */
            function parse(args_raw) {
                let result = {
                    "positional": [],
                    "volatile": {},
                };
                let state = "free";
                let key = null;
                args_raw.forEach((arg_raw) => {
                    switch (state) {
                        case "free": {
                            if (arg_raw.startsWith("-")) {
                                key = arg_raw.slice(1);
                                state = "bound";
                            }
                            else {
                                if (key === null) {
                                    result.positional.push(arg_raw);
                                    key = null;
                                    state = "free";
                                }
                                else {
                                    _wiki_js_cli.helpers.log.write(_wiki_js_cli.helpers.log.enum_level.warning, "arg_discarded", {
                                        "arg_raw": arg_raw,
                                    });
                                    key = null;
                                    state = "free";
                                }
                            }
                            break;
                        }
                        case "bound": {
                            if (!(key in result["volatile"])) {
                                result["volatile"][key] = [];
                            }
                            else {
                                // do nothing
                            }
                            result["volatile"][key].push(arg_raw);
                            key = null;
                            state = "free";
                        }
                    }
                });
                return result;
            }
            args.parse = parse;
        })(args = helpers.args || (helpers.args = {}));
    })(helpers = _wiki_js_cli.helpers || (_wiki_js_cli.helpers = {}));
})(_wiki_js_cli || (_wiki_js_cli = {}));
var _wiki_js_cli;
(function (_wiki_js_cli) {
    var conf;
    (function (conf) {
        /**
         */
        var _data = null;
        /**
         */
        async function load(path) {
            let data_raw;
            if (path === null) {
                data_raw = {};
            }
            else {
                const content = await _wiki_js_cli.helpers.file.read(path);
                data_raw = JSON.parse(content);
            }
            _wiki_js_cli.helpers.log.write(_wiki_js_cli.helpers.log.enum_level.debug, "conf_raw", data_raw);
            _data = {
                "api": {
                    "url_base": (data_raw?.api?.url_base
                        ??
                            "http://localhost:3000"),
                },
                "login": {
                    "username": (data_raw?.login?.username
                        ??
                            "admin"),
                    "password": (data_raw?.login?.password
                        ??
                            "admin"),
                },
                "log": {
                    "threshold": (data_raw?.log?.threshold
                        ??
                            "info"),
                }
            };
            return Promise.resolve(undefined);
        }
        conf.load = load;
        /**
         */
        function set(data) {
            _data = data;
        }
        conf.set = set;
        /**
         */
        function get() {
            return _data;
        }
        conf.get = get;
    })(conf = _wiki_js_cli.conf || (_wiki_js_cli.conf = {}));
})(_wiki_js_cli || (_wiki_js_cli = {}));
var _wiki_js_cli;
(function (_wiki_js_cli) {
    var api;
    (function (api) {
        /**
         */
        var _login_token = null;
        /**
         */
        var _url_base = null;
        /**
         */
        function init(url_base) {
            _url_base = url_base;
            return Promise.resolve(undefined);
        }
        api.init = init;
        /**
         */
        async function call_generic_graphql(graphql_query, options) {
            options = Object.assign({
                "variables": {},
            }, options);
            const http_request = {
                "target": (_url_base + "/graphql"),
                "method": "POST",
                "headers": Object.assign({
                    "Content-Type": "application/json",
                }, ((_login_token === null)
                    ?
                        {}
                    :
                        { "Cookie": ("jwt=" + _login_token) })),
                "body": JSON.stringify([
                    {
                        "operationName": null,
                        "variables": options.variables,
                        "extensions": {},
                        "query": graphql_query,
                    }
                ]),
            };
            const http_response = await _wiki_js_cli.helpers.http.call(http_request);
            const data = JSON.parse(http_response.body);
            return Promise.resolve(data[0]["data"]);
        }
        /**
         */
        async function call_finalize(admin_email, admin_password, site_url, telemetry) {
            const http_request = {
                "target": (_url_base + "/finalize"),
                "method": "POST",
                "headers": {
                    "Content-Type": "application/json",
                },
                "body": JSON.stringify({
                    "adminEmail": admin_email,
                    "adminPassword": admin_password,
                    "adminPasswordConfirm": admin_password,
                    "siteUrl": site_url,
                    "telemetry": telemetry,
                }),
            };
            const http_response = await _wiki_js_cli.helpers.http.call(http_request);
            const data = JSON.parse(http_response.body);
            return Promise.resolve(undefined);
        }
        api.call_finalize = call_finalize;
        /**
         * executes a local login
         */
        async function call_login_local(username, password) {
            _wiki_js_cli.helpers.log.write(_wiki_js_cli.helpers.log.enum_level.info, "api_call_login_local", {});
            return (call_generic_graphql("mutation ($username: String!, $password: String!, $strategy: String!) {authentication {login(username: $username, password: $password, strategy: $strategy) {responseResult {succeeded errorCode slug message __typename} jwt mustChangePwd mustProvideTFA mustSetupTFA continuationToken redirect tfaQRImage __typename} __typename}}", {
                "variables": {
                    "strategy": "local",
                    "username": username,
                    "password": password,
                }
            })
                .then((data) => {
                if (data["authentication"]["login"]["responseResult"]["succeeded"]) {
                    _login_token = data["authentication"]["login"]["jwt"];
                    return Promise.resolve(undefined);
                }
                else {
                    return Promise.reject(new Error("login failed"));
                }
            }));
        }
        api.call_login_local = call_login_local;
        /**
         */
        function call_email_settings_set(settings) {
            _wiki_js_cli.helpers.log.write(_wiki_js_cli.helpers.log.enum_level.info, "api_call_email_settings_set", {
                "settings": settings,
            });
            return (call_generic_graphql("mutation ($senderName: String!, $senderEmail: String!, $host: String!, $port: Int!, $name: String!, $secure: Boolean!, $verifySSL: Boolean!, $user: String!, $pass: String!, $useDKIM: Boolean!, $dkimDomainName: String!, $dkimKeySelector: String!, $dkimPrivateKey: String!) {mail {updateConfig(senderName: $senderName, senderEmail: $senderEmail, host: $host, port: $port, name: $name, secure: $secure, verifySSL: $verifySSL, user: $user, pass: $pass, useDKIM: $useDKIM, dkimDomainName: $dkimDomainName, dkimKeySelector: $dkimKeySelector, dkimPrivateKey: $dkimPrivateKey) {responseResult {succeeded errorCode slug message __typename} __typename} __typename}}", {
                "variables": {
                    "senderName": settings.sender_name,
                    "senderEmail": settings.sender_email_address,
                    "host": settings.smtp_host,
                    "port": settings.smtp_port,
                    "name": settings.name,
                    "secure": settings.secure,
                    "verifySSL": settings.verify_ssl,
                    "user": settings.smtp_username,
                    "pass": settings.smtp_password,
                    "useDKIM": settings.use_dkim,
                    "dkimDomainName": settings.dkim_domain_name,
                    "dkimKeySelector": settings.dkim_key_selector,
                    "dkimPrivateKey": settings.dkim_private_key,
                }
            }));
        }
        api.call_email_settings_set = call_email_settings_set;
        /**
         */
        function call_locale_download(locale) {
            _wiki_js_cli.helpers.log.write(_wiki_js_cli.helpers.log.enum_level.info, "api_call_locale_download", {
                "locale": locale,
            });
            return (call_generic_graphql("mutation ($locale: String!) {localization {downloadLocale(locale: $locale) {responseResult {succeeded errorCode slug message __typename} __typename}__typename}}", {
                "variables": {
                    "locale": locale,
                }
            }));
        }
        api.call_locale_download = call_locale_download;
        /**
         */
        function call_group_list(name) {
            _wiki_js_cli.helpers.log.write(_wiki_js_cli.helpers.log.enum_level.info, "api_call_group_list", {});
            return (call_generic_graphql("{groups {list {id name isSystem userCount createdAt updatedAt __typename} __typename}}", {
                "variables": {}
            }));
        }
        api.call_group_list = call_group_list;
        /**
         */
        function call_group_create(name) {
            _wiki_js_cli.helpers.log.write(_wiki_js_cli.helpers.log.enum_level.info, "api_call_group_create", {
                "name": name,
            });
            return (call_generic_graphql("mutation ($name: String!) {groups {create(name: $name) {responseResult {succeeded errorCode slug message __typename} group {id name createdAt updatedAt __typename} __typename} __typename}}", {
                "variables": {
                    "name": name,
                }
            }));
        }
        api.call_group_create = call_group_create;
        /**
         * @param permissions_general {
         *     Array<
         *         string
         *     >
         * }
         * @param permissions_page_specific {
         *     Array<
         *         {
         *             id:string;
         *             path:string;
         *             roles:Array<
         *                 string
         *             >;
         *             match:string;
         *             deny:boolean;
         *             locales:Array<
         *                 string
         *             >;
         *         }
         *     >
         * }
         */
        function call_group_update(group_id, name, permissions_general, permissions_page_specific) {
            _wiki_js_cli.helpers.log.write(_wiki_js_cli.helpers.log.enum_level.info, "api_call_group_update", {});
            return (call_generic_graphql("mutation ($id: Int!, $name: String!, $redirectOnLogin: String!, $permissions: [String]!, $pageRules: [PageRuleInput]!) {groups {update(id: $id, name: $name, redirectOnLogin: $redirectOnLogin, permissions: $permissions, pageRules: $pageRules) {responseResult {succeeded errorCode slug message __typename} __typename} __typename}}", {
                "variables": {
                    "id": group_id,
                    "name": name,
                    "redirectOnLogin": "/",
                    "permissions": permissions_general,
                    "pageRules": permissions_page_specific,
                }
            }));
        }
        api.call_group_update = call_group_update;
        /**
         */
        function call_authentication_strategy_list() {
            _wiki_js_cli.helpers.log.write(_wiki_js_cli.helpers.log.enum_level.info, "api_call_authentication_strategy_list", {});
            return (call_generic_graphql("{authentication {activeStrategies {key strategy {key title description useForm logo website __typename} config {key value __typename} order isEnabled displayName selfRegistration domainWhitelist autoEnrollGroups __typename} __typename}}", {})
                .then((data) => Promise.resolve(data["authentication"]["activeStrategies"])));
        }
        api.call_authentication_strategy_list = call_authentication_strategy_list;
        /**
         */
        function call_authentication_strategy_set(strategies) {
            _wiki_js_cli.helpers.log.write(_wiki_js_cli.helpers.log.enum_level.info, "api_call_authentication_strategy_set", {
                "strategies": strategies,
            });
            return (call_generic_graphql("mutation ($strategies: [AuthenticationStrategyInput]!) {authentication {updateStrategies(strategies: $strategies) {responseResult {succeeded errorCode slug message __typename} __typename} __typename}}", {
                "variables": {
                    "strategies": strategies,
                }
            }));
        }
        api.call_authentication_strategy_set = call_authentication_strategy_set;
        /**
         */
        function call_theming_set(dark_mode, toc_position) {
            _wiki_js_cli.helpers.log.write(_wiki_js_cli.helpers.log.enum_level.info, "api_call_theming_set", {
                "dark_mode": dark_mode,
                "toc_position": toc_position,
            });
            return (call_generic_graphql("mutation ($theme: String!, $iconset: String!, $darkMode: Boolean!, $tocPosition: String, $injectCSS: String, $injectHead: String, $injectBody: String) {theming {setConfig(theme: $theme, iconset: $iconset, darkMode: $darkMode, tocPosition: $tocPosition, injectCSS: $injectCSS, injectHead: $injectHead, injectBody: $injectBody) {responseResult {succeeded errorCode slug message __typename} __typename} __typename}}", {
                "variables": {
                    "theme": "default",
                    "iconset": "mdi",
                    "darkMode": dark_mode,
                    "tocPosition": toc_position,
                    "injectCSS": "",
                    "injectHead": "",
                    "injectBody": ""
                }
            }));
        }
        api.call_theming_set = call_theming_set;
    })(api = _wiki_js_cli.api || (_wiki_js_cli.api = {}));
})(_wiki_js_cli || (_wiki_js_cli = {}));
var _wiki_js_cli;
(function (_wiki_js_cli) {
    var logic;
    (function (logic) {
        /**
         */
        async function login(options = {}) {
            options = Object.assign({
                "username": _wiki_js_cli.conf.get().login.username,
                "password": _wiki_js_cli.conf.get().login.password,
            }, options);
            await _wiki_js_cli.api.call_login_local(options.username, options.password);
            return Promise.resolve(undefined);
        }
        logic.login = login;
        /**
         */
        async function initialize(admin_email_address, admin_password, options = {}) {
            options = Object.assign({
                "site_url": "http://localhost:3000",
                "allow_telemetry": false,
            }, options);
            await _wiki_js_cli.api.call_finalize(admin_email_address, admin_password, options.site_url, options.allow_telemetry);
            return Promise.resolve(undefined);
        }
        logic.initialize = initialize;
        /**
         */
        async function email_settings_set(smtp_host, smtp_port, smtp_username, smtp_password, sender_name, sender_email_address, options = {}) {
            options = Object.assign({}, options);
            const result = await _wiki_js_cli.api.call_email_settings_set({
                "sender_name": sender_name,
                "sender_email_address": sender_email_address,
                "smtp_host": smtp_host,
                "smtp_port": smtp_port,
                "secure": true,
                "verify_ssl": true,
                "smtp_username": smtp_username,
                "smtp_password": smtp_password,
                "name": "",
                "use_dkim": false,
                "dkim_domain_name": "",
                "dkim_key_selector": "",
                "dkim_private_key": "",
            });
            return Promise.resolve(undefined);
        }
        logic.email_settings_set = email_settings_set;
        /**
         */
        async function locale_add(locale_code) {
            _wiki_js_cli.api.call_locale_download(locale_code);
            return Promise.resolve(undefined);
        }
        logic.locale_add = locale_add;
        /**
         */
        async function group_identify(name) {
            const data = await _wiki_js_cli.api.call_group_list(name);
            const hits = (data["groups"]["list"]
                .filter((entry) => (entry["name"] === name)));
            if (hits.length !== 1) {
                return Promise.reject(new Error("not found or ambiguous"));
            }
            else {
                return Promise.resolve(hits[0]["id"]);
            }
        }
        logic.group_identify = group_identify;
        /**
         * returns the ID of the generated group
         */
        async function group_add(name, options = {}) {
            options = Object.assign({
                "permissions_general": [],
                "permissions_specific": [],
            }, options);
            const result_1 = await _wiki_js_cli.api.call_group_create(name);
            const id = result_1["groups"]["create"]["group"]["id"];
            const result_2 = await _wiki_js_cli.api.call_group_update(id, name, options.permissions_general, options.permissions_specific);
            return Promise.resolve(id);
        }
        logic.group_add = group_add;
        /**
         */
        async function group_modify(id, options = {}) {
            options = Object.assign({
                "permissions_general": [],
                "permissions_specific": [],
            }, options);
            const result = await _wiki_js_cli.api.call_group_update(id, name, options.permissions_general, options.permissions_specific);
            return Promise.resolve(undefined);
        }
        logic.group_modify = group_modify;
        /**
         */
        async function authentication_strategy_list() {
            const result = await _wiki_js_cli.api.call_authentication_strategy_list();
            return Promise.resolve(result);
        }
        logic.authentication_strategy_list = authentication_strategy_list;
        /**
         */
        async function authentication_strategy_add(strategy) {
            const current = await _wiki_js_cli.api.call_authentication_strategy_list();
            const result = await _wiki_js_cli.api.call_authentication_strategy_set(((current
                .map((entry) => ({
                "key": entry["key"],
                "strategyKey": entry["strategy"]["key"],
                "displayName": entry["displayName"],
                "order": entry["order"],
                "isEnabled": entry["isEnabled"],
                "config": (entry["config"]
                    .map((item) => ({
                    "key": item["key"],
                    "value": JSON.stringify({ "v": JSON.parse(item["value"])["value"] }),
                }))),
                "selfRegistration": entry["selfRegistration"],
                "domainWhitelist": entry["domainWhitelist"],
                "autoEnrollGroups": entry["autoEnrollGroups"],
            })))
                .concat([
                {
                    "key": strategy.key,
                    "strategyKey": "oauth2",
                    "displayName": strategy.name,
                    "order": ((current
                        .map(x => x["order"])
                        .reduce((x, y) => (((x === null) || (x < y)) ? y : x), null))
                        +
                            1),
                    "isEnabled": true,
                    "config": [
                        {
                            "key": "clientId",
                            "value": JSON.stringify({ "v": strategy.client_id }),
                        },
                        {
                            "key": "clientSecret",
                            "value": JSON.stringify({ "v": strategy.client_secret }),
                        },
                        {
                            "key": "authorizationURL",
                            "value": JSON.stringify({ "v": strategy.authorization_url }),
                        },
                        {
                            "key": "tokenURL",
                            "value": JSON.stringify({ "v": strategy.token_url }),
                        },
                        {
                            "key": "userInfoURL",
                            "value": JSON.stringify({ "v": strategy.user_info_url }),
                        },
                        {
                            "key": "userIdClaim",
                            "value": JSON.stringify({ "v": "id" }),
                        },
                        {
                            "key": "displayNameClaim",
                            "value": JSON.stringify({ "v": "name" }),
                        },
                        {
                            "key": "emailClaim",
                            "value": JSON.stringify({ "v": "email" }),
                        },
                        {
                            "key": "mapGroups",
                            "value": JSON.stringify({ "v": false }),
                        },
                        {
                            "key": "groupsClaim",
                            "value": JSON.stringify({ "v": "groups" }),
                        },
                        {
                            "key": "logoutURL",
                            "value": JSON.stringify({ "v": "" }),
                        },
                        {
                            "key": "scope",
                            "value": JSON.stringify({ "v": "openid profile email" }),
                        },
                        {
                            "key": "useQueryStringForAccessToken",
                            "value": JSON.stringify({ "v": false }),
                        },
                        {
                            "key": "enableCSRFProtection",
                            "value": JSON.stringify({ "v": true }),
                        }
                    ],
                    "selfRegistration": true,
                    "domainWhitelist": [],
                    "autoEnrollGroups": await Promise.all(strategy.group_assignments
                        .map(x => group_identify(x))),
                },
            ])));
            return Promise.resolve(undefined);
        }
        logic.authentication_strategy_add = authentication_strategy_add;
        /**
         */
        async function theming_set(options = {}) {
            options = Object.assign({
                "dark_mode": false,
                "toc_position": "left",
            }, options);
            const result = await _wiki_js_cli.api.call_theming_set(options.dark_mode, options.toc_position);
            return Promise.resolve(result);
        }
        logic.theming_set = theming_set;
    })(logic = _wiki_js_cli.logic || (_wiki_js_cli.logic = {}));
})(_wiki_js_cli || (_wiki_js_cli = {}));
var _wiki_js_cli;
(function (_wiki_js_cli) {
    /**
     */
    function parse_boolean(indicator) {
        if ((indicator === "1")
            ||
                (indicator === "yes")
            ||
                (indicator === "on")
            ||
                (indicator === "true")) {
            return true;
        }
        else {
            if ((indicator === "0")
                ||
                    (indicator === "no")
                ||
                    (indicator === "off")
                ||
                    (indicator === "false")) {
                return false;
            }
            else {
                throw (new Error("invalid boolean indicator: " + indicator));
            }
        }
    }
    /**
     */
    async function main(args_raw) {
        // args
        const args = _wiki_js_cli.helpers.args.parse(args_raw);
        const override_url_base = ((("b" in args.volatile)
            &&
                (args.volatile["b"].length >= 0))
            ?
                args.volatile["b"][0]
            :
                null);
        const override_username = ((("u" in args.volatile)
            &&
                (args.volatile["u"].length >= 0))
            ?
                args.volatile["u"][0]
            :
                null);
        const override_password = ((("p" in args.volatile)
            &&
                (args.volatile["p"].length >= 0))
            ?
                args.volatile["p"][0]
            :
                null);
        const override_log_level = ((("l" in args.volatile)
            &&
                (args.volatile["l"].length >= 0))
            ?
                args.volatile["l"][0]
            :
                null);
        // conf
        const conf_path = ((("c" in args.volatile)
            &&
                (args.volatile["c"].length >= 0))
            ?
                args.volatile["c"][0]
            :
                null);
        await _wiki_js_cli.conf.load(conf_path);
        _wiki_js_cli.helpers.log.write(_wiki_js_cli.helpers.log.enum_level.debug, "conf", _wiki_js_cli.conf.get());
        // init
        await _wiki_js_cli.helpers.log.setup(override_log_level ?? _wiki_js_cli.conf.get().log.threshold);
        await _wiki_js_cli.api.init((override_url_base ?? _wiki_js_cli.conf.get().api.url_base));
        // exec
        if (args.positional.length < 1) {
            return Promise.reject("SYNTAX: [node] cli.js [-c <conf-path>] [-b <api-url-base>] [-u <login-username>] [-p <login-password>] <action> [<arg-1> [<arg-2> […]]]\n\n\t<action> = init | email-settings-set | locale-add | group-add | group-modify | auth-strat-add-oauth2 | theming-set");
        }
        else {
            const action = args.positional[0];
            switch (action) {
                default: {
                    return Promise.reject("invalid action: " + action);
                    break;
                }
                case "init": {
                    if (args.positional.length <= 2) {
                        return Promise.reject("SYNTAX: … init <admin-email-address> <admin-password> [<site-url> [<allow-telemetry>]]");
                    }
                    else {
                        const admin_email_address = args.positional[1];
                        const admin_password = args.positional[2];
                        const site_url = ((args.positional.length >= 4)
                            ?
                                args.positional[3]
                            :
                                undefined);
                        const allow_telemetry = ((args.positional.length >= 5)
                            ?
                                parse_boolean(args.positional[4])
                            :
                                undefined);
                        await _wiki_js_cli.logic.initialize(admin_email_address, admin_password, {
                            "site_url": site_url,
                            "allow_telemetry": allow_telemetry
                        });
                        return Promise.resolve(undefined);
                    }
                    break;
                }
                case "email-settings-set": {
                    if (args.positional.length <= 6) {
                        return Promise.reject("SYNTAX: … email-settings-set <smtp-host> <smtp-port> <smtp-username> <smtp-password> <sender-name> <sender-email-address>");
                    }
                    else {
                        const smtp_host = args.positional[1];
                        const smtp_port = parseInt(args.positional[2]);
                        const smtp_username = args.positional[3];
                        const smtp_password = args.positional[4];
                        const sender_name = args.positional[5];
                        const sender_email_address = args.positional[6];
                        await _wiki_js_cli.logic.login({
                            "username": override_username,
                            "password": override_password,
                        });
                        await _wiki_js_cli.logic.email_settings_set(smtp_host, smtp_port, smtp_username, smtp_password, sender_name, sender_email_address, {});
                        return Promise.resolve(undefined);
                    }
                    break;
                }
                case "locale-add": {
                    if (args.positional.length <= 1) {
                        return Promise.reject("SYNTAX: … locale-add <locale-code>");
                    }
                    else {
                        const locale_code = args.positional[1];
                        await _wiki_js_cli.logic.login({
                            "username": override_username,
                            "password": override_password,
                        });
                        await _wiki_js_cli.logic.locale_add(locale_code);
                        return Promise.resolve(undefined);
                    }
                    break;
                }
                case "group-add": {
                    if (args.positional.length <= 2) {
                        return Promise.reject("SYNTAX: … group-add <name> <permissions>");
                    }
                    else {
                        const name = args.positional[1];
                        const permissions = args.positional[2].split(",");
                        await _wiki_js_cli.logic.login({
                            "username": override_username,
                            "password": override_password,
                        });
                        const result = await _wiki_js_cli.logic.group_add(name, {
                            "permissions_general": permissions,
                            "permissions_specific": [
                                {
                                    "id": "default",
                                    "path": "",
                                    "roles": permissions,
                                    "match": "START",
                                    "deny": false,
                                    "locales": []
                                }
                            ],
                        });
                        process.stdout.write(JSON.stringify(result, undefined, "\t")
                            +
                                "\n");
                    }
                    break;
                }
                case "group-modify": {
                    if (args.positional.length <= 2) {
                        return Promise.reject("SYNTAX: … group-modify <name> <permissions>");
                    }
                    else {
                        const name = args.positional[1];
                        const permissions = args.positional[2].split(",");
                        const id = await _wiki_js_cli.logic.group_identify(name);
                        await _wiki_js_cli.logic.login({
                            "username": override_username,
                            "password": override_password,
                        });
                        const result = await _wiki_js_cli.logic.group_modify(id, {
                            "permissions_general": permissions,
                            "permissions_specific": [
                                {
                                    "id": "default",
                                    "path": "",
                                    "roles": permissions,
                                    "match": "START",
                                    "deny": false,
                                    "locales": []
                                }
                            ],
                        });
                    }
                    break;
                }
                case "auth-strat-add-oauth2": {
                    if (args.positional.length <= 8) {
                        return Promise.reject("SYNTAX: … auth-strat-add-oauth2 <strategy-key> <strategy-name> <strategy-client-id> <strategy-client-secret> <strategy-authorization-url> <strategy-token-url> <strategy-user-info-url> <group-assignments>");
                    }
                    else {
                        const strategy = {
                            "key": args.positional[1],
                            "name": args.positional[2],
                            "client_id": args.positional[3],
                            "client_secret": args.positional[4],
                            "authorization_url": args.positional[5],
                            "token_url": args.positional[6],
                            "user_info_url": args.positional[7],
                            "group_assignments": args.positional[8].split(","),
                        };
                        await _wiki_js_cli.logic.login({
                            "username": override_username,
                            "password": override_password,
                        });
                        await _wiki_js_cli.logic.authentication_strategy_add(strategy);
                        return Promise.resolve(undefined);
                    }
                    break;
                }
                case "theming-set": {
                    if (args.positional.length <= 1) {
                        return Promise.reject("SYNTAX: … theming-set <dark-mode> [<toc-position>]");
                    }
                    else {
                        const dark_mode = parse_boolean(args.positional[1]);
                        const toc_position_raw = ((args.positional.length <= 2)
                            ?
                                "left"
                            :
                                args.positional[2]);
                        const toc_position = (() => {
                            switch (toc_position_raw) {
                                case "left": return "left";
                                case "right": return "right";
                                case "hidden": return "off";
                                default: {
                                    return null;
                                }
                            }
                        })();
                        if (toc_position === null) {
                            return Promise.reject("invalid toc-position: " + toc_position_raw + "; valid values are: left,right,hidden");
                        }
                        else {
                            await _wiki_js_cli.logic.login({
                                "username": override_username,
                                "password": override_password,
                            });
                            await _wiki_js_cli.logic.theming_set({
                                "dark_mode": dark_mode,
                                "toc_position": toc_position,
                            });
                            return Promise.resolve(undefined);
                        }
                    }
                    break;
                }
            }
        }
    }
    _wiki_js_cli.main = main;
})(_wiki_js_cli || (_wiki_js_cli = {}));
(_wiki_js_cli.main(process.argv.slice(2))
    .then(() => {
})
    .catch((reason) => {
    process.stderr.write("-- " + String(reason) + "\n");
}));