@axium/server 0.9.0 → 0.11.0

package/dist/cli.js

@@ -51,15 +51,35 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
+import { formatDateRange } from '@axium/core/format';
 import { Argument, Option, program } from 'commander';
+import { access } from 'node:fs/promises';
+import { join } from 'node:path/posix';
+import { createInterface } from 'node:readline/promises';
 import { styleText } from 'node:util';
 import { getByString, isJSON, setByString } from 'utilium';
+import z from 'zod/v4';
 import $pkg from '../package.json' with { type: 'json' };
-import config from './config.js';
-import * as db from './database.js';
-import { _portActions, _portMethods, exit, handleError, output, restrictedPorts } from './io.js';
-import { loadDefaultPlugins, plugins, pluginText, resolvePlugin } from './plugins.js';
 import { apps } from './apps.js';
+import config, { configFiles, saveConfigTo } from './config.js';
+import * as db from './database.js';
+import { _portActions, _portMethods, exit, handleError, output, restrictedPorts, setCommandTimeout, warn } from './io.js';
+import { linkRoutes, listRouteLinks, unlinkRoutes } from './linking.js';
+import { getSpecifier, plugins, pluginText, resolvePlugin } from './plugins.js';
+import { serve } from './serve.js';
+function readline() {
+    const rl = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return Object.assign(rl, {
+        [Symbol.dispose]: rl.close.bind(rl),
+    });
+}
+function userText(user, bold = false) {
+    const text = `${user.name} <${user.email}> (${user.id})`;
+    return bold ? styleText('bold', text) : text;
+}
 program
     .version($pkg.version)
     .name('axium')
@@ -72,15 +92,10 @@ program.on('option:debug', () => config.set({ debug: true }));
 program.on('option:config', () => void config.load(program.opts().config));
 program.hook('preAction', async function (_, action) {
     await config.loadDefaults();
-    await loadDefaultPlugins();
     const opt = action.optsWithGlobals();
     opt.force && output.warn('--force: Protections disabled.');
     if (opt.debug === false)
         config.set({ debug: false });
-    /* if (!config.auth.secret) {
-        config.save({ auth: { secret: process.env.AUTH_SECRET || randomBytes(32).toString('base64') } }, true);
-        output.debug('Auto-generated a new auth secret');
-    } */
 });
 // Options shared by multiple (sub)commands
 const opts = {
@@ -92,13 +107,14 @@ const opts = {
     }),
     force: new Option('-f, --force', 'force the operation').default(false),
     global: new Option('-g, --global', 'apply the operation globally').default(false),
+    timeout: new Option('-t, --timeout <ms>', 'how long to wait for commands to complete.').default('1000').argParser(value => {
+        const timeout = parseInt(value);
+        if (!Number.isSafeInteger(timeout) || timeout < 0)
+            warn('Invalid timeout value, using default.');
+        setCommandTimeout(timeout);
+    }),
 };
-const axiumDB = program
-    .command('db')
-    .alias('database')
-    .description('Manage the database')
-    .option('-t, --timeout <ms>', 'how long to wait for commands to complete.', '1000')
-    .addOption(opts.host);
+const axiumDB = program.command('db').alias('database').description('Manage the database').addOption(opts.timeout).addOption(opts.host);
 axiumDB
     .command('init')
     .description('Initialize the database')
@@ -255,11 +271,7 @@ axiumConfig
     for (const path of config.files.keys())
         console.log(path);
 });
-const axiumPlugin = program
-    .command('plugins')
-    .description('Manage plugins')
-    .addOption(opts.global)
-    .option('--safe', 'do not perform actions that would execute code from plugins.');
+const axiumPlugin = program.command('plugins').description('Manage plugins').addOption(opts.global);
 axiumPlugin
     .command('list')
     .alias('ls')
@@ -279,7 +291,7 @@ axiumPlugin
     }
     console.log(styleText('whiteBright', plugins.size + ' plugin(s) loaded:'));
     for (const plugin of plugins) {
-        console.log(plugin.name, styleText('dim', `(${plugin.id})`), opt.versions ? plugin.version : '');
+        console.log(plugin.name, opt.versions ? plugin.version : '');
     }
 });
 axiumPlugin
@@ -292,6 +304,64 @@ axiumPlugin
         exit(`Can't find a plugin matching "${search}"`);
     console.log(pluginText(plugin));
 });
+axiumPlugin
+    .command('remove')
+    .alias('rm')
+    .description('Remove a plugin')
+    .argument('<plugin>', 'the plugin to remove')
+    .action(async (search, opt) => {
+    const env_4 = { stack: [], error: void 0, hasError: false };
+    try {
+        const plugin = resolvePlugin(search);
+        if (!plugin)
+            exit(`Can't find a plugin matching "${search}"`);
+        const specifier = getSpecifier(plugin);
+        const _ = __addDisposableResource(env_4, db.connect(), true);
+        await plugin.hooks.remove?.(opt, db.database);
+        for (const [path, data] of configFiles) {
+            if (!data.plugins)
+                continue;
+            data.plugins = data.plugins.filter(p => p !== specifier);
+            saveConfigTo(path, data);
+        }
+        plugins.delete(plugin);
+    }
+    catch (e_4) {
+        env_4.error = e_4;
+        env_4.hasError = true;
+    }
+    finally {
+        const result_4 = __disposeResources(env_4);
+        if (result_4)
+            await result_4;
+    }
+});
+axiumPlugin
+    .command('init')
+    .alias('setup')
+    .alias('install')
+    .description('Initialize a plugin. This could include adding tables to the database or linking routes.')
+    .addOption(opts.timeout)
+    .argument('<plugin>', 'the plugin to initialize')
+    .action(async (search, opt) => {
+    const env_5 = { stack: [], error: void 0, hasError: false };
+    try {
+        const plugin = resolvePlugin(search);
+        if (!plugin)
+            exit(`Can't find a plugin matching "${search}"`);
+        const _ = __addDisposableResource(env_5, db.connect(), true);
+        await plugin.hooks.db_init?.({ force: false, ...opt, skip: true }, db.database);
+    }
+    catch (e_5) {
+        env_5.error = e_5;
+        env_5.hasError = true;
+    }
+    finally {
+        const result_5 = __disposeResources(env_5);
+        if (result_5)
+            await result_5;
+    }
+});
 const axiumApps = program.command('apps').description('Manage Axium apps').addOption(opts.global);
 axiumApps
     .command('list')
@@ -313,28 +383,186 @@ axiumApps
         console.log(app.name, styleText('dim', `(${app.id})`));
     }
 });
+const lookup = new Argument('<user>', 'the UUID or email of the user to operate on').argParser(async (lookup) => {
+    const value = await (lookup.includes('@') ? z.email() : z.uuid())
+        .parseAsync(lookup.toLowerCase())
+        .catch(() => exit('Invalid user ID or email.'));
+    db.connect();
+    const result = await db.database
+        .selectFrom('users')
+        .where(value.includes('@') ? 'email' : 'id', '=', value)
+        .selectAll()
+        .executeTakeFirst();
+    if (!result)
+        exit('No user with matching ID or email.');
+    return result;
+});
+/**
+ * Updates an array of strings by adding or removing items.
+ * Only returns whether the array was updated and diff text for what actually changed.
+ */
+function diffUpdate(original, add, remove) {
+    const diffs = [];
+    // update the values
+    if (add) {
+        for (const role of add) {
+            if (original.includes(role))
+                continue;
+            original.push(role);
+            diffs.push(styleText('green', '+' + role));
+        }
+    }
+    if (remove)
+        original = original.filter(item => {
+            const allow = !remove.includes(item);
+            if (!allow)
+                diffs.push(styleText('red', '-' + item));
+            return allow;
+        });
+    return [!!diffs.length, original, diffs.join(', ')];
+}
+program
+    .command('user')
+    .description('Get or change information about a user')
+    .addArgument(lookup)
+    .option('-S, --sessions', 'show user sessions')
+    .option('-P, --passkeys', 'show user passkeys')
+    .option('--add-role <role...>', 'add roles to the user')
+    .option('--remove-role <role...>', 'remove roles from the user')
+    .option('--tag <tag...>', 'Add tags to the user')
+    .option('--untag <tag...>', 'Remove tags from the user')
+    .option('--delete', 'Delete the user')
+    .action(async (_user, opt) => {
+    const env_6 = { stack: [], error: void 0, hasError: false };
+    try {
+        let user = await _user;
+        const _ = __addDisposableResource(env_6, db.connect(), true);
+        const [updatedRoles, roles, rolesDiff] = diffUpdate(user.roles, opt.addRole, opt.removeRole);
+        const [updatedTags, tags, tagsDiff] = diffUpdate(user.tags, opt.tag, opt.untag);
+        if (updatedRoles || updatedTags) {
+            user = await db.database
+                .updateTable('users')
+                .set({ roles, tags })
+                .returningAll()
+                .executeTakeFirstOrThrow()
+                .then(u => {
+                if (updatedRoles && rolesDiff)
+                    console.log(`> Updated roles: ${rolesDiff}`);
+                if (updatedTags && tagsDiff)
+                    console.log(`> Updated tags: ${tagsDiff}`);
+                return u;
+            })
+                .catch(e => exit('Failed to update user roles: ' + e.message));
+        }
+        if (opt.delete) {
+            const env_7 = { stack: [], error: void 0, hasError: false };
+            try {
+                const rl = __addDisposableResource(env_7, readline(), false);
+                const confirmed = await rl
+                    .question(`Are you sure you want to delete ${userText(user, true)}? (y/N) `)
+                    .then(v => z.stringbool().parseAsync(v))
+                    .catch(() => false);
+                if (!confirmed)
+                    console.log(styleText('dim', '> Delete aborted.'));
+                else
+                    await db.database
+                        .deleteFrom('users')
+                        .where('id', '=', user.id)
+                        .executeTakeFirstOrThrow()
+                        .then(() => console.log(styleText(['red', 'bold'], '> Deleted')))
+                        .catch(e => exit('Failed to delete user: ' + e.message));
+            }
+            catch (e_6) {
+                env_7.error = e_6;
+                env_7.hasError = true;
+            }
+            finally {
+                __disposeResources(env_7);
+            }
+        }
+        console.log([
+            user.isAdmin && styleText('redBright', 'Administrator'),
+            'UUID: ' + user.id,
+            'Name: ' + user.name,
+            `Email: ${user.email}, ${user.emailVerified ? 'verified on ' + formatDateRange(user.emailVerified) : styleText(config.auth.email_verification ? 'yellow' : 'dim', 'not verified')}`,
+            'Registered ' + formatDateRange(user.registeredAt),
+            `Roles: ${user.roles.length ? user.roles.join(', ') : styleText('dim', '(none)')}`,
+            `Tags: ${user.tags.length ? user.tags.join(', ') : styleText('dim', '(none)')}`,
+        ]
+            .filter(Boolean)
+            .join('\n'));
+        if (opt.sessions) {
+            const sessions = await db.database.selectFrom('sessions').where('userId', '=', user.id).selectAll().execute();
+            console.log(styleText('bold', 'Sessions:'));
+            if (!sessions.length)
+                console.log(styleText('dim', '(none)'));
+            else
+                for (const session of sessions) {
+                    console.log(`\t${session.id}\tcreated ${formatDateRange(session.created).padEnd(40)}\texpires ${formatDateRange(session.expires).padEnd(40)}\t${session.elevated ? styleText('yellow', '(elevated)') : ''}`);
+                }
+        }
+        if (opt.passkeys) {
+            const passkeys = await db.database.selectFrom('passkeys').where('userId', '=', user.id).selectAll().execute();
+            console.log(styleText('bold', 'Passkeys:'));
+            for (const passkey of passkeys) {
+                console.log(`\t${passkey.id}: created ${formatDateRange(passkey.createdAt).padEnd(40)} used ${passkey.counter} times. ${passkey.deviceType}, ${passkey.backedUp ? '' : 'not '}backed up; transports are [${passkey.transports.join(', ')}], ${passkey.name ? 'named ' + JSON.stringify(passkey.name) : 'unnamed'}.`);
+            }
+        }
+    }
+    catch (e_7) {
+        env_6.error = e_7;
+        env_6.hasError = true;
+    }
+    finally {
+        const result_6 = __disposeResources(env_6);
+        if (result_6)
+            await result_6;
+    }
+});
+program
+    .command('toggle-admin')
+    .description('Toggle whether a user is an administrator')
+    .addArgument(lookup)
+    .action(async (_user) => {
+    const env_8 = { stack: [], error: void 0, hasError: false };
+    try {
+        const user = await _user;
+        const _ = __addDisposableResource(env_8, db.connect(), true);
+        const isAdmin = !user.isAdmin;
+        await db.database.updateTable('users').set({ isAdmin }).where('id', '=', user.id).executeTakeFirstOrThrow();
+        console.log(`${userText(user)} is ${isAdmin ? 'now' : 'no longer'} an administrator. (${styleText(['whiteBright', 'bold'], isAdmin.toString())})`);
+    }
+    catch (e_8) {
+        env_8.error = e_8;
+        env_8.hasError = true;
+    }
+    finally {
+        const result_7 = __disposeResources(env_8);
+        if (result_7)
+            await result_7;
+    }
+});
 program
     .command('status')
     .alias('stats')
     .description('Get information about the server')
     .addOption(opts.host)
     .action(async () => {
-    const env_4 = { stack: [], error: void 0, hasError: false };
+    const env_9 = { stack: [], error: void 0, hasError: false };
     try {
         console.log('Axium Server v' + program.version());
         console.log(styleText('whiteBright', 'Debug mode:'), config.debug ? styleText('yellow', 'enabled') : 'disabled');
         console.log(styleText('whiteBright', 'Loaded config files:'), config.files.keys().toArray().join(', '));
         process.stdout.write(styleText('whiteBright', 'Database: '));
-        const _ = __addDisposableResource(env_4, db.connect(), true);
+        const _ = __addDisposableResource(env_9, db.connect(), true);
         try {
             console.log(await db.statusText());
         }
         catch {
             output.error('Unavailable');
         }
-        console.log(styleText('whiteBright', 'Credentials authentication:'), config.auth.credentials ? styleText('yellow', 'enabled') : 'disabled');
         console.log(styleText('whiteBright', 'Loaded plugins:'), Array.from(plugins)
-            .map(plugin => plugin.id)
+            .map(plugin => plugin.name)
             .join(', ') || styleText('dim', '(none)'));
         for (const plugin of plugins) {
             if (!plugin.statusText)
@@ -343,14 +571,14 @@ program
             console.log(await plugin.statusText());
         }
     }
-    catch (e_4) {
-        env_4.error = e_4;
-        env_4.hasError = true;
+    catch (e_9) {
+        env_9.error = e_9;
+        env_9.hasError = true;
     }
     finally {
-        const result_4 = __disposeResources(env_4);
-        if (result_4)
-            await result_4;
+        const result_8 = __disposeResources(env_9);
+        if (result_8)
+            await result_8;
     }
 });
 program
@@ -368,8 +596,37 @@ program
     .addOption(opts.force)
     .addOption(opts.host)
     .action(async (opt) => {
-    /* config.save({ auth: { secret: randomBytes(32).toString('base64') } }, true); */
     await db.init({ ...opt, skip: opt.dbSkip }).catch(handleError);
     await restrictedPorts({ method: 'node-cap', action: 'enable' }).catch(handleError);
 });
+program
+    .command('serve')
+    .description('Start the Axium server')
+    .option('-p, --port <port>', 'the port to listen on')
+    .option('--ssl <prefix>', 'the prefix for the cert.pem and key.pem SSL files')
+    .action(async (opt) => {
+    const server = await serve({
+        secure: opt.ssl ? true : config.web.secure,
+        ssl_cert: opt.ssl ? join(opt.ssl, 'cert.pem') : config.web.ssl_cert,
+        ssl_key: opt.ssl ? join(opt.ssl, 'key.pem') : config.web.ssl_key,
+    });
+    const port = !Number.isNaN(Number.parseInt(opt.port ?? '')) ? Number.parseInt(opt.port) : config.web.port;
+    server.listen(port, () => {
+        console.log('Server is listening on port ' + port);
+    });
+});
+program.command('link').description('Link svelte page routes').action(linkRoutes);
+program.command('unlink').description('Unlink svelte page routes').action(unlinkRoutes);
+program
+    .command('list-links')
+    .description('List linked routes')
+    .action(async () => {
+    for (const link of listRouteLinks()) {
+        const idText = link.id.startsWith('#') ? `(${link.id.slice(1)})` : link.id;
+        const toColor = await access(link.to)
+            .then(() => 'white')
+            .catch(() => 'redBright');
+        console.log(`${idText}:\t ${styleText('cyanBright', link.from)}\t->\t${styleText(toColor, link.to)}`);
+    }
+});
 program.parse();

package/dist/config.d.ts

@@ -10,8 +10,6 @@ export interface Config extends Record<string, unknown> {
         disabled: string[];
     };
     auth: {
-        credentials: boolean;
-        debug: boolean;
         origin: string;
         /** In minutes */
         passkey_probation: number;
@@ -36,20 +34,28 @@ export interface Config extends Record<string, unknown> {
         console: boolean;
     };
     web: {
+        assets: string;
+        disable_cache: boolean;
+        port: number;
         prefix: string;
+        routes: string;
+        secure: boolean;
+        ssl_key: string;
+        ssl_cert: string;
+        template: string;
     };
 }
-export declare const configFiles: Map<string, PartialRecursive<Config>>;
+export declare const configFiles: Map<string, File>;
 export declare function plainConfig(): Omit<Config, keyof typeof configShortcuts>;
 declare const configShortcuts: {
-    findPath: typeof findConfigPath;
+    findPath: typeof findConfigPaths;
     load: typeof loadConfig;
     loadDefaults: typeof loadDefaultConfigs;
     plain: typeof plainConfig;
     save: typeof saveConfig;
     saveTo: typeof saveConfigTo;
     set: typeof setConfig;
-    files: Map<string, PartialRecursive<Config>>;
+    files: Map<string, File>;
 };
 export declare const config: Config & typeof configShortcuts;
 export default config;
@@ -62,8 +68,6 @@ export declare const File: z.ZodObject<{
         disabled: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>>;
     auth: z.ZodOptional<z.ZodObject<{
-        credentials: z.ZodOptional<z.ZodBoolean>;
-        debug: z.ZodOptional<z.ZodBoolean>;
         origin: z.ZodOptional<z.ZodString>;
         passkey_probation: z.ZodOptional<z.ZodNumber>;
         rp_id: z.ZodOptional<z.ZodString>;
@@ -91,13 +95,22 @@ export declare const File: z.ZodObject<{
         console: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;
     web: z.ZodOptional<z.ZodObject<{
+        assets: z.ZodOptional<z.ZodString>;
+        disable_cache: z.ZodOptional<z.ZodBoolean>;
+        port: z.ZodOptional<z.ZodNumber>;
         prefix: z.ZodOptional<z.ZodString>;
+        routes: z.ZodOptional<z.ZodString>;
+        secure: z.ZodOptional<z.ZodBoolean>;
+        ssl_key: z.ZodOptional<z.ZodString>;
+        ssl_cert: z.ZodOptional<z.ZodString>;
+        template: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
     include: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
     plugins: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
 }, z.core.$loose>;
 export interface File extends PartialRecursive<Config>, z.infer<typeof File> {
 }
+export declare function addConfigDefaults(other: PartialRecursive<Config>, _target?: Record<string, any>): void;
 /**
  * Update the current config
  */
@@ -132,4 +145,4 @@ export declare function saveConfigTo(path: string, changed: PartialRecursive<Con
 /**
  * Find the path to the config file
  */
-export declare function findConfigPath(global: boolean): string;
+export declare function findConfigPaths(): string[];

package/dist/config.js

@@ -3,14 +3,15 @@ import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path/posix';
 import { deepAssign, omit } from 'utilium';
 import * as z from 'zod/v4';
-import { findDir, logger, output } from './io.js';
+import { _setDebugOutput, dirs, logger, output } from './io.js';
 import { loadPlugin } from './plugins.js';
-export const configFiles = new Map();
+import { _unique } from './state.js';
+export const configFiles = _unique('configFiles', new Map());
 export function plainConfig() {
     return omit(config, Object.keys(configShortcuts));
 }
 const configShortcuts = {
-    findPath: findConfigPath,
+    findPath: findConfigPaths,
     load: loadConfig,
     loadDefaults: loadDefaultConfigs,
     plain: plainConfig,
@@ -19,18 +20,16 @@ const configShortcuts = {
     set: setConfig,
     files: configFiles,
 };
-export const config = {
+export const config = _unique('config', {
     ...configShortcuts,
     api: {
         disable_metadata: false,
-        cookie_auth: false,
+        cookie_auth: true,
     },
     apps: {
         disabled: [],
     },
     auth: {
-        credentials: false,
-        debug: false,
         origin: 'https://test.localhost',
         passkey_probation: 60,
         rp_id: 'test.localhost',
@@ -52,9 +51,17 @@ export const config = {
         level: 'info',
     },
     web: {
+        assets: '',
+        disable_cache: false,
+        port: 443,
         prefix: '',
+        routes: 'routes',
+        secure: true,
+        ssl_key: resolve(dirs[0], 'ssl_key.pem'),
+        ssl_cert: resolve(dirs[0], 'ssl_cert.pem'),
+        template: join(import.meta.dirname, '../web/template.html'),
     },
-};
+});
 export default config;
 // config from file
 export const File = z
@@ -72,8 +79,6 @@ export const File = z
         .partial(),
     auth: z
         .object({
-        credentials: z.boolean(),
-        debug: z.boolean(),
         origin: z.string(),
         /** In minutes */
         passkey_probation: z.number(),
@@ -104,13 +109,32 @@ export const File = z
         .partial(),
     web: z
         .object({
+        assets: z.string(),
+        disable_cache: z.boolean(),
+        port: z.number().min(1).max(65535),
         prefix: z.string(),
+        routes: z.string(),
+        secure: z.boolean(),
+        ssl_key: z.string(),
+        ssl_cert: z.string(),
+        template: z.string(),
     })
         .partial(),
     include: z.array(z.string()).optional(),
     plugins: z.array(z.string()).optional(),
 })
     .partial();
+export function addConfigDefaults(other, _target = config) {
+    for (const [key, value] of Object.entries(other)) {
+        if (!(key in _target) || _target[key] === null || _target[key] === undefined || Number.isNaN(_target[key])) {
+            _target[key] = value;
+            continue;
+        }
+        if (typeof value == 'object' && value != null && typeof _target[key] == 'object') {
+            addConfigDefaults(value, _target[key]);
+        }
+    }
+}
 /**
  * Update the current config
  */
@@ -119,11 +143,14 @@ export function setConfig(other) {
     logger.detach(output);
     if (config.log.console)
         logger.attach(output, { output: config.log.level });
+    _setDebugOutput(config.debug);
 }
 /**
  * Load the config from the provided path
  */
 export async function loadConfig(path, options = {}) {
+    if (configFiles.has(path))
+        return;
     let json;
     try {
         json = JSON.parse(readFileSync(path, 'utf8'));
@@ -131,19 +158,20 @@ export async function loadConfig(path, options = {}) {
     catch (e) {
         if (!options.optional)
             throw e;
-        config.debug && output.debug(`Skipping config at ${path} (${e.message})`);
+        output.debug(`Skipping config at ${path} (${e.message})`);
         return;
     }
     const file = options.strict ? File.parse(json) : json;
     configFiles.set(path, file);
     setConfig(file);
+    output.debug('Loaded config: ' + path);
     for (const include of file.include ?? [])
         await loadConfig(join(dirname(path), include), { optional: true });
     for (const plugin of file.plugins ?? [])
         await loadPlugin(plugin.startsWith('.') ? resolve(dirname(path), plugin) : plugin);
 }
 export async function loadDefaultConfigs() {
-    for (const path of [findConfigPath(true), findConfigPath(false)]) {
+    for (const path of findConfigPaths()) {
         if (!existsSync(path))
             writeFileSync(path, '{}');
         await loadConfig(path, { optional: true });
@@ -153,7 +181,7 @@ export async function loadDefaultConfigs() {
  * Update the current config and write the updated config to the appropriate file
  */
 export function saveConfig(changed, global = false) {
-    saveConfigTo(process.env.AXIUM_CONFIG ?? findConfigPath(global), changed);
+    saveConfigTo(findConfigPaths().at(global ? 0 : -1), changed);
 }
 /**
  * Update the current config and write the updated config to the provided path
@@ -162,16 +190,17 @@ export function saveConfigTo(path, changed) {
     setConfig(changed);
     const config = configFiles.get(path) ?? {};
     Object.assign(config, { ...changed, db: { ...config.db, ...changed.db } });
-    config.debug && output.debug(`Wrote config to ${path}`);
+    output.debug(`Wrote config to ${path}`);
     writeFileSync(path, JSON.stringify(config));
 }
 /**
  * Find the path to the config file
  */
-export function findConfigPath(global) {
+export function findConfigPaths() {
+    const paths = dirs.map(dir => join(dir, 'config.json'));
     if (process.env.AXIUM_CONFIG)
-        return process.env.AXIUM_CONFIG;
-    return join(findDir(global), 'config.json');
+        paths.push(process.env.AXIUM_CONFIG);
+    return paths;
 }
 if (process.env.AXIUM_CONFIG)
     await loadConfig(process.env.AXIUM_CONFIG);