@axium/server 0.10.0 → 0.11.1

package/dist/database.js

@@ -55,7 +55,7 @@ import { randomBytes } from 'node:crypto';
 import { readFileSync, writeFileSync } from 'node:fs';
 import pg from 'pg';
 import config from './config.js';
-import { _fixOutput, run, someWarnings } from './io.js';
+import * as io from './io.js';
 import { plugins } from './plugins.js';
 const sym = Symbol.for('Axium:database');
 export let database;
@@ -99,32 +99,32 @@ export async function statusText() {
 }
 export function shouldRecreate(opt) {
     if (opt.skip) {
-        opt.output('warn', 'already exists. (skipped)');
+        io.warn('already exists. (skipped)');
         return true;
     }
     if (opt.force) {
-        opt.output('warn', 'already exists. (re-creating)');
+        io.warn('already exists. (re-creating)');
         return false;
     }
-    opt.output('warn', 'already exists. Use --skip to skip or --force to re-create.');
+    io.warn('already exists. Use --skip to skip or --force to re-create.');
     throw 2;
 }
 export async function getHBA(opt) {
-    const hbaShowResult = await run(opt, 'Finding pg_hba.conf', `sudo -u postgres psql -c "SHOW hba_file"`);
-    opt.output('start', 'Resolving pg_hba.conf path');
+    const hbaShowResult = await io.run('Finding pg_hba.conf', `sudo -u postgres psql -c "SHOW hba_file"`);
+    io.start('Resolving pg_hba.conf path');
     const hbaPath = hbaShowResult.match(/^\s*(.+\.conf)\s*$/m)?.[1]?.trim();
     if (!hbaPath) {
         throw 'failed. You will need to add password-based auth for the axium user manually.';
     }
-    opt.output('done');
-    opt.output('debug', `Found pg_hba.conf at ${hbaPath}`);
-    opt.output('start', 'Reading HBA configuration');
+    io.done();
+    io.debug(`Found pg_hba.conf at ${hbaPath}`);
+    io.start('Reading HBA configuration');
     const content = readFileSync(hbaPath, 'utf-8');
-    opt.output('done');
+    io.done();
     const writeBack = (newContent) => {
-        opt.output('start', 'Writing HBA configuration');
+        io.start('Writing HBA configuration');
         writeFileSync(hbaPath, newContent);
-        opt.output('done');
+        io.done();
     };
     return [content, writeBack];
 }
@@ -133,19 +133,23 @@ local axium axium md5
 host  axium axium 127.0.0.1/32 md5
 host  axium axium ::1/128 md5
 `;
+const _sql = (command, message) => io.run(message, `sudo -u postgres psql -c "${command}"`);
+/** Shortcut to output a warning if an error is thrown because relation already exists */
+export const warnExists = io.someWarnings([/\w+ "[\w.]+" already exists/, 'already exists.']);
+const throwUnlessRows = (text) => {
+    if (text.includes('(0 rows)'))
+        throw 'missing.';
+    return text;
+};
 export async function init(opt) {
     const env_1 = { stack: [], error: void 0, hasError: false };
     try {
-        _fixOutput(opt);
         if (!config.db.password) {
             config.save({ db: { password: randomBytes(32).toString('base64') } }, true);
-            opt.output('debug', 'Generated password and wrote to global config');
+            io.debug('Generated password and wrote to global config');
         }
-        await run(opt, 'Checking for sudo', 'which sudo');
-        await run(opt, 'Checking for psql', 'which psql');
-        const _sql = (command, message) => run(opt, message, `sudo -u postgres psql -c "${command}"`);
-        const warnExists = someWarnings(opt.output, [/(schema|relation) "[\w.]+" already exists/, 'already exists.']);
-        const done = () => opt.output('done');
+        await io.run('Checking for sudo', 'which sudo');
+        await io.run('Checking for psql', 'which psql');
         await _sql('CREATE DATABASE axium', 'Creating database').catch(async (error) => {
             if (error != 'database "axium" already exists')
                 throw error;
@@ -169,19 +173,19 @@ export async function init(opt) {
         await _sql('ALTER DATABASE axium OWNER TO axium', 'Setting database owner');
         await getHBA(opt)
             .then(([content, writeBack]) => {
-            opt.output('start', 'Checking for Axium HBA configuration');
+            io.start('Checking for Axium HBA configuration');
             if (content.includes(pgHba))
                 throw 'already exists.';
-            done();
-            opt.output('start', 'Adding Axium HBA configuration');
+            io.done();
+            io.start('Adding Axium HBA configuration');
             const newContent = content.replace(/^local\s+all\s+all.*$/m, `$&\n${pgHba}`);
-            done();
+            io.done();
             writeBack(newContent);
         })
-            .catch(e => opt.output('warn', e));
+            .catch(io.warn);
         await _sql('SELECT pg_reload_conf()', 'Reloading configuration');
         const db = __addDisposableResource(env_1, connect(), true);
-        opt.output('start', 'Creating table users');
+        io.start('Creating table users');
         await db.schema
             .createTable('users')
             .addColumn('id', 'uuid', col => col.primaryKey().defaultTo(sql `gen_random_uuid()`))
@@ -189,11 +193,15 @@ export async function init(opt) {
             .addColumn('email', 'text', col => col.unique().notNull())
             .addColumn('emailVerified', 'timestamptz')
             .addColumn('image', 'text')
+            .addColumn('isAdmin', 'boolean', col => col.notNull().defaultTo(false))
+            .addColumn('roles', sql `text[]`, col => col.notNull().defaultTo(sql `'{}'::text[]`))
+            .addColumn('tags', sql `text[]`, col => col.notNull().defaultTo(sql `'{}'::text[]`))
             .addColumn('preferences', 'jsonb', col => col.notNull().defaultTo(sql `'{}'::jsonb`))
+            .addColumn('registeredAt', 'timestamptz', col => col.notNull().defaultTo(sql `now()`))
             .execute()
-            .then(done)
+            .then(io.done)
             .catch(warnExists);
-        opt.output('start', 'Creating table sessions');
+        io.start('Creating table sessions');
         await db.schema
             .createTable('sessions')
             .addColumn('id', 'uuid', col => col.primaryKey().defaultTo(sql `gen_random_uuid()`))
@@ -203,11 +211,11 @@ export async function init(opt) {
             .addColumn('expires', 'timestamptz', col => col.notNull())
             .addColumn('elevated', 'boolean', col => col.notNull())
             .execute()
-            .then(done)
+            .then(io.done)
             .catch(warnExists);
-        opt.output('start', 'Creating index for sessions.userId');
-        await db.schema.createIndex('sessions_userId_index').on('sessions').column('userId').execute().then(done).catch(warnExists);
-        opt.output('start', 'Creating table verifications');
+        io.start('Creating index for sessions.userId');
+        await db.schema.createIndex('sessions_userId_index').on('sessions').column('userId').execute().then(io.done).catch(warnExists);
+        io.start('Creating table verifications');
         await db.schema
             .createTable('verifications')
             .addColumn('userId', 'uuid', col => col.references('users.id').onDelete('cascade').notNull())
@@ -215,9 +223,9 @@ export async function init(opt) {
             .addColumn('expires', 'timestamptz', col => col.notNull())
             .addColumn('role', 'text', col => col.notNull())
             .execute()
-            .then(done)
+            .then(io.done)
             .catch(warnExists);
-        opt.output('start', 'Creating table passkeys');
+        io.start('Creating table passkeys');
         await db.schema
             .createTable('passkeys')
             .addColumn('id', 'text', col => col.primaryKey().notNull())
@@ -230,15 +238,15 @@ export async function init(opt) {
             .addColumn('backedUp', 'boolean', col => col.notNull())
             .addColumn('transports', sql `text[]`)
             .execute()
-            .then(done)
+            .then(io.done)
             .catch(warnExists);
-        opt.output('start', 'Creating index for passkeys.id');
-        await db.schema.createIndex('passkeys_id_key').on('passkeys').column('id').execute().then(done).catch(warnExists);
+        io.start('Creating index for passkeys.id');
+        await db.schema.createIndex('passkeys_id_key').on('passkeys').column('id').execute().then(io.done).catch(warnExists);
         for (const plugin of plugins) {
-            if (!plugin.db_init)
+            if (!plugin.hooks.db_init)
                 continue;
-            opt.output('plugin', plugin.name);
-            await plugin.db_init(opt, db, { warnExists, done });
+            io.plugin(plugin.name);
+            await plugin.hooks.db_init(opt, db);
         }
     }
     catch (e_1) {
@@ -254,33 +262,25 @@ export async function init(opt) {
 export async function check(opt) {
     const env_2 = { stack: [], error: void 0, hasError: false };
     try {
-        _fixOutput(opt);
-        await run(opt, 'Checking for sudo', 'which sudo');
-        await run(opt, 'Checking for psql', 'which psql');
-        const _sql = (command, message) => run(opt, message, `sudo -u postgres psql -c "${command}"`);
-        const done = () => opt.output('done');
-        const throwUnlessRows = (text) => {
-            if (text.includes('(0 rows)'))
-                throw 'missing.';
-            return text;
-        };
+        await io.run('Checking for sudo', 'which sudo');
+        await io.run('Checking for psql', 'which psql');
         await _sql(`SELECT 1 FROM pg_database WHERE datname = 'axium'`, 'Checking for database').then(throwUnlessRows);
         await _sql(`SELECT 1 FROM pg_roles WHERE rolname = 'axium'`, 'Checking for user').then(throwUnlessRows);
-        opt.output('start', 'Connecting to database');
+        io.start('Connecting to database');
         const db = __addDisposableResource(env_2, connect(), true);
-        done();
-        opt.output('start', `Checking users table`);
-        await db.selectFrom('users').select(['id', 'email', 'emailVerified', 'image', 'name', 'preferences']).execute().then(done);
-        opt.output('start', `Checking sessions table`);
-        await db.selectFrom('sessions').select(['id', 'userId', 'token', 'created', 'expires', 'elevated']).execute().then(done);
-        opt.output('start', `Checking verifications table`);
-        await db.selectFrom('verifications').select(['userId', 'token', 'expires', 'role']).execute().then(done);
-        opt.output('start', `Checking passkeys table`);
+        io.done();
+        io.start('Checking users table');
+        await db.selectFrom('users').select(['id', 'email', 'emailVerified', 'image', 'name', 'preferences']).execute().then(io.done);
+        io.start('Checking sessions table');
+        await db.selectFrom('sessions').select(['id', 'userId', 'token', 'created', 'expires', 'elevated']).execute().then(io.done);
+        io.start('Checking verifications table');
+        await db.selectFrom('verifications').select(['userId', 'token', 'expires', 'role']).execute().then(io.done);
+        io.start('Checking passkeys table');
         await db
             .selectFrom('passkeys')
             .select(['id', 'name', 'createdAt', 'userId', 'publicKey', 'counter', 'deviceType', 'backedUp', 'transports'])
             .execute()
-            .then(done);
+            .then(io.done);
     }
     catch (e_2) {
         env_2.error = e_2;
@@ -293,19 +293,17 @@ export async function check(opt) {
     }
 }
 export async function clean(opt) {
-    _fixOutput(opt);
-    const done = () => opt.output('done');
     const now = new Date();
     const db = connect();
-    opt.output('start', 'Removing expired sessions');
-    await db.deleteFrom('sessions').where('sessions.expires', '<', now).execute().then(done);
-    opt.output('start', 'Removing expired verifications');
-    await db.deleteFrom('verifications').where('verifications.expires', '<', now).execute().then(done);
+    io.start('Removing expired sessions');
+    await db.deleteFrom('sessions').where('sessions.expires', '<', now).execute().then(io.done);
+    io.start('Removing expired verifications');
+    await db.deleteFrom('verifications').where('verifications.expires', '<', now).execute().then(io.done);
     for (const plugin of plugins) {
-        if (!plugin.db_clean)
+        if (!plugin.hooks.clean)
             continue;
-        opt.output('plugin', plugin.name);
-        await plugin.db_clean(opt, db);
+        io.plugin(plugin.name);
+        await plugin.hooks.clean(opt, db);
     }
 }
 /**
@@ -314,30 +312,28 @@ export async function clean(opt) {
 export async function uninstall(opt) {
     const env_3 = { stack: [], error: void 0, hasError: false };
     try {
-        _fixOutput(opt);
         const db = __addDisposableResource(env_3, connect(), true);
         for (const plugin of plugins) {
-            if (!plugin.db_remove)
+            if (!plugin.hooks.remove)
                 continue;
-            opt.output('plugin', plugin.name);
-            await plugin.db_remove(opt, db);
+            io.plugin(plugin.name);
+            await plugin.hooks.remove(opt, db);
         }
-        const _sql = (command, message) => run(opt, message, `sudo -u postgres psql -c "${command}"`);
         await _sql('DROP DATABASE axium', 'Dropping database');
         await _sql('REVOKE ALL PRIVILEGES ON SCHEMA public FROM axium', 'Revoking schema privileges');
         await _sql('DROP USER axium', 'Dropping user');
         await getHBA(opt)
             .then(([content, writeBack]) => {
-            opt.output('start', 'Checking for Axium HBA configuration');
+            io.start('Checking for Axium HBA configuration');
             if (!content.includes(pgHba))
                 throw 'missing.';
-            opt.output('done');
-            opt.output('start', 'Removing Axium HBA configuration');
+            io.done();
+            io.start('Removing Axium HBA configuration');
             const newContent = content.replace(pgHba, '');
-            opt.output('done');
+            io.done();
             writeBack(newContent);
         })
-            .catch(e => opt.output('warn', e));
+            .catch(io.warn);
     }
     catch (e_3) {
         env_3.error = e_3;
@@ -353,17 +349,16 @@ export async function uninstall(opt) {
  * Removes all data from tables.
  */
 export async function wipe(opt) {
-    _fixOutput(opt);
     const db = connect();
     for (const plugin of plugins) {
-        if (!plugin.db_wipe)
+        if (!plugin.hooks.db_wipe)
             continue;
-        opt.output('plugin', plugin.name);
-        await plugin.db_wipe(opt, db);
+        io.plugin(plugin.name);
+        await plugin.hooks.db_wipe(opt, db);
     }
     for (const table of ['users', 'passkeys', 'sessions', 'verifications']) {
-        opt.output('start', `Removing data from ${table}`);
+        io.start(`Removing data from ${table}`);
         await db.deleteFrom(table).execute();
-        opt.output('done');
+        io.done();
     }
 }

package/dist/io.d.ts

@@ -16,13 +16,12 @@ export declare const output: {
     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(opts: WithOutput & {
-    timeout?: number;
-}, message: string, command: string): Promise<string>;
+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;
@@ -31,20 +30,18 @@ export interface Output {
     (tag: 'done'): void;
     (tag: Exclude<OutputTag, 'done'>, message: string): void;
 }
-export interface MaybeOutput {
-    output?: Output | null | false;
-}
-export interface WithOutput {
-    output: Output;
-}
-export declare function _setDebugOutput(enabled: boolean): void;
-export declare function defaultOutput(tag: 'done'): void;
-export declare function defaultOutput(tag: Exclude<OutputTag, 'done'>, message: string): void;
 /**
- * TS can't tell when we do this inline
- * @internal
+ * Enable or disable debug output.
  */
-export declare function _fixOutput<T extends MaybeOutput>(opt: T): asserts opt is T & WithOutput;
+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 */
@@ -55,7 +52,7 @@ export declare const _portActions: readonly ["enable", "disable"];
  * Method:
  * - `node-cap`: Use the `cap_net_bind_service` capability on the node binary.
  */
-export interface PortOptions extends MaybeOutput {
+export interface PortOptions {
     method: (typeof _portMethods)[number];
     action: (typeof _portActions)[number];
     node?: string;
@@ -71,4 +68,4 @@ export declare function restrictedPorts(opt: PortOptions): Promise<void>;
  * The handler will allow the parent scope to continue if a relation already exists,
  * rather than fatally exiting.
  */
-export declare function someWarnings(output: Output, ...allowList: [RegExp, string?][]): (error: string | Error) => void;
+export declare function someWarnings(...allowList: [RegExp, string?][]): (error: string | Error) => void;

package/dist/io.js

@@ -47,16 +47,20 @@ export const output = {
     },
 };
 logger.attach(output);
+let timeout = 1000;
+export function setCommandTimeout(value) {
+    timeout = value;
+}
 /**
  * Run a system command with the fancy "Example... done."
  * @internal
  */
-export async function run(opts, message, command) {
+export async function run(message, command) {
     let stderr;
     try {
-        opts.output('start', message);
+        start(message);
         const { promise, resolve, reject } = Promise.withResolvers();
-        exec(command, opts, (err, stdout, _stderr) => {
+        exec(command, { timeout }, (err, stdout, _stderr) => {
             stderr = _stderr.startsWith('ERROR:') ? _stderr.slice(6).trim() : _stderr;
             if (err)
                 reject('[command]');
@@ -64,7 +68,7 @@ export async function run(opts, message, command) {
                 resolve(stdout);
         });
         const value = await promise;
-        opts.output('done');
+        done();
         return value;
     }
     catch (error) {
@@ -89,10 +93,13 @@ export function handleError(e) {
         exit(e);
 }
 let _debugOutput = false;
+/**
+ * Enable or disable debug output.
+ */
 export function _setDebugOutput(enabled) {
     _debugOutput = enabled;
 }
-export function defaultOutput(tag, message = '') {
+function defaultOutput(tag, message = '') {
     switch (tag) {
         case 'debug':
             _debugOutput && output.debug(message);
@@ -116,15 +123,31 @@ export function defaultOutput(tag, message = '') {
             console.log(styleText('whiteBright', 'Running plugin: ' + message));
     }
 }
-/**
- * TS can't tell when we do this inline
- * @internal
- */
-export function _fixOutput(opt) {
-    if (opt.output === false)
-        opt.output = () => { };
-    else
-        opt.output ??= defaultOutput;
+let _taggedOutput = defaultOutput;
+export function useTaggedOutput(output) {
+    _taggedOutput = output;
+}
+// Shortcuts for tagged output
+export function done() {
+    _taggedOutput?.('done');
+}
+export function start(message) {
+    _taggedOutput?.('start', message);
+}
+export function plugin(name) {
+    _taggedOutput?.('plugin', name);
+}
+export function debug(message) {
+    _taggedOutput?.('debug', message);
+}
+export function info(message) {
+    _taggedOutput?.('info', message);
+}
+export function warn(message) {
+    _taggedOutput?.('warn', message);
+}
+export function error(message) {
+    _taggedOutput?.('error', message);
 }
 /** @internal */
 export const _portMethods = ['node-cap'];
@@ -136,46 +159,45 @@ export const _portActions = ['enable', 'disable'];
  * If the origin has a port, passkeys do not work correctly with some password managers.
  */
 export async function restrictedPorts(opt) {
-    _fixOutput(opt);
-    opt.output('start', 'Checking for root privileges');
+    start('Checking for root privileges');
     if (process.getuid?.() != 0)
         throw 'root privileges are needed to change restricted ports.';
-    opt.output('done');
-    opt.output('start', 'Checking ports method');
+    done();
+    start('Checking ports method');
     if (!_portMethods.includes(opt.method))
         throw 'invalid';
-    opt.output('done');
-    opt.output('start', 'Checking ports action');
+    done();
+    start('Checking ports action');
     if (!_portActions.includes(opt.action))
         throw 'invalid';
-    opt.output('done');
+    done();
     switch (opt.method) {
         case 'node-cap': {
-            const setcap = await run(opt, 'Finding setcap', 'command -v setcap')
+            const setcap = await run('Finding setcap', 'command -v setcap')
                 .then(e => e.trim())
                 .catch(() => {
-                opt.output('warn', 'not in path.');
-                opt.output('start', 'Checking for /usr/sbin/setcap');
+                warn('not in path.');
+                start('Checking for /usr/sbin/setcap');
                 fs.accessSync('/usr/sbin/setcap', fs.constants.X_OK);
-                opt.output('done');
+                done();
                 return '/usr/sbin/setcap';
             });
-            opt.output('debug', 'Using setcap at ' + setcap);
+            debug('Using setcap at ' + setcap);
             let { node } = opt;
-            node ||= await run(opt, 'Finding node', 'command -v node')
+            node ||= await run('Finding node', 'command -v node')
                 .then(e => e.trim())
                 .catch(() => {
-                opt.output('warn', 'not in path.');
-                opt.output('start', 'Checking for /usr/bin/node');
+                warn('not in path.');
+                start('Checking for /usr/bin/node');
                 fs.accessSync('/usr/bin/node', fs.constants.X_OK);
-                opt.output('done');
+                done();
                 return '/usr/bin/node';
             });
-            opt.output('start', 'Resolving real path for node');
+            start('Resolving real path for node');
             node = fs.realpathSync(node);
-            opt.output('done');
-            opt.output('debug', 'Using node at ' + node);
-            await run(opt, 'Setting ports capability', `${setcap} cap_net_bind_service=${opt.action == 'enable' ? '+' : '-'}ep ${node}`);
+            done();
+            debug('Using node at ' + node);
+            await run('Setting ports capability', `${setcap} cap_net_bind_service=${opt.action == 'enable' ? '+' : '-'}ep ${node}`);
             break;
         }
     }
@@ -185,13 +207,13 @@ export async function restrictedPorts(opt) {
  * The handler will allow the parent scope to continue if a relation already exists,
  * rather than fatally exiting.
  */
-export function someWarnings(output, ...allowList) {
+export function someWarnings(...allowList) {
     return (error) => {
         error = typeof error == 'object' && 'message' in error ? error.message : error;
         for (const [pattern, message = error] of allowList) {
             if (!pattern.test(error))
                 continue;
-            output('warn', message);
+            warn(message);
             return;
         }
         throw error;

package/dist/linking.d.ts

@@ -0,0 +1,10 @@
+export declare function listRouteLinks(): Generator<{
+    id: string;
+    from: string;
+    to: string;
+}>;
+/**
+ * Symlinks .svelte page routes for plugins and the server into a project's routes directory.
+ */
+export declare function linkRoutes(): void;
+export declare function unlinkRoutes(): void;

package/dist/linking.js

@@ -0,0 +1,76 @@
+import { existsSync, symlinkSync, unlinkSync } from 'node:fs';
+import { join, resolve } from 'node:path/posix';
+import config from './config.js';
+import * as io from './io.js';
+import { getSpecifier, plugins } from './plugins.js';
+const textFor = {
+    builtin: 'built-in routes',
+};
+function info(id) {
+    const text = id.startsWith('#') ? textFor[id.slice(1)] : `routes for plugin: ${id}`;
+    const link = join(config.web.routes, `(${id.startsWith('#') ? id.slice(1) : id.replaceAll('/', '__')})`);
+    return [text, link];
+}
+export function* listRouteLinks() {
+    const [, link] = info('#builtin');
+    yield { id: '#builtin', from: resolve(import.meta.dirname, '../routes'), to: link };
+    for (const plugin of plugins) {
+        if (!plugin.routes)
+            continue;
+        const [, link] = info(plugin.name);
+        yield { id: plugin.name, from: join(import.meta.resolve(getSpecifier(plugin)), plugin.routes), to: link };
+    }
+}
+function createLink(id, routes) {
+    const [text, link] = info(id);
+    if (existsSync(link)) {
+        io.warn('already exists.');
+        io.start('Unlinking ' + text);
+        try {
+            unlinkSync(link);
+        }
+        catch (e) {
+            io.exit(e && e instanceof Error ? e.message : e.toString());
+        }
+        io.done();
+        io.start('Re-linking ' + text);
+    }
+    try {
+        symlinkSync(link, routes, 'dir');
+    }
+    catch (e) {
+        io.exit(e && e instanceof Error ? e.message : e.toString());
+    }
+}
+/**
+ * Symlinks .svelte page routes for plugins and the server into a project's routes directory.
+ */
+export function linkRoutes() {
+    io.start('Linking built-in routes');
+    createLink('#builtin', resolve(import.meta.dirname, '../routes'));
+    for (const plugin of plugins) {
+        if (!plugin.routes)
+            continue;
+        io.start(`Linking routes for plugin: ${plugin.name}`);
+        createLink(plugin.name, join(import.meta.resolve(getSpecifier(plugin)), plugin.routes));
+    }
+}
+function removeLink(id) {
+    const [text, link] = info(id);
+    if (!existsSync(link))
+        return;
+    io.start('Unlinking ' + text);
+    try {
+        unlinkSync(link);
+    }
+    catch (e) {
+        io.exit(e && e instanceof Error ? e.message : e.toString());
+    }
+    io.done();
+}
+export function unlinkRoutes() {
+    removeLink('#builtin');
+    for (const plugin of plugins) {
+        removeLink(plugin.name);
+    }
+}