@axium/server 0.24.1 → 0.26.0

package/dist/config.d.ts

@@ -1,6 +1,7 @@
 import { type DeepRequired } from 'utilium';
 import * as z from 'zod';
 export declare const ConfigSchema: z.ZodObject<{
+    admin_api: z.ZodOptional<z.ZodBoolean>;
     allow_new_users: z.ZodOptional<z.ZodBoolean>;
     apps: z.ZodOptional<z.ZodObject<{
         disabled: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -8,8 +9,8 @@ export declare const ConfigSchema: z.ZodObject<{
     audit: z.ZodOptional<z.ZodObject<{
         allow_raw: z.ZodOptional<z.ZodBoolean>;
         retention: z.ZodOptional<z.ZodNumber>;
-        min_severity: z.ZodOptional<z.ZodLiteral<"error" | "debug" | "Error" | "notice" | "info" | "warning" | "Emergency" | "Alert" | "Critical" | "Warning" | "Notice" | "Info" | "Debug" | "emergency" | "alert" | "critical">>;
-        auto_suspend: z.ZodOptional<z.ZodLiteral<"error" | "debug" | "Error" | "notice" | "info" | "warning" | "Emergency" | "Alert" | "Critical" | "Warning" | "Notice" | "Info" | "Debug" | "emergency" | "alert" | "critical">>;
+        min_severity: z.ZodOptional<z.ZodLiteral<"Emergency" | "Alert" | "Critical" | "Error" | "Warning" | "Notice" | "Info" | "Debug" | "emergency" | "alert" | "critical" | "error" | "warning" | "notice" | "info" | "debug">>;
+        auto_suspend: z.ZodOptional<z.ZodLiteral<"Emergency" | "Alert" | "Critical" | "Error" | "Warning" | "Notice" | "Info" | "Debug" | "emergency" | "alert" | "critical" | "error" | "warning" | "notice" | "info" | "debug">>;
     }, z.core.$loose>>;
     auth: z.ZodOptional<z.ZodObject<{
         origin: z.ZodOptional<z.ZodString>;
@@ -33,17 +34,16 @@ export declare const ConfigSchema: z.ZodObject<{
     log: z.ZodOptional<z.ZodObject<{
         level: z.ZodOptional<z.ZodEnum<{
             error: "error";
-            debug: "debug";
-            warn: "warn";
             notice: "notice";
             info: "info";
+            debug: "debug";
+            warn: "warn";
         }>>;
         console: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$loose>>;
+    request_size_limit: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
     show_duplicate_state: z.ZodOptional<z.ZodBoolean>;
     web: z.ZodOptional<z.ZodObject<{
-        assets: z.ZodOptional<z.ZodString>;
-        build: z.ZodOptional<z.ZodString>;
         disable_cache: z.ZodOptional<z.ZodBoolean>;
         port: z.ZodOptional<z.ZodNumber>;
         prefix: z.ZodOptional<z.ZodString>;
@@ -51,13 +51,13 @@ export declare const ConfigSchema: z.ZodObject<{
         secure: z.ZodOptional<z.ZodBoolean>;
         ssl_key: z.ZodOptional<z.ZodString>;
         ssl_cert: z.ZodOptional<z.ZodString>;
-        template: z.ZodOptional<z.ZodString>;
     }, z.core.$loose>>;
 }, z.core.$loose>;
 export interface Config extends z.infer<typeof ConfigSchema> {
 }
 export declare const configFiles: Map<string, File>;
 export declare function plainConfig(): Omit<DeepRequired<Config>, keyof typeof configShortcuts>;
+export declare const defaultConfig: DeepRequired<Config>;
 declare const configShortcuts: {
     findPath: typeof findConfigPaths;
     load: typeof loadConfig;
@@ -67,12 +67,14 @@ declare const configShortcuts: {
     saveTo: typeof saveConfigTo;
     set: typeof setConfig;
     files: Map<string, File>;
+    defaults: DeepRequired<Config>;
 };
 export declare const config: DeepRequired<Config> & typeof configShortcuts;
 export default config;
 export declare const FileSchema: z.ZodObject<{
     include: z.ZodOptional<z.ZodArray<z.ZodString>>;
     plugins: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    admin_api: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
     allow_new_users: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
     apps: z.ZodOptional<z.ZodOptional<z.ZodObject<{
         disabled: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -80,8 +82,8 @@ export declare const FileSchema: z.ZodObject<{
     audit: z.ZodOptional<z.ZodOptional<z.ZodObject<{
         allow_raw: z.ZodOptional<z.ZodBoolean>;
         retention: z.ZodOptional<z.ZodNumber>;
-        min_severity: z.ZodOptional<z.ZodLiteral<"error" | "debug" | "Error" | "notice" | "info" | "warning" | "Emergency" | "Alert" | "Critical" | "Warning" | "Notice" | "Info" | "Debug" | "emergency" | "alert" | "critical">>;
-        auto_suspend: z.ZodOptional<z.ZodLiteral<"error" | "debug" | "Error" | "notice" | "info" | "warning" | "Emergency" | "Alert" | "Critical" | "Warning" | "Notice" | "Info" | "Debug" | "emergency" | "alert" | "critical">>;
+        min_severity: z.ZodOptional<z.ZodLiteral<"Emergency" | "Alert" | "Critical" | "Error" | "Warning" | "Notice" | "Info" | "Debug" | "emergency" | "alert" | "critical" | "error" | "warning" | "notice" | "info" | "debug">>;
+        auto_suspend: z.ZodOptional<z.ZodLiteral<"Emergency" | "Alert" | "Critical" | "Error" | "Warning" | "Notice" | "Info" | "Debug" | "emergency" | "alert" | "critical" | "error" | "warning" | "notice" | "info" | "debug">>;
     }, z.core.$loose>>>;
     auth: z.ZodOptional<z.ZodOptional<z.ZodObject<{
         origin: z.ZodOptional<z.ZodString>;
@@ -105,17 +107,16 @@ export declare const FileSchema: z.ZodObject<{
     log: z.ZodOptional<z.ZodOptional<z.ZodObject<{
         level: z.ZodOptional<z.ZodEnum<{
             error: "error";
-            debug: "debug";
-            warn: "warn";
             notice: "notice";
             info: "info";
+            debug: "debug";
+            warn: "warn";
         }>>;
         console: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$loose>>>;
+    request_size_limit: z.ZodOptional<z.ZodOptional<z.ZodOptional<z.ZodNumber>>>;
     show_duplicate_state: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
     web: z.ZodOptional<z.ZodOptional<z.ZodObject<{
-        assets: z.ZodOptional<z.ZodString>;
-        build: z.ZodOptional<z.ZodString>;
         disable_cache: z.ZodOptional<z.ZodBoolean>;
         port: z.ZodOptional<z.ZodNumber>;
         prefix: z.ZodOptional<z.ZodString>;
@@ -123,12 +124,11 @@ export declare const FileSchema: z.ZodObject<{
         secure: z.ZodOptional<z.ZodBoolean>;
         ssl_key: z.ZodOptional<z.ZodString>;
         ssl_cert: z.ZodOptional<z.ZodString>;
-        template: z.ZodOptional<z.ZodString>;
     }, z.core.$loose>>>;
 }, z.core.$loose>;
 export interface File extends z.infer<typeof FileSchema> {
 }
-export declare function addConfigDefaults(other: Config, _target?: Record<string, any>): void;
+export declare function addConfigDefaults(other: Config, _target?: Record<string, any>, _noDefault?: boolean): void;
 /**
  * Update the current config
  */
@@ -142,16 +142,26 @@ export interface LoadOptions {
      * If enabled, the config file will be skipped if it does not exist.
      */
     optional?: boolean;
+    /**
+     * If enabled, code from plugins will not be executed.
+     */
+    safe?: boolean;
     /**
      * If `optional`, this function will be called with the error if the config file is invalid or can't be read.
      */
     onError?(error: Error): void;
+    /**
+     * Used to mark included files
+     * @internal
+     */
+    _markIncluded?: boolean;
 }
 /**
  * Load the config from the provided path
  */
 export declare function loadConfig(path: string, options?: LoadOptions): Promise<void>;
-export declare function loadDefaultConfigs(): Promise<void>;
+export declare function loadDefaultConfigs(safe?: boolean): Promise<void>;
+export declare function reloadConfigs(safe?: boolean): Promise<void>;
 /**
  * Update the current config and write the updated config to the appropriate file
  */

package/dist/config.js

@@ -1,15 +1,18 @@
+import * as io from '@axium/core/node/io';
+import { loadPlugin } from '@axium/core/node/plugins';
 import { levelText } from 'logzen';
 import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path/posix';
 import { capitalize, deepAssign, omit } from 'utilium';
 import * as z from 'zod';
-import { _setDebugOutput, dirs, logger, output } from './io.js';
-import { loadPlugin } from './plugins.js';
+import { dirs, logger, systemDir } from './io.js';
 import { _duplicateStateWarnings, _unique } from './state.js';
 const audit_severity_levels = ['emergency', 'alert', 'critical', 'error', 'warning', 'notice', 'info', 'debug'];
 const z_audit_severity = z.literal([...audit_severity_levels, ...audit_severity_levels.map(capitalize)]);
 export const ConfigSchema = z
     .looseObject({
+    /** Whether /api/admin is enabled */
+    admin_api: z.boolean(),
     allow_new_users: z.boolean(),
     apps: z
         .looseObject({
@@ -59,11 +62,10 @@ export const ConfigSchema = z
         console: z.boolean(),
     })
         .partial(),
+    request_size_limit: z.number().min(0).optional(),
     show_duplicate_state: z.boolean(),
     web: z
         .looseObject({
-        assets: z.string(),
-        build: z.string(),
         disable_cache: z.boolean(),
         port: z.number().min(1).max(65535),
         prefix: z.string(),
@@ -71,7 +73,6 @@ export const ConfigSchema = z
         secure: z.boolean(),
         ssl_key: z.string(),
         ssl_cert: z.string(),
-        template: z.string(),
     })
         .partial(),
 })
@@ -80,18 +81,8 @@ export const configFiles = _unique('configFiles', new Map());
 export function plainConfig() {
     return omit(config, Object.keys(configShortcuts));
 }
-const configShortcuts = {
-    findPath: findConfigPaths,
-    load: loadConfig,
-    loadDefaults: loadDefaultConfigs,
-    plain: plainConfig,
-    save: saveConfig,
-    saveTo: saveConfigTo,
-    set: setConfig,
-    files: configFiles,
-};
-export const config = _unique('config', {
-    ...configShortcuts,
+export const defaultConfig = {
+    admin_api: true,
     allow_new_users: true,
     apps: {
         disabled: [],
@@ -131,9 +122,8 @@ export const config = _unique('config', {
         level: 'info',
     },
     show_duplicate_state: false,
+    request_size_limit: 0,
     web: {
-        assets: '',
-        build: '../build/handler.js',
         disable_cache: false,
         port: 443,
         prefix: '',
@@ -141,26 +131,42 @@ export const config = _unique('config', {
         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'),
     },
+};
+const configShortcuts = {
+    findPath: findConfigPaths,
+    load: loadConfig,
+    loadDefaults: loadDefaultConfigs,
+    plain: plainConfig,
+    save: saveConfig,
+    saveTo: saveConfigTo,
+    set: setConfig,
+    files: configFiles,
+    defaults: defaultConfig,
+};
+export const config = _unique('config', {
+    ...configShortcuts,
+    ...defaultConfig,
 });
 export default config;
 // config from file
 export const FileSchema = z
     .looseObject({
     ...ConfigSchema.shape,
-    include: z.array(z.string()),
-    plugins: z.array(z.string()),
+    include: z.string().array(),
+    plugins: z.string().array(),
 })
     .partial();
-export function addConfigDefaults(other, _target = config) {
+export function addConfigDefaults(other, _target = config, _noDefault = false) {
+    if (!_noDefault)
+        deepAssign(defaultConfig, other);
     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]);
+            addConfigDefaults(value, _target[key], true);
         }
     }
 }
@@ -169,12 +175,13 @@ export function addConfigDefaults(other, _target = config) {
  */
 export function setConfig(other) {
     deepAssign(config, other);
-    logger.detach(output);
+    logger.detach(io);
     if (config.log.console)
-        logger.attach(output, { output: config.log.level });
-    _setDebugOutput(config.debug);
+        logger.attach(io, { output: config.log.level });
+    io._setDebugOutput(config.debug);
     _duplicateStateWarnings(config.show_duplicate_state);
 }
+const kWasIncluded = Symbol.for('_wasIncluded');
 /**
  * Load the config from the provided path
  */
@@ -186,9 +193,20 @@ export async function loadConfig(path, options = {}) {
         json = JSON.parse(readFileSync(path, 'utf8'));
     }
     catch (e) {
+        if (path == join(systemDir, 'config.json') && 'code' in e && e.code === 'ENOENT') {
+            try {
+                writeFileSync(path, '{}');
+            }
+            catch {
+                io.warn('Failed to create the main configuration file (/etc/axium/config.json): ' + e.message);
+                return;
+            }
+            io.debug('Created main configuration file (fresh install?)');
+            return;
+        }
         if (!options.optional)
             throw e;
-        output.debug(`Skipping config at ${path} (${e.message})`);
+        io.debug(`Skipping config at ${path} (${e.message})`);
         return;
     }
     let file;
@@ -198,18 +216,18 @@ export async function loadConfig(path, options = {}) {
     catch (e) {
         if (!options.loose)
             throw e;
-        output.debug(`Loading invalid config from ${path} (${e.message})`);
+        io.debug(`Loading invalid config from ${path} (${e.message})`);
         file = json;
     }
-    configFiles.set(path, file);
+    configFiles.set(path, { ...file, [kWasIncluded]: !!options._markIncluded });
     setConfig(file);
-    output.debug('Loaded config: ' + path);
+    io.debug('Loaded config: ' + path);
     for (const include of file.include ?? [])
-        await loadConfig(resolve(dirname(path), include), { optional: true });
+        await loadConfig(resolve(dirname(path), include), { ...options, optional: true, _markIncluded: true });
     for (const plugin of file.plugins ?? [])
-        await loadPlugin(plugin.startsWith('.') ? resolve(dirname(path), plugin) : plugin);
+        await loadPlugin('server', plugin, path, options.safe);
 }
-export async function loadDefaultConfigs() {
+export async function loadDefaultConfigs(safe = false) {
     for (const path of findConfigPaths()) {
         if (!existsSync(path)) {
             try {
@@ -219,9 +237,20 @@ export async function loadDefaultConfigs() {
                 continue;
             }
         }
-        await loadConfig(path, { optional: true });
+        await loadConfig(path, { optional: true, safe });
     }
 }
+export async function reloadConfigs(safe = false) {
+    const paths = Array.from(configFiles
+        .entries()
+        .filter(([, cfg]) => !cfg[kWasIncluded])
+        .map(([p]) => p));
+    configFiles.clear();
+    setConfig(defaultConfig);
+    for (const path of paths)
+        await loadConfig(path, { safe });
+    io.info('Reloaded configuration files');
+}
 /**
  * Update the current config and write the updated config to the appropriate file
  */
@@ -235,7 +264,7 @@ export function saveConfigTo(path, changed) {
     setConfig(changed);
     const config = configFiles.get(path) ?? {};
     Object.assign(config, { ...changed, db: { ...config.db, ...changed.db } });
-    output.debug(`Wrote config to ${path}`);
+    io.debug(`Wrote config to ${path}`);
     writeFileSync(path, JSON.stringify(config));
 }
 /**

package/dist/database.d.ts

@@ -1,9 +1,8 @@
-import type { Permission, Preferences } from '@axium/core';
+import type { Permission, Preferences, Severity, UserInternal } from '@axium/core';
 import type { AuthenticatorTransportFuture, CredentialDeviceType } from '@simplewebauthn/server';
 import type * as kysely from 'kysely';
 import { Kysely } from 'kysely';
-import type { Severity } from './audit.js';
-import type { UserInternal, VerificationRole } from './auth.js';
+import type { VerificationRole } from './auth.js';
 export interface DBAccessControl {
     itemId: string;
     userId: string;
@@ -43,7 +42,7 @@ export interface Schema {
         name: string | null;
         createdAt: kysely.GeneratedAlways<Date>;
         userId: string;
-        publicKey: Uint8Array;
+        publicKey: Uint8Array<ArrayBuffer>;
         counter: number;
         deviceType: CredentialDeviceType;
         backedUp: boolean;

package/dist/database.js

@@ -50,14 +50,15 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
+import * as io from '@axium/core/node/io';
+import { plugins } from '@axium/core/plugins';
 import { Kysely, PostgresDialect, sql } from 'kysely';
 import { jsonObjectFrom } from 'kysely/helpers/postgres';
 import { randomBytes } from 'node:crypto';
 import { readFileSync, writeFileSync } from 'node:fs';
 import pg from 'pg';
 import config from './config.js';
-import * as io from './io.js';
-import { plugins } from './plugins.js';
+import { styleText } from 'node:util';
 const sym = Symbol.for('Axium:database');
 export let database;
 export function connect() {
@@ -277,11 +278,11 @@ export async function init(opt) {
             .catch(maybeCheck('audit_log'));
         io.start('Creating schema acl');
         await database.schema.createSchema('acl').execute().then(io.done).catch(warnExists);
-        for (const plugin of plugins) {
-            if (!plugin.hooks.db_init)
+        for (const plugin of plugins.values()) {
+            if (!plugin._hooks?.db_init)
                 continue;
-            io.plugin(plugin.name);
-            await plugin.hooks.db_init(opt);
+            io.log(styleText('whiteBright', 'Running plugin: '), plugin.name);
+            await plugin._hooks?.db_init(opt);
         }
     }
     catch (e_1) {
@@ -432,22 +433,22 @@ export async function clean(opt) {
     await database.deleteFrom('sessions').where('sessions.expires', '<', now).execute().then(io.done);
     io.start('Removing expired verifications');
     await database.deleteFrom('verifications').where('verifications.expires', '<', now).execute().then(io.done);
-    for (const plugin of plugins) {
-        if (!plugin.hooks.clean)
+    for (const plugin of plugins.values()) {
+        if (!plugin._hooks?.clean)
             continue;
-        io.plugin(plugin.name);
-        await plugin.hooks.clean(opt);
+        io.log(styleText('whiteBright', 'Running plugin: '), plugin.name);
+        await plugin._hooks?.clean(opt);
     }
 }
 /**
  * Completely remove Axium from the database.
  */
 export async function uninstall(opt) {
-    for (const plugin of plugins) {
-        if (!plugin.hooks.remove)
+    for (const plugin of plugins.values()) {
+        if (!plugin._hooks?.remove)
             continue;
-        io.plugin(plugin.name);
-        await plugin.hooks.remove(opt);
+        io.log(styleText('whiteBright', 'Running plugin: '), plugin.name);
+        await plugin._hooks?.remove(opt);
     }
     await _sql('DROP DATABASE axium', 'Dropping database');
     await _sql('REVOKE ALL PRIVILEGES ON SCHEMA public FROM axium', 'Revoking schema privileges');
@@ -469,11 +470,11 @@ export async function uninstall(opt) {
  * Removes all data from tables.
  */
 export async function wipe(opt) {
-    for (const plugin of plugins) {
-        if (!plugin.hooks.db_wipe)
+    for (const plugin of plugins.values()) {
+        if (!plugin._hooks?.db_wipe)
             continue;
-        io.plugin(plugin.name);
-        await plugin.hooks.db_wipe(opt);
+        io.log(styleText('whiteBright', 'Running plugin: '), plugin.name);
+        await plugin._hooks?.db_wipe(opt);
     }
     for (const table of ['users', 'passkeys', 'sessions', 'verifications']) {
         io.start(`Wiping ${table}`);

package/dist/internal_requests.d.ts

@@ -0,0 +1,3 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+export declare function convertToRequest(req: IncomingMessage): Request;
+export declare function convertFromResponse(res: ServerResponse, response: Response): Promise<void>;

package/dist/internal_requests.js

@@ -0,0 +1,119 @@
+import { config } from './config.js';
+/* Credit to the SvelteKit team: https://github.com/sveltejs/kit/blob/8d1ba04825a540324bc003e85f36559a594aadc2/packages/kit/src/exports/node/index.js */
+function get_raw_body(req) {
+    const h = req.headers;
+    if (!h['content-type'])
+        return null;
+    const content_length = Number(h['content-length']);
+    // check if no request body
+    if ((req.httpVersionMajor === 1 && isNaN(content_length) && h['transfer-encoding'] == null) || content_length === 0) {
+        return null;
+    }
+    let length = content_length;
+    if (config.request_size_limit) {
+        if (!length)
+            length = config.request_size_limit;
+        else if (length > config.request_size_limit)
+            throw 413;
+    }
+    if (req.destroyed) {
+        const readable = new ReadableStream();
+        void readable.cancel();
+        return readable;
+    }
+    let size = 0;
+    let cancelled = false;
+    return new ReadableStream({
+        start(controller) {
+            req.on('error', error => {
+                cancelled = true;
+                controller.error(error);
+            });
+            req.on('end', () => {
+                if (cancelled)
+                    return;
+                controller.close();
+            });
+            req.on('data', chunk => {
+                if (cancelled)
+                    return;
+                size += chunk.length;
+                if (size > length) {
+                    cancelled = true;
+                    controller.error(413);
+                    return;
+                }
+                controller.enqueue(chunk);
+                if (controller.desiredSize === null || controller.desiredSize <= 0) {
+                    req.pause();
+                }
+            });
+        },
+        pull() {
+            req.resume();
+        },
+        cancel(reason) {
+            cancelled = true;
+            req.destroy(reason);
+        },
+    });
+}
+export function convertToRequest(req) {
+    const headers = req.headers;
+    const request = new Request(config.auth.origin + req.url, {
+        // @ts-expect-error 2353
+        duplex: 'half',
+        method: req.method,
+        headers,
+        body: get_raw_body(req),
+    });
+    return request;
+}
+export async function convertFromResponse(res, response) {
+    res.writeHead(response.status, Object.fromEntries(response.headers));
+    if (!response.body) {
+        res.end();
+        return;
+    }
+    if (response.body.locked) {
+        res.write('Fatal error: Response body is locked. ' +
+            `This can happen when the response was already read (for example through 'response.json()' or 'response.text()').`);
+        res.end();
+        return;
+    }
+    const reader = response.body.getReader();
+    if (res.destroyed) {
+        await reader.cancel();
+        return;
+    }
+    const cancel = (error) => {
+        res.off('close', cancel);
+        res.off('error', cancel);
+        // If the reader has already been interrupted with an error earlier,
+        // then it will appear here, it is useless, but it needs to be catch.
+        reader.cancel(error).catch(() => { });
+        if (error)
+            res.destroy(error);
+    };
+    res.on('close', cancel);
+    res.on('error', cancel);
+    async function next() {
+        try {
+            for (;;) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                if (!res.write(value)) {
+                    // eslint-disable-next-line @typescript-eslint/no-misused-promises
+                    res.once('drain', next);
+                    return;
+                }
+            }
+            res.end();
+        }
+        catch (error) {
+            cancel(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    void next();
+}

package/dist/io.d.ts

@@ -2,45 +2,6 @@ import { Logger } from 'logzen';
 export declare const systemDir = "/etc/axium";
 export declare const dirs: string[];
 export declare const logger: Logger;
-/**
- * @internal
- */
-export declare const output: {
-    constructor: {
-        name: string;
-    };
-    error(message: string): void;
-    warn(message: string): void;
-    info(message: string): void;
-    log(message: string): void;
-    debug(message: string): void;
-};
-export declare function setCommandTimeout(value: number): void;
-/**
- * Run a system command with the fancy "Example... done."
- * @internal
- */
-export declare function run(message: string, command: string): Promise<string>;
-/** Yet another convenience function */
-export declare function exit(message: string | Error, code?: number): never;
-export declare function handleError(e: number | string | Error): void;
-export type OutputTag = 'debug' | 'info' | 'warn' | 'error' | 'start' | 'done' | 'plugin';
-export interface Output {
-    (tag: 'done'): void;
-    (tag: Exclude<OutputTag, 'done'>, message: string): void;
-}
-/**
- * Enable or disable debug output.
- */
-export declare function _setDebugOutput(enabled: boolean): void;
-export declare function useTaggedOutput(output: Output | null): void;
-export declare function done(): void;
-export declare function start(message: string): void;
-export declare function plugin(name: string): void;
-export declare function debug(message: string): void;
-export declare function info(message: string): void;
-export declare function warn(message: string): void;
-export declare function error(message: string): void;
 /** @internal */
 export declare const _portMethods: readonly ["node-cap"];
 /** @internal */
@@ -62,13 +23,3 @@ export interface PortOptions {
  * If the origin has a port, passkeys do not work correctly with some password managers.
  */
 export declare function restrictedPorts(opt: PortOptions): Promise<void>;
-/**
- * This is a factory for handling errors when performing operations.
- * The handler will allow the parent scope to continue if a relation already exists,
- * rather than fatally exiting.
- */
-export declare function someWarnings(...allowList: [RegExp, string?][]): (error: string | Error) => void;
-/**
- * Get a human-readable string for a date that also fits into CLIs well (fixed-width)
- */
-export declare function prettyDate(date: Date): string;