ntfy-reverse-proxy 0.0.0 → 2.0.0

package/build/src/cli/menu/interactive.js

@@ -0,0 +1,902 @@
+import { existsSync, readFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { Bootstrap, CLIHeader, Logger } from '@cbnventures/nova/toolkit';
+import chalk from 'chalk';
+import prompts from 'prompts';
+import { LIB_REGEX_NON_ALPHANUMERIC_ID } from '../../lib/regex.js';
+import { addContext, generateId, generateToken, listContexts, removeContext, } from '../commands/context.js';
+import { deploy } from '../commands/deploy.js';
+import { addServer, listServers, removeServer } from '../commands/server.js';
+import { getSettings, updateSettings } from '../commands/settings.js';
+async function interactiveMenu(configDirs) {
+    const currentFilePath = fileURLToPath(import.meta.url);
+    let dir = dirname(currentFilePath);
+    let version = '0.0.0';
+    while (dir !== dirname(dir)) {
+        const packageJsonPath = join(dir, 'package.json');
+        if (existsSync(packageJsonPath) === true) {
+            const packageJsonRaw = readFileSync(packageJsonPath, 'utf-8');
+            const packageJsonParsed = JSON.parse(packageJsonRaw);
+            version = packageJsonParsed['version'];
+            break;
+        }
+        const parent = dirname(dir);
+        dir = parent;
+    }
+    const header = CLIHeader.render([
+        chalk.magentaBright(`Reverse Proxy for ntfy v${version}`),
+        chalk.dim('A CBN Ventures Creation'),
+    ], {
+        style: 'round',
+        width: 50,
+        marginBottom: 1,
+    });
+    process.stdout.write(`${header}\n`);
+    let configPath = undefined;
+    if (configDirs['length'] > 1) {
+        const configDirResponse = await prompts({
+            type: 'select',
+            name: 'dir',
+            message: chalk.cyan('Multiple config files found. Which one?'),
+            choices: configDirs.map((configDir) => ({
+                title: join(configDir, 'config.json'),
+                value: configDir,
+            })),
+        });
+        if (configDirResponse['dir'] === undefined) {
+            return;
+        }
+        configPath = join(configDirResponse['dir'], 'config.json');
+    }
+    else if (configDirs['length'] === 1) {
+        configPath = join(configDirs[0], 'config.json');
+    }
+    else {
+        const defaultConfigDir = Bootstrap.getConfigDir('ntfy-reverse-proxy');
+        configPath = join(defaultConfigDir, 'config.json');
+    }
+    let running = true;
+    while (running === true) {
+        const response = await prompts({
+            type: 'select',
+            name: 'action',
+            message: chalk.cyan('What would you like to do?'),
+            choices: [
+                {
+                    title: 'Manage Servers', value: 'servers',
+                },
+                {
+                    title: 'Manage Contexts', value: 'contexts',
+                },
+                {
+                    title: 'Settings', value: 'settings',
+                },
+                {
+                    title: 'Deploy', value: 'deploy',
+                },
+                {
+                    title: 'Exit', value: 'exit',
+                },
+            ],
+        });
+        const action = response['action'];
+        if (action === undefined || action === 'exit') {
+            running = false;
+            break;
+        }
+        if (action === 'servers') {
+            await serverMenu(configPath);
+        }
+        else if (action === 'contexts') {
+            await contextMenu(configPath);
+        }
+        else if (action === 'settings') {
+            await settingsFlow(configPath);
+        }
+        else if (action === 'deploy') {
+            try {
+                await deploy(configPath, true);
+            }
+            catch (error) {
+                const errorMessage = (error instanceof Error) ? error['message'] : String(error);
+                Logger.error(`Error: ${errorMessage}`);
+            }
+        }
+    }
+    return;
+}
+async function serverMenu(configPath) {
+    let inMenu = true;
+    while (inMenu === true) {
+        const response = await prompts({
+            type: 'select',
+            name: 'action',
+            message: chalk.cyan('Manage Servers'),
+            choices: [
+                {
+                    title: 'Add', value: 'add',
+                },
+                {
+                    title: 'Edit', value: 'edit',
+                },
+                {
+                    title: 'Remove', value: 'remove',
+                },
+                {
+                    title: 'Back', value: 'back',
+                },
+            ],
+        });
+        const action = response['action'];
+        if (action === undefined || action === 'back') {
+            inMenu = false;
+            break;
+        }
+        if (action === 'add') {
+            const answers = await prompts([
+                {
+                    type: 'text',
+                    name: 'name',
+                    message: 'Server name:',
+                    validate: (value) => value.trim()['length'] > 0 || 'Name is required',
+                },
+                {
+                    type: 'text',
+                    name: 'server',
+                    message: 'Server URL:',
+                    validate: (value) => {
+                        if (value.startsWith('https://') === false) {
+                            return 'URL must start with https://';
+                        }
+                        try {
+                            const urlInstance = new URL(value);
+                            void urlInstance;
+                            return true;
+                        }
+                        catch {
+                            return 'Invalid URL';
+                        }
+                    },
+                },
+                {
+                    type: 'password',
+                    name: 'token',
+                    message: 'Server token:',
+                    validate: (value) => value.startsWith('tk_') || 'Token must start with tk_',
+                },
+            ]);
+            const answersName = answers['name'];
+            const answersServer = answers['server'];
+            const answersToken = answers['token'];
+            if (answersName !== undefined
+                && answersServer !== undefined
+                && answersToken !== undefined) {
+                try {
+                    addServer(configPath, {
+                        name: answersName,
+                        server: answersServer,
+                        token: answersToken,
+                    });
+                    Logger.info(`Server "${answersName}" added.`);
+                }
+                catch (error) {
+                    const errorMessage = (error instanceof Error) ? error['message'] : String(error);
+                    Logger.error(`Error: ${errorMessage}`);
+                }
+            }
+        }
+        else if (action === 'edit') {
+            try {
+                const servers = listServers(configPath);
+                servers.sort((a, b) => a['name'].localeCompare(b['name']));
+                if (servers['length'] === 0) {
+                    Logger.warn('No servers to edit.');
+                }
+                else {
+                    const selectResponse = await prompts({
+                        type: 'select',
+                        name: 'name',
+                        message: 'Select server to edit:',
+                        choices: servers.map((server) => ({
+                            title: server['name'], value: server['name'],
+                        })),
+                    });
+                    const name = selectResponse['name'];
+                    if (name !== undefined) {
+                        const current = servers.find((server) => server['name'] === name);
+                        const currentServer = (current !== undefined) ? current['server'] : undefined;
+                        const updates = await prompts([
+                            {
+                                type: 'text',
+                                name: 'server',
+                                message: 'Server URL:',
+                                initial: currentServer,
+                                validate: (value) => {
+                                    if (value.startsWith('https://') === false) {
+                                        return 'URL must start with https://';
+                                    }
+                                    try {
+                                        const urlInstance = new URL(value);
+                                        void urlInstance;
+                                        return true;
+                                    }
+                                    catch {
+                                        return 'Invalid URL';
+                                    }
+                                },
+                            },
+                            {
+                                type: 'password',
+                                name: 'token',
+                                message: 'Server token (leave blank to keep current):',
+                                validate: (value) => {
+                                    const trimmedEmpty = (value.trim() === '');
+                                    const startsWithTk = value.startsWith('tk_');
+                                    if (trimmedEmpty === true) {
+                                        return true;
+                                    }
+                                    return startsWithTk || 'Token must start with tk_';
+                                },
+                            },
+                        ]);
+                        const editImport = await import('../commands/server.js');
+                        const updatesServerString = updates['server'];
+                        const serverUrlTrimmed = updatesServerString.trim();
+                        const serverUrl = (serverUrlTrimmed !== '') ? updatesServerString : undefined;
+                        const updatesTokenString = updates['token'];
+                        const tokenTrimmed = updatesTokenString.trim();
+                        const tokenValue = (tokenTrimmed !== '') ? updatesTokenString : undefined;
+                        if (serverUrl !== undefined || tokenValue !== undefined) {
+                            const editUpdates = {};
+                            if (serverUrl !== undefined) {
+                                Reflect.set(editUpdates, 'server', serverUrl);
+                            }
+                            if (tokenValue !== undefined) {
+                                Reflect.set(editUpdates, 'token', tokenValue);
+                            }
+                            editImport.editServer(configPath, name, editUpdates);
+                            Logger.info(`Server "${name}" updated.`);
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                const errorMessage = (error instanceof Error) ? error['message'] : String(error);
+                Logger.error(`Error: ${errorMessage}`);
+            }
+        }
+        else if (action === 'remove') {
+            try {
+                const servers = listServers(configPath);
+                servers.sort((a, b) => a['name'].localeCompare(b['name']));
+                if (servers['length'] === 0) {
+                    Logger.warn('No servers to remove.');
+                }
+                else {
+                    const selectResponse = await prompts({
+                        type: 'select',
+                        name: 'name',
+                        message: 'Select server to remove:',
+                        choices: servers.map((server) => ({
+                            title: server['name'], value: server['name'],
+                        })),
+                    });
+                    const name = selectResponse['name'];
+                    if (name !== undefined) {
+                        const confirmResponse = await prompts({
+                            type: 'confirm',
+                            name: 'confirmed',
+                            message: chalk.yellow(`Remove "${name}"?`),
+                            initial: false,
+                        });
+                        const confirmed = confirmResponse['confirmed'];
+                        if (confirmed === true) {
+                            removeServer(configPath, name);
+                            Logger.info(`Server "${name}" removed.`);
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                const errorMessage = (error instanceof Error) ? error['message'] : String(error);
+                Logger.error(`Error: ${errorMessage}`);
+            }
+        }
+    }
+    return;
+}
+async function contextMenu(configPath) {
+    let inMenu = true;
+    while (inMenu === true) {
+        const response = await prompts({
+            type: 'select',
+            name: 'action',
+            message: chalk.cyan('Manage Contexts'),
+            choices: [
+                {
+                    title: 'Add', value: 'add',
+                },
+                {
+                    title: 'Edit', value: 'edit',
+                },
+                {
+                    title: 'Remove', value: 'remove',
+                },
+                {
+                    title: 'Back', value: 'back',
+                },
+            ],
+        });
+        const action = response['action'];
+        if (action === undefined || action === 'back') {
+            inMenu = false;
+            break;
+        }
+        if (action === 'add') {
+            try {
+                const servers = listServers(configPath);
+                if (servers['length'] === 0) {
+                    Logger.warn('Add a server first.');
+                }
+                else {
+                    await addContextFlow(configPath, servers);
+                }
+            }
+            catch (error) {
+                const errorMessage = (error instanceof Error) ? error['message'] : String(error);
+                Logger.error(`Error: ${errorMessage}`);
+            }
+        }
+        else if (action === 'edit') {
+            try {
+                const contexts = listContexts(configPath);
+                contexts.sort((a, b) => a['name'].localeCompare(b['name']));
+                if (contexts['length'] === 0) {
+                    Logger.warn('No contexts to edit.');
+                }
+                else {
+                    const selectResponse = await prompts({
+                        type: 'select',
+                        name: 'name',
+                        message: 'Select context to edit:',
+                        choices: contexts.map((context) => ({
+                            title: context['name'], value: context['name'],
+                        })),
+                    });
+                    const name = selectResponse['name'];
+                    if (name !== undefined) {
+                        const current = contexts.find((context) => context['name'] === name);
+                        if (current !== undefined) {
+                            const servers = listServers(configPath);
+                            const serverChoices = servers.map((server) => ({
+                                title: server['name'], value: server['name'],
+                            }));
+                            const keepIdResponse = await prompts({
+                                type: 'confirm',
+                                name: 'keepId',
+                                message: `Keep current ID (${current['id']})?`,
+                                initial: true,
+                            });
+                            const keepId = keepIdResponse['keepId'];
+                            let id = undefined;
+                            if (keepId === false) {
+                                id = generateId();
+                                Logger.info(`  New ID: ${id}`);
+                            }
+                            const httpChoices = [
+                                {
+                                    title: 'Plain Text', value: 'plain-text',
+                                },
+                                {
+                                    title: 'ntfy JSON', value: 'ntfy-json',
+                                },
+                                {
+                                    title: 'Seerr', value: 'seerr',
+                                },
+                                {
+                                    title: 'Synology DSM', value: 'synology',
+                                },
+                                {
+                                    title: 'Statuspage.io', value: 'statuspage',
+                                },
+                            ];
+                            const emailChoices = [
+                                {
+                                    title: 'Plain Text', value: 'plain-text',
+                                },
+                                {
+                                    title: 'pfSense', value: 'pfsense',
+                                },
+                                {
+                                    title: 'UniFi', value: 'unifi',
+                                },
+                            ];
+                            const knownChoices = (current['type'] === 'http') ? httpChoices : emailChoices;
+                            const exists = knownChoices.some((c) => c['value'] === current['interpreter']);
+                            if (exists === false) {
+                                knownChoices.unshift({
+                                    title: `${current['interpreter']} (current, unknown)`, value: current['interpreter'],
+                                });
+                            }
+                            const httpValues = [
+                                'plain-text',
+                                'ntfy-json',
+                                'seerr',
+                                'synology',
+                                'statuspage',
+                            ];
+                            const emailValues = [
+                                'plain-text',
+                                'pfsense',
+                                'unifi',
+                            ];
+                            const knownValues = (current['type'] === 'http') ? httpValues : emailValues;
+                            const interpreterIdx = knownValues.indexOf(current['interpreter']);
+                            const interpreterInitial = (interpreterIdx >= 0) ? interpreterIdx : 0;
+                            const interpreterResponse = await prompts({
+                                type: 'select',
+                                name: 'interpreter',
+                                message: 'Interpreter:',
+                                choices: knownChoices,
+                                initial: interpreterInitial,
+                            });
+                            const interpreter = interpreterResponse['interpreter'];
+                            const topicResponse = await prompts({
+                                type: 'text',
+                                name: 'topic',
+                                message: 'ntfy topic:',
+                                initial: current['topic'],
+                                validate: (value) => value.trim()['length'] > 0 || 'Topic is required',
+                            });
+                            const topic = topicResponse['topic'];
+                            const currentErrorTopic = (current['error_topic'] !== undefined) ? current['error_topic'] : '';
+                            const errorTopicResponse = await prompts({
+                                type: 'text',
+                                name: 'error_topic',
+                                message: 'ntfy error topic (blank to skip):',
+                                initial: currentErrorTopic,
+                            });
+                            const errorTopic = errorTopicResponse['error_topic'];
+                            const modeInitial = (current['mode'] === 'send-all') ? 1 : 0;
+                            const modeResponse = await prompts({
+                                type: 'select',
+                                name: 'mode',
+                                message: 'Mode:',
+                                choices: [
+                                    {
+                                        title: 'Send to one server only', value: 'send-once',
+                                    },
+                                    {
+                                        title: 'Send to all servers', value: 'send-all',
+                                    },
+                                ],
+                                initial: modeInitial,
+                            });
+                            const mode = modeResponse['mode'];
+                            const showVisitorInfoResponse = await prompts({
+                                type: 'confirm',
+                                name: 'show_visitor_info',
+                                message: 'Show visitor info?',
+                                initial: current['show_visitor_info'],
+                            });
+                            const showVisitorInfo = showVisitorInfoResponse['show_visitor_info'];
+                            const primaryServerIdx = serverChoices.findIndex((s) => s['value'] === current['primary_server']);
+                            if (primaryServerIdx < 0) {
+                                serverChoices.unshift({
+                                    title: `${current['primary_server']} (current, not found)`, value: current['primary_server'],
+                                });
+                            }
+                            const primaryServerInitial = (primaryServerIdx >= 0) ? primaryServerIdx : 0;
+                            const primaryServerResponse = await prompts({
+                                type: 'select',
+                                name: 'primary_server',
+                                message: 'Primary server:',
+                                choices: serverChoices,
+                                initial: primaryServerInitial,
+                            });
+                            const primaryServer = primaryServerResponse['primary_server'];
+                            const selectedServersResponse = await prompts({
+                                type: 'multiselect',
+                                name: 'selectedServers',
+                                message: 'All servers (space to select):',
+                                choices: serverChoices.map((s) => ({
+                                    ...s,
+                                    selected: current['servers'].includes(s['value']),
+                                })),
+                            });
+                            const selectedServers = selectedServersResponse['selectedServers'];
+                            const updates = {};
+                            if (id !== undefined) {
+                                Reflect.set(updates, 'id', id);
+                            }
+                            if (interpreter !== undefined) {
+                                Reflect.set(updates, 'interpreter', interpreter);
+                            }
+                            if (topic !== undefined) {
+                                Reflect.set(updates, 'topic', topic);
+                            }
+                            if (mode !== undefined) {
+                                Reflect.set(updates, 'mode', mode);
+                            }
+                            if (showVisitorInfo !== undefined) {
+                                Reflect.set(updates, 'show_visitor_info', showVisitorInfo);
+                            }
+                            if (primaryServer !== undefined) {
+                                Reflect.set(updates, 'primary_server', primaryServer);
+                            }
+                            if (selectedServers !== undefined) {
+                                Reflect.set(updates, 'servers', selectedServers);
+                            }
+                            const errorTopicValue = errorTopic;
+                            const errorTopicTrimmed = (errorTopicValue !== undefined) ? errorTopicValue.trim() : '';
+                            const resolvedErrorTopic = (errorTopicTrimmed !== '') ? errorTopicTrimmed : undefined;
+                            Reflect.set(updates, 'error_topic', resolvedErrorTopic);
+                            if (current['type'] === 'http' && current['token'] !== undefined) {
+                                const keepTokenResponse = await prompts({
+                                    type: 'confirm',
+                                    name: 'keepToken',
+                                    message: 'Keep current auth token?',
+                                    initial: true,
+                                });
+                                const keepToken = keepTokenResponse['keepToken'];
+                                if (keepToken === false) {
+                                    const newToken = generateToken();
+                                    Reflect.set(updates, 'token', newToken);
+                                    Logger.info(`  New token: ${newToken}`);
+                                }
+                            }
+                            else if (current['type'] === 'http' && current['token'] === undefined) {
+                                const addTokenResponse = await prompts({
+                                    type: 'confirm',
+                                    name: 'addToken',
+                                    message: 'Add auth token?',
+                                    initial: false,
+                                });
+                                const addToken = addTokenResponse['addToken'];
+                                if (addToken === true) {
+                                    const newToken = generateToken();
+                                    Reflect.set(updates, 'token', newToken);
+                                    Logger.info(`  New token: ${newToken}`);
+                                }
+                            }
+                            else if (current['type'] === 'email') {
+                                const currentAllowedFrom = (current['allowed_from'] !== undefined) ? current['allowed_from'] : '';
+                                const allowedFromResponse = await prompts({
+                                    type: 'text',
+                                    name: 'allowed_from',
+                                    message: 'Allowed from email (blank to clear):',
+                                    initial: currentAllowedFrom,
+                                });
+                                const allowedFrom = allowedFromResponse['allowed_from'];
+                                const allowedFromTrimmed = (allowedFrom !== undefined) ? allowedFrom.trim() : '';
+                                const resolvedAllowedFrom = (allowedFromTrimmed !== '') ? allowedFromTrimmed : undefined;
+                                Reflect.set(updates, 'allowed_from', resolvedAllowedFrom);
+                            }
+                            const editImport = await import('../commands/context.js');
+                            editImport.editContext(configPath, name, updates);
+                            Logger.info(`Context "${name}" updated.`);
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                const errorMessage = (error instanceof Error) ? error['message'] : String(error);
+                Logger.error(`Error: ${errorMessage}`);
+            }
+        }
+        else if (action === 'remove') {
+            try {
+                const contexts = listContexts(configPath);
+                contexts.sort((a, b) => a['name'].localeCompare(b['name']));
+                if (contexts['length'] === 0) {
+                    Logger.warn('No contexts to remove.');
+                }
+                else {
+                    const selectResponse = await prompts({
+                        type: 'select',
+                        name: 'name',
+                        message: 'Select context to remove:',
+                        choices: contexts.map((context) => ({
+                            title: context['name'], value: context['name'],
+                        })),
+                    });
+                    const name = selectResponse['name'];
+                    if (name !== undefined) {
+                        const confirmResponse = await prompts({
+                            type: 'confirm',
+                            name: 'confirmed',
+                            message: chalk.yellow(`Remove "${name}"?`),
+                            initial: false,
+                        });
+                        const confirmed = confirmResponse['confirmed'];
+                        if (confirmed === true) {
+                            removeContext(configPath, name);
+                            Logger.info(`Context "${name}" removed.`);
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                const errorMessage = (error instanceof Error) ? error['message'] : String(error);
+                Logger.error(`Error: ${errorMessage}`);
+            }
+        }
+    }
+    return;
+}
+async function addContextFlow(configPath, servers) {
+    const autoId = generateId();
+    const typeResponse = await prompts({
+        type: 'select',
+        name: 'contextType',
+        message: 'Context type:',
+        choices: [
+            {
+                title: 'HTTP', value: 'http',
+            },
+            {
+                title: 'Email', value: 'email',
+            },
+        ],
+    });
+    const contextType = typeResponse['contextType'];
+    if (contextType === undefined) {
+        return;
+    }
+    const httpInterpreters = [
+        {
+            title: 'Plain Text', value: 'plain-text',
+        },
+        {
+            title: 'ntfy JSON', value: 'ntfy-json',
+        },
+        {
+            title: 'Seerr', value: 'seerr',
+        },
+        {
+            title: 'Synology DSM', value: 'synology',
+        },
+        {
+            title: 'Statuspage.io', value: 'statuspage',
+        },
+    ];
+    const emailInterpreters = [
+        {
+            title: 'Plain Text', value: 'plain-text',
+        },
+        {
+            title: 'pfSense', value: 'pfsense',
+        },
+        {
+            title: 'UniFi', value: 'unifi',
+        },
+    ];
+    const nameResponse = await prompts({
+        type: 'text',
+        name: 'name',
+        message: 'Context name:',
+        validate: (value) => value.trim()['length'] > 0 || 'Name is required',
+    });
+    const name = nameResponse['name'];
+    if (name === undefined) {
+        return;
+    }
+    const idMessage = (contextType === 'http') ? `ID (blank for auto: ${autoId}):` : 'ID (email local part, e.g. "pfsense"):';
+    const idResponse = await prompts({
+        type: 'text',
+        name: 'id',
+        message: idMessage,
+        validate: (value) => {
+            if (contextType === 'http') {
+                return true;
+            }
+            if (value.trim()['length'] === 0) {
+                return 'ID is required for email contexts';
+            }
+            if (LIB_REGEX_NON_ALPHANUMERIC_ID.test(value) === true) {
+                return 'ID must be alphanumeric (plus . _ -)';
+            }
+            return true;
+        },
+    });
+    const rawId = idResponse['id'];
+    if (rawId === undefined) {
+        return;
+    }
+    const interpreterChoices = (contextType === 'http') ? httpInterpreters : emailInterpreters;
+    const interpreterResponse = await prompts({
+        type: 'select',
+        name: 'interpreter',
+        message: 'Interpreter:',
+        choices: interpreterChoices,
+    });
+    const interpreter = interpreterResponse['interpreter'];
+    if (interpreter === undefined) {
+        return;
+    }
+    const topicResponse = await prompts({
+        type: 'text',
+        name: 'topic',
+        message: 'ntfy topic:',
+        validate: (value) => value.trim()['length'] > 0 || 'Topic is required',
+    });
+    const topic = topicResponse['topic'];
+    if (topic === undefined) {
+        return;
+    }
+    const errorTopicResponse = await prompts({
+        type: 'text',
+        name: 'error_topic',
+        message: 'ntfy error topic (blank to skip):',
+    });
+    const errorTopic = errorTopicResponse['error_topic'];
+    const modeResponse = await prompts({
+        type: 'select',
+        name: 'mode',
+        message: 'Mode:',
+        choices: [
+            {
+                title: 'Send to one server only', value: 'send-once',
+            },
+            {
+                title: 'Send to all servers', value: 'send-all',
+            },
+        ],
+    });
+    const mode = modeResponse['mode'];
+    if (mode === undefined) {
+        return;
+    }
+    const showVisitorInfoResponse = await prompts({
+        type: 'confirm',
+        name: 'show_visitor_info',
+        message: 'Show visitor info?',
+        initial: false,
+    });
+    const showVisitorInfo = showVisitorInfoResponse['show_visitor_info'];
+    if (showVisitorInfo === undefined) {
+        return;
+    }
+    const primaryServerResponse = await prompts({
+        type: 'select',
+        name: 'primary_server',
+        message: 'Primary server:',
+        choices: servers.map((server) => ({
+            title: server['name'], value: server['name'],
+        })),
+    });
+    const primaryServer = primaryServerResponse['primary_server'];
+    if (primaryServer === undefined) {
+        return;
+    }
+    const selectedServersResponse = await prompts({
+        type: 'multiselect',
+        name: 'selectedServers',
+        message: 'All servers for this context (space to select):',
+        choices: servers.map((server) => ({
+            title: server['name'], value: server['name'],
+        })),
+    });
+    const selectedServers = selectedServersResponse['selectedServers'];
+    if (selectedServers === undefined) {
+        return;
+    }
+    const rawIdString = rawId;
+    const idTrimmed = rawIdString.trim();
+    const resolvedId = (idTrimmed !== '') ? idTrimmed : autoId;
+    const errorTopicString = (errorTopic !== undefined) ? (errorTopic) : '';
+    const errorTopicTrimmed = errorTopicString.trim();
+    const resolvedErrorTopic = (errorTopicTrimmed !== '') ? errorTopicTrimmed : undefined;
+    const topicString = topic;
+    const typedInterpreter = interpreter;
+    const typedMode = mode;
+    if (contextType === 'http') {
+        const autoToken = generateToken();
+        const tokenResponse = await prompts({
+            type: 'text',
+            name: 'token',
+            message: 'Auth token (blank to skip, enter to accept):',
+            initial: autoToken,
+        });
+        const rawToken = tokenResponse['token'];
+        const tokenTrimmed = (rawToken !== undefined) ? rawToken.trim() : '';
+        const resolvedToken = (tokenTrimmed !== '') ? tokenTrimmed : undefined;
+        addContext(configPath, {
+            name,
+            type: 'http',
+            id: resolvedId,
+            interpreter: typedInterpreter,
+            topic: topicString,
+            error_topic: resolvedErrorTopic,
+            mode: typedMode,
+            show_visitor_info: showVisitorInfo,
+            primary_server: primaryServer,
+            servers: selectedServers,
+            token: resolvedToken,
+        });
+    }
+    else {
+        const allowedFromResponse = await prompts({
+            type: 'text',
+            name: 'allowed_from',
+            message: 'Allowed from email (blank to skip):',
+        });
+        const rawAllowedFrom = allowedFromResponse['allowed_from'];
+        const allowedFromTrimmed = (rawAllowedFrom !== undefined) ? rawAllowedFrom.trim() : '';
+        const resolvedAllowedFrom = (allowedFromTrimmed !== '') ? allowedFromTrimmed : undefined;
+        addContext(configPath, {
+            name,
+            type: 'email',
+            id: resolvedId,
+            interpreter: typedInterpreter,
+            topic: topicString,
+            error_topic: resolvedErrorTopic,
+            mode: typedMode,
+            show_visitor_info: showVisitorInfo,
+            primary_server: primaryServer,
+            servers: selectedServers,
+            allowed_from: resolvedAllowedFrom,
+        });
+    }
+    Logger.info(`Context "${name}" added.`);
+    return;
+}
+async function settingsFlow(configPath) {
+    let currentSettings = undefined;
+    try {
+        currentSettings = getSettings(configPath);
+    }
+    catch (error) {
+        const errorMessage = (error instanceof Error) ? error['message'] : String(error);
+        Logger.error(`Error: ${errorMessage}`);
+        return;
+    }
+    const workerNameResponse = await prompts({
+        type: 'text',
+        name: 'worker_name',
+        message: 'Worker name:',
+        initial: currentSettings['worker_name'],
+        validate: (value) => value.trim()['length'] > 0 || 'Worker name is required',
+    });
+    const workerName = workerNameResponse['worker_name'];
+    if (workerName === undefined) {
+        return;
+    }
+    const baseDomainResponse = await prompts({
+        type: 'text',
+        name: 'base_domain',
+        message: 'Base domain:',
+        initial: currentSettings['base_domain'],
+        validate: (value) => value.trim()['length'] > 0 || 'Base domain is required',
+    });
+    const baseDomain = baseDomainResponse['base_domain'];
+    if (baseDomain === undefined) {
+        return;
+    }
+    const showResponseOutputResponse = await prompts({
+        type: 'confirm',
+        name: 'show_response_output',
+        message: 'Show response output (debug mode)?',
+        initial: currentSettings['show_response_output'],
+    });
+    const showResponseOutput = showResponseOutputResponse['show_response_output'];
+    if (showResponseOutput === undefined) {
+        return;
+    }
+    try {
+        updateSettings(configPath, {
+            worker_name: workerName,
+            base_domain: baseDomain,
+            show_response_output: showResponseOutput,
+        });
+        Logger.info('Settings updated.');
+    }
+    catch (error) {
+        const errorMessage = (error instanceof Error) ? error['message'] : String(error);
+        Logger.error(`Error: ${errorMessage}`);
+    }
+    return;
+}
+export { interactiveMenu, };
+//# sourceMappingURL=interactive.js.map