nesoi 3.0.0 → 3.0.3

package/lib/engine/apps/app.config.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AppConfigFactory = void 0;
+/**
+ * Factory
+ */
 class AppConfigFactory {
     constructor(app) {
         this.app = app;
@@ -18,10 +21,19 @@ class AppConfigFactory {
         this.config.buckets = config;
         return this.app;
     }
+    trash(config) {
+        // TODO
+        // this.config.buckets = config as never;
+        return this.app;
+    }
     controllers(config) {
         this.config.controllers = config;
         return this.app;
     }
+    audit(config) {
+        this.config.i18n = config;
+        return this.app;
+    }
     compiler(config) {
         this.config.compiler = config;
         return this.app;

package/lib/engine/apps/app.d.ts

@@ -12,6 +12,7 @@ export type AppProvider<out Name, T> = {
         modules: Record<string, AnyModule>;
     }) => T;
     down: (provider: NoInfer<T>) => any;
+    libPaths?: string[];
 };
 export type AnyAppProvider = AppProvider<any, any>;
 export declare abstract class App<S extends $Space, Modules extends string = ModuleName<S> & string, Providers extends Record<string, any> = Record<string, any>> {
@@ -62,6 +63,7 @@ export declare abstract class App<S extends $Space, Modules extends string = Mod
     provider<Name extends string, T>($: AppProvider<Name, T>): App<S, Modules, Providers & { [K in Name]: T; }>;
     get config(): AppConfigFactory<S, Modules, Providers>;
     protected makeModules(): Record<string, AnyModule>;
+    static getProviders(app: AnyApp): Record<string, AnyAppProvider>;
     static getInfo(app: AnyApp): {
         spaceModules: (string | number | symbol)[];
         config: AnyAppConfig;

package/lib/engine/apps/app.js

@@ -91,6 +91,9 @@ class App {
         return modules;
     }
     //
+    static getProviders(app) {
+        return app._providers;
+    }
     static getInfo(app) {
         return {
             spaceModules: app._spaceModuleNames,

package/lib/engine/apps/inline.app.d.ts

@@ -3,14 +3,13 @@ import { App, AppProvider } from './app';
 import { AnyTrxEngine } from '../transaction/trx_engine';
 import { AnyBuilder, AnyModule, Module } from '../module';
 import { AnyDaemon, Daemon } from '../daemon';
+import { AppConfigFactory } from './app.config';
 export declare class InlineApp<S extends $Space, ModuleNames extends string = ModuleName<S> & string, Providers extends Record<string, any> = Record<string, any>> extends App<S, ModuleNames, Providers> {
     protected _daemon?: Daemon<S, ModuleNames>;
     protected _modules: Record<string, AnyModule>;
     private packageJson?;
-    private bootPromise?;
+    protected bootPromise?: Promise<void>;
     constructor(name: string, builders: AnyBuilder[]);
-    modules<M extends ModuleName<S>>(modules: M[]): InlineApp<S, M & ModuleNames>;
-    provider<Name extends string, T>($: AppProvider<Name, T>): InlineApp<S, ModuleNames, Providers & { [K in Name]: T; }>;
     boot(): InlineApp<S, ModuleNames, Providers>;
     /**
      * Treeshake and build modules declared for this application.
@@ -35,6 +34,9 @@ export declare class InlineApp<S extends $Space, ModuleNames extends string = Mo
      * TODO: allow overriding this behavior with adapters
      */
     protected linkExternals(modules: Record<string, Module<S, $Module>>): void;
+    modules<M extends ModuleName<S>>(modules: M[]): InlineApp<S, M & ModuleNames>;
+    provider<Name extends string, T>($: AppProvider<Name, T>): InlineApp<S, ModuleNames, Providers & { [K in Name]: T; }>;
+    get config(): AppConfigFactory<S, ModuleNames, Providers, typeof this>;
     static package(app: InlineApp<any, any>, scripts: Record<string, string>, dependencies: Record<string, string>): {
         name: string;
         version: string;

package/lib/engine/apps/inline.app.js

@@ -6,20 +6,12 @@ const log_1 = require("../util/log");
 const trx_engine_1 = require("../transaction/trx_engine");
 const tree_1 = require("../tree");
 const daemon_1 = require("../daemon");
+const app_config_1 = require("./app.config");
 class InlineApp extends app_1.App {
     constructor(name, builders) {
         super(name, { builders });
         this._modules = {};
     }
-    // Type Builder Overrides
-    modules(modules) {
-        super.modules(modules);
-        return this;
-    }
-    provider($) {
-        super.provider($);
-        return this;
-    }
     // App abstract methods
     boot() {
         if (!this.bootPromise) {
@@ -58,13 +50,16 @@ class InlineApp extends app_1.App {
         }
         const modules = this._modules;
         for (const key in this._injectedModules) {
-            modules[key] = this._injectedModules[key];
+            const mod = this._injectedModules[key];
+            modules[mod.name] = mod;
         }
         const providers = {};
         for (const key in this._providers) {
-            providers[key] = this._providers[key].up({
+            const provider = this._providers[key].up({
                 modules
             });
+            provider.__down = this._providers[key].down;
+            providers[key] = provider;
         }
         log_1.Log.debug('app', this.name, 'Starting transaction engines');
         const trxEngines = {};
@@ -72,7 +67,14 @@ class InlineApp extends app_1.App {
             const module = modules[m];
             module.start(this, providers);
             const trxConfig = this._config.trxEngine?.[m];
-            trxEngines[m] = new trx_engine_1.TrxEngine(`app:${this.name}`, module, this._config.authn, trxConfig, providers);
+            const authn = {};
+            for (const a in this._config?.authn || {}) {
+                const prov = this._config.authn?.[a]?.();
+                if (prov) {
+                    authn[a] = prov;
+                }
+            }
+            trxEngines[m] = new trx_engine_1.TrxEngine(`app:${this.name}`, module, authn, trxConfig, providers);
         }
         log_1.Log.debug('app', this.name, 'Linking externals');
         this.linkExternals(modules);
@@ -114,6 +116,7 @@ class InlineApp extends app_1.App {
             const buckets = module.schema.externals.buckets;
             Object.values(buckets).forEach(bucket => {
                 module.buckets[bucket.refName] = modules[bucket.module].buckets[bucket.name];
+                module.nql.linkExternal(modules[bucket.module].buckets[bucket.name]);
             });
             const jobs = module.schema.externals.jobs;
             Object.values(jobs).forEach(job => {
@@ -125,6 +128,18 @@ class InlineApp extends app_1.App {
             });
         });
     }
+    // Type Builder Overrides
+    modules(modules) {
+        super.modules(modules);
+        return this;
+    }
+    provider($) {
+        super.provider($);
+        return this;
+    }
+    get config() {
+        return new app_config_1.AppConfigFactory(this);
+    }
     //
     static package(app, scripts, dependencies) {
         return {

package/lib/engine/apps/monolyth/monolyth.app.d.ts

@@ -4,17 +4,19 @@ import { InlineApp } from './../inline.app';
 import { AnyTrxEngine } from '../../transaction/trx_engine';
 import { Space } from '../../space';
 import { Daemon } from "../../daemon";
+import { AppConfigFactory } from '../app.config';
 export declare class MonolythApp<S extends $Space, ModuleNames extends string = ModuleName<S> & string, Providers extends Record<string, any> = Record<string, any>> extends InlineApp<S, ModuleNames, Providers> {
     private watcher?;
     constructor(name: string, space?: Space<S>);
     protected _packageJson?: Record<string, any>;
-    modules<M extends ModuleName<S>>(modules: M[]): MonolythApp<S, M & ModuleNames>;
-    provider<Name extends string, T>($: AppProvider<Name, T>): MonolythApp<S, ModuleNames, Providers & { [K in Name]: T; }>;
     daemon($?: {
         watch?: boolean;
     }): Promise<Daemon<S, ModuleNames>>;
     protected makeDaemon(trxEngines: Record<ModuleNames, AnyTrxEngine>, providers: Record<string, any>): MonolythDaemon<$Space, ModuleNames>;
     remake(): Promise<void>;
+    modules<M extends ModuleName<S>>(modules: M[]): MonolythApp<S, M & ModuleNames>;
+    provider<Name extends string, T>($: AppProvider<Name, T>): MonolythApp<S, ModuleNames, Providers & { [K in Name]: T; }>;
+    get config(): AppConfigFactory<S, ModuleNames, Providers, typeof this>;
 }
 export declare class MonolythDaemon<S extends $Space, Modules extends ModuleName<S>> extends Daemon<S, Modules> {
 }

package/lib/engine/apps/monolyth/monolyth.app.js

@@ -38,21 +38,13 @@ const inline_app_1 = require("./../inline.app");
 const space_1 = require("../../space");
 const daemon_1 = require("../../daemon");
 const log_1 = require("../../util/log");
+const app_config_1 = require("../app.config");
 class MonolythApp extends inline_app_1.InlineApp {
     constructor(name, space) {
         super(name, []);
         this.builders = undefined;
         this.space = space;
     }
-    // Type Builder Overrides
-    modules(modules) {
-        super.modules(modules);
-        return this;
-    }
-    provider($) {
-        super.provider($);
-        return this;
-    }
     // Override InlineApp abstract methods
     async daemon($) {
         /**
@@ -65,7 +57,13 @@ class MonolythApp extends inline_app_1.InlineApp {
          */
         if (this.space && $?.watch) {
             Promise.resolve().then(() => __importStar(require('chokidar'))).then(({ default: chokidar }) => {
-                this.watcher = chokidar.watch(space_1.Space.path(this.space, '..', '..')); // TODO: change to .
+                this.watcher = chokidar.watch(space_1.Space.path(this.space), {
+                    ignored: [
+                        space_1.Space.path(this.space, 'node_modules'),
+                        space_1.Space.path(this.space, '.nesoi'),
+                        space_1.Space.path(this.space, 'build')
+                    ]
+                }); // TODO: change to .
                 this.watcher
                     .on('change', () => {
                     this.remake();
@@ -84,9 +82,23 @@ class MonolythApp extends inline_app_1.InlineApp {
             log_1.Log.error('app', 'monolyth', `Attempt to remake app ${this.name} failed: Daemon not running.`);
             return;
         }
+        await daemon_1.Daemon.destroy(this._daemon);
+        this.bootPromise = undefined;
         const app = await this.make();
         await daemon_1.Daemon.reload(this._daemon, app.trxEngines, app.providers);
     }
+    // Type Builder Overrides
+    modules(modules) {
+        super.modules(modules);
+        return this;
+    }
+    provider($) {
+        super.provider($);
+        return this;
+    }
+    get config() {
+        return new app_config_1.AppConfigFactory(this);
+    }
 }
 exports.MonolythApp = MonolythApp;
 class MonolythDaemon extends daemon_1.Daemon {

package/lib/engine/auth/authn.d.ts

@@ -1,4 +1,5 @@
 import { NesoiObjId } from '../data/obj';
+import { AnyTrxNode } from '../transaction/trx_node';
 export type User = {
     id: NesoiObjId;
     [x: string]: any;
@@ -8,7 +9,10 @@ export type AuthnRequest<P extends keyof any> = {
     [K in P]?: AuthnToken;
 };
 export declare abstract class AuthnProvider<U extends User> {
-    abstract authenticate(token: AuthnToken): Promise<U>;
+    abstract authenticate($: {
+        trx: AnyTrxNode;
+        token: AuthnToken;
+    }): Promise<U>;
 }
 export type AnyAuthnProviders = {
     [K: string]: AuthnProvider<any>;

package/lib/engine/auth/zero.authn_provider.d.ts

@@ -1,11 +1,13 @@
 import { NesoiObjId } from '../data/obj';
-import { AuthnProvider, AuthnToken } from './authn';
+import { AuthnProvider } from './authn';
 type ZeroUser = {
     id: NesoiObjId;
     name: string;
 };
 export declare class ZeroAuthnProvider extends AuthnProvider<ZeroUser> {
-    authenticate(_token: AuthnToken): Promise<{
+    authenticate($: {
+        token: string;
+    }): Promise<{
         id: number;
         name: string;
     }>;

package/lib/engine/auth/zero.authn_provider.js

@@ -3,10 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZeroAuthnProvider = void 0;
 const authn_1 = require("./authn");
 class ZeroAuthnProvider extends authn_1.AuthnProvider {
-    async authenticate(_token) {
+    authenticate($) {
         return Promise.resolve({
             id: 0,
-            name: 'User Zero'
+            name: $.token
         });
     }
 }

package/lib/engine/cli/cli.d.ts

@@ -11,9 +11,11 @@ export declare class CLI {
     private app;
     private ctx;
     private adapters;
+    private input;
     constructor(daemon: AnyDaemon, config?: CLIConfig<any> | undefined);
-    run(): Promise<void>;
+    run(cmd?: string): Promise<void>;
     private runCmd;
     private cmdHelp;
     private cmdClear;
+    private getCmds;
 }

package/lib/engine/cli/cli.js

@@ -9,6 +9,7 @@ const ui_1 = __importDefault(require("./ui"));
 const console_1 = __importDefault(require("../util/console"));
 const daemon_1 = require("../daemon");
 const log_1 = require("../util/log");
+const cli_input_1 = require("./cli_input");
 class CLI {
     constructor(daemon, config) {
         this.daemon = daemon;
@@ -22,13 +23,20 @@ class CLI {
             this.adapters[key] = val(daemon_1.Daemon.get(daemon, 'providers'));
             this.adapters[key].name = key;
         });
+        this.input = new cli_input_1.CLIInputHandler(this.getCmds());
     }
-    async run() {
+    async run(cmd) {
+        if (cmd) {
+            this.runCmd(cmd);
+            return;
+        }
         console_1.default.header('CLI');
         // eslint-disable-next-line no-constant-condition
         while (true) {
             const ctx = `${(0, string_1.colored)(this.app, 'darkgray')}:${(0, string_1.colored)(this.ctx, 'lightcyan')}${(0, string_1.colored)('$', 'brown')}`;
-            const cmd = await ui_1.default.question(ctx);
+            const cmd = await this.input.input(ctx);
+            if (!cmd)
+                continue;
             try {
                 if (await this.runCmd(cmd)) {
                     break;
@@ -66,7 +74,7 @@ class CLI {
                 return false;
             }
         }
-        ui_1.default.error('Invalid command');
+        ui_1.default.error(`Invalid command '${payload}'`);
         return false;
     }
     cmdHelp() {
@@ -84,5 +92,16 @@ class CLI {
     async cmdClear() {
         console.clear();
     }
+    getCmds() {
+        const cmds = [];
+        for (const a in this.adapters) {
+            const adapter = this.adapters[a];
+            for (const c in adapter.commands) {
+                const command = adapter.commands[c];
+                cmds.push(adapter.name + ' ' + command.name);
+            }
+        }
+        return cmds;
+    }
 }
 exports.CLI = CLI;

package/lib/engine/cli/cli_adapter.d.ts

@@ -1,11 +1,12 @@
 import { AnyDaemon } from '../daemon';
 export declare abstract class CLICommand<T extends Record<string, any> = Record<string, any>> {
+    scope: 'dev' | 'prod' | 'any';
     name: string;
     syntax: string;
     description: string;
     regex?: RegExp | undefined;
     groups?: string[] | undefined;
-    constructor(name: string, syntax: string, description: string, regex?: RegExp | undefined, groups?: string[] | undefined);
+    constructor(scope: 'dev' | 'prod' | 'any', name: string, syntax: string, description: string, regex?: RegExp | undefined, groups?: string[] | undefined);
     input(payload: string): Record<string, any>;
     abstract run(daemon: AnyDaemon, input: T): Promise<void>;
 }

package/lib/engine/cli/cli_adapter.js

@@ -3,7 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CLIAdapter = exports.CLICommand = void 0;
 const string_1 = require("../util/string");
 class CLICommand {
-    constructor(name, syntax, description, regex, groups) {
+    constructor(scope, name, syntax, description, regex, groups) {
+        this.scope = scope;
         this.name = name;
         this.syntax = syntax;
         this.description = description;

package/lib/engine/cli/cli_input.d.ts

@@ -0,0 +1,19 @@
+export declare class CLIInputHandler {
+    private suggestions;
+    private items;
+    private history;
+    private buffer;
+    private cursor;
+    private suggestion?;
+    constructor(suggestions?: string[]);
+    /**
+     * Wait for user input:
+     * - Some text + Enter
+     * - Special Keys: Up/Down/Tab
+     */
+    input(ctx?: string): Promise<string | undefined>;
+    add(item: string): void;
+    up(): string | undefined;
+    down(): string | undefined;
+    suggest(_seed: string): string;
+}

package/lib/engine/cli/cli_input.js

@@ -0,0 +1,207 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLIInputHandler = void 0;
+const stream_1 = require("stream");
+const readline = __importStar(require("readline"));
+class CLIInputHandler {
+    constructor(suggestions = []) {
+        this.suggestions = suggestions;
+        this.items = [];
+        this.history = 0;
+        this.buffer = '';
+        this.cursor = 0;
+    }
+    /**
+     * Wait for user input:
+     * - Some text + Enter
+     * - Special Keys: Up/Down/Tab
+     */
+    async input(ctx) {
+        return new Promise(resolve => {
+            const mutableStdout = new stream_1.Writable({
+                write: function (chunk, encoding, callback) {
+                }
+            });
+            this.buffer = '';
+            this.cursor = 0;
+            this.suggestion = undefined;
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: mutableStdout,
+                terminal: true
+            });
+            const print = () => {
+                process.stdout.clearLine(0);
+                process.stdout.cursorTo(0);
+                process.stdout.write(ctx + ' ' + this.buffer);
+                process.stdout.moveCursor(this.cursor - this.buffer.length, 0);
+            };
+            print();
+            const onKeypress = (ch, key) => {
+                // History
+                if (key.name === 'up') {
+                    this.buffer = this.up() || this.buffer;
+                    this.cursor = this.buffer.length;
+                    print();
+                    return;
+                }
+                if (key.name === 'down') {
+                    this.buffer = this.down() || '';
+                    this.cursor = this.buffer.length;
+                    print();
+                    return;
+                }
+                // Suggestion
+                if (key.name === 'tab') {
+                    this.buffer = this.suggest(this.buffer) || this.buffer;
+                    this.cursor = this.buffer.length;
+                    print();
+                    return;
+                }
+                this.suggestion = undefined;
+                // Text Editing
+                if (key.name === 'left') {
+                    if (this.cursor > 0) {
+                        process.stdout.moveCursor(-1, 0);
+                        this.cursor -= 1;
+                    }
+                    print();
+                    return;
+                }
+                if (key.name === 'right') {
+                    if (this.cursor < this.buffer.length) {
+                        process.stdout.moveCursor(1, 0);
+                        this.cursor += 1;
+                    }
+                    print();
+                    return;
+                }
+                if (key.name === 'backspace') {
+                    if (this.buffer.length == 0) {
+                        return;
+                    }
+                    this.buffer = this.buffer.slice(0, this.cursor - 1)
+                        + this.buffer.slice(this.cursor);
+                    this.cursor -= 1;
+                    print();
+                    return;
+                }
+                if (key.name === 'delete') {
+                    if (this.buffer.length == 0) {
+                        return;
+                    }
+                    this.buffer = this.buffer.slice(0, this.cursor)
+                        + this.buffer.slice(this.cursor + 1);
+                    print();
+                    return;
+                }
+                // Submit
+                if (key.name === 'return') {
+                    submit(this.buffer);
+                    return;
+                }
+                // Text Characters
+                else {
+                    this.buffer = this.buffer.slice(0, this.cursor)
+                        + ch
+                        + this.buffer.slice(this.cursor);
+                    this.cursor += 1;
+                    print();
+                }
+            };
+            const onCancel = () => {
+                if (!this.buffer.length) {
+                    process.stdout.clearLine(0);
+                    process.stdout.cursorTo(0);
+                    process.exit();
+                }
+                submit(undefined);
+            };
+            const submit = (value) => {
+                process.stdout.write('\n');
+                rl.close();
+                process.stdin.off('keypress', onKeypress);
+                rl.off('SIGINT', onCancel);
+                this.buffer = '';
+                if (value !== undefined) {
+                    this.add(value);
+                }
+                resolve(value);
+            };
+            process.stdin.on('keypress', onKeypress);
+            rl.on('SIGINT', onCancel);
+        });
+    }
+    add(item) {
+        this.history = 0;
+        this.suggestion = undefined;
+        if (this.items[0] === item) {
+            return;
+        }
+        this.items.unshift(item);
+    }
+    up() {
+        if (this.history >= this.items.length)
+            return;
+        const item = this.items[this.history];
+        this.history += 1;
+        return item;
+    }
+    down() {
+        if (this.history <= 0)
+            return;
+        const item = this.items[this.history];
+        this.history -= 1;
+        return item;
+    }
+    suggest(_seed) {
+        const idx = this.suggestion?.idx || 0;
+        const seed = this.suggestion?.seed || _seed;
+        for (let i = idx; i < this.suggestions.length; i++) {
+            const sugg = this.suggestions[i];
+            if (sugg.startsWith(seed)) {
+                this.suggestion = {
+                    seed,
+                    idx: i + 1
+                };
+                return sugg;
+            }
+        }
+        this.suggestion = undefined;
+        return seed;
+    }
+}
+exports.CLIInputHandler = CLIInputHandler;

package/lib/engine/cli/ui.d.ts

@@ -2,7 +2,7 @@ export default class UI {
     /**
      * Show a list of options and let the user pick with up/down + enter
      */
-    static select(title: string, options: string[], defaul?: number): Promise<string>;
+    static select<T>(title: string, options: T[], val?: NoInfer<(o: T) => string>, defaul?: number): Promise<T>;
     /**
      * Ask a question and wait for the answer
      */

package/lib/engine/cli/ui.js

@@ -40,7 +40,7 @@ class UI {
     /**
      * Show a list of options and let the user pick with up/down + enter
      */
-    static async select(title, options, defaul = 0) {
+    static async select(title, options, val = (o => o), defaul = 0) {
         return new Promise(resolve => {
             UI.step(title);
             let mute = true;
@@ -61,7 +61,7 @@ class UI {
             const print = () => {
                 mute = false;
                 for (let i = 0; i < options.length; i++) {
-                    rl.write((0, string_1.colored)(`${i === selected ? '» ' : '  '}` + options[i] + '\n', i === selected ? 'lightgreen' : 'lightgray'));
+                    rl.write((0, string_1.colored)(`${i === selected ? '» ' : '  '}` + val(options[i]) + '\n', i === selected ? 'lightgreen' : 'lightgray'));
                 }
                 mute = true;
             };

package/lib/engine/daemon.d.ts

@@ -14,8 +14,9 @@ export declare abstract class Daemon<S extends $Space, Modules extends ModuleNam
     private _cli?;
     constructor(name: string, trxEngines: Record<Modules, AnyTrxEngine>, providers: Record<string, any>, app?: AnyAppConfig | undefined);
     trx<K extends Modules & keyof S['modules']>(moduleName: K): DaemonTrx<S, S["modules"][K], {}>;
-    cli(): Promise<void>;
+    cli(cmd?: string): Promise<void>;
     private bindControllers;
+    static destroy(daemon: AnyDaemon): Promise<void>;
     static reload(daemon: AnyDaemon, trxEngines: Record<string, AnyTrxEngine>, providers: Record<string, any>): void;
     static get<T extends {
         name: string;
@@ -29,7 +30,7 @@ export declare class DaemonTrx<S extends $Space, M extends $Module, Authn extend
     private trxEngine;
     private _authn?;
     constructor(trxEngine: AnyTrxEngine);
-    authn<Authn extends AuthnRequest<keyof S['authnUsers']>>(authn: Authn): DaemonTrx<S, M, { [K in keyof Authn]: S["authnUsers"][K & keyof S["authnUsers"]]; }>;
+    authn<Authn extends AuthnRequest<keyof S['authnUsers']>>(authn?: Authn): DaemonTrx<S, M, { [K in keyof Authn]: S["authnUsers"][K & keyof S["authnUsers"]]; }>;
     run<Output>(fn: (trx: TrxNode<S, M, Authn>) => Promise<Output>): Promise<TrxStatus<Output>>;
 }
 export type AnyDaemon = Daemon<any, any>;