@proletariat/cli 0.3.19 → 0.3.21

package/dist/commands/execution/config.js

@@ -0,0 +1,433 @@
+import { Flags } from '@oclif/core';
+import * as path from 'node:path';
+import Database from 'better-sqlite3';
+import inquirer from 'inquirer';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { styles } from '../../lib/styles.js';
+import { getWorkspaceInfo } from '../../lib/agents/commands.js';
+import { loadExecutionConfig, saveTerminalApp, saveTerminalOpenInBackground, saveTmuxControlMode, saveShell, saveExecutionSetting, } from '../../lib/execution/config.js';
+import { shouldOutputJson, isAgentMode, outputPromptAsJson, outputSuccessAsJson, outputErrorAsJson, createMetadata, normalizeChoices, } from '../../lib/prompt-json.js';
+export default class ExecutionConfig extends PMOCommand {
+    static description = 'View and update execution preferences';
+    static examples = [
+        '<%= config.bin %> execution config                    # Interactive menu',
+        '<%= config.bin %> execution config --json             # Output current config as JSON',
+        '<%= config.bin %> execution config --list             # Show all settings',
+        '<%= config.bin %> execution config --set defaultEnvironment host',
+        '<%= config.bin %> execution config --set outputMode interactive',
+        '<%= config.bin %> execution config --set sandboxed true',
+        '<%= config.bin %> execution config --setting outputMode --json  # Show output mode choices',
+    ];
+    static flags = {
+        ...pmoBaseFlags,
+        json: Flags.boolean({
+            description: 'Output configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+        set: Flags.string({
+            char: 's',
+            description: 'Set a config value (format: key value)',
+            multiple: true,
+        }),
+        list: Flags.boolean({
+            char: 'l',
+            description: 'List all configuration values',
+            default: false,
+        }),
+        setting: Flags.string({
+            description: 'Navigate to a specific setting prompt (for agent navigation)',
+        }),
+    };
+    getPMOOptions() {
+        return { promptIfMultiple: false };
+    }
+    /**
+     * Prompt wrapper - drop-in replacement for inquirer.prompt
+     */
+    async promptUser(questions, jsonModeConfig) {
+        if (jsonModeConfig && isAgentMode(jsonModeConfig.flags)) {
+            const firstQuestion = questions[0];
+            if (firstQuestion) {
+                const choices = firstQuestion.choices
+                    ? normalizeChoices(firstQuestion.choices)
+                    : undefined;
+                outputPromptAsJson({
+                    type: firstQuestion.type,
+                    name: firstQuestion.name,
+                    message: firstQuestion.message,
+                    choices,
+                    default: firstQuestion.default,
+                }, createMetadata(jsonModeConfig.commandName, jsonModeConfig.flags));
+            }
+            return {};
+        }
+        return inquirer.prompt(questions);
+    }
+    async execute() {
+        const { flags } = await this.parse(ExecutionConfig);
+        const jsonMode = shouldOutputJson(flags);
+        const jsonModeConfig = jsonMode ? { flags, commandName: 'execution config' } : null;
+        // Get workspace info
+        let workspaceInfo;
+        try {
+            workspaceInfo = getWorkspaceInfo();
+        }
+        catch {
+            if (jsonMode) {
+                outputErrorAsJson('NOT_IN_WORKSPACE', 'Not in a workspace. Run "prlt init" first.', createMetadata('execution config', flags));
+                this.exit(1);
+            }
+            this.error('Not in a workspace. Run "prlt init" first.');
+        }
+        // Open database
+        const dbPath = path.join(workspaceInfo.path, '.proletariat', 'workspace.db');
+        const db = new Database(dbPath);
+        try {
+            // Load current config
+            const config = loadExecutionConfig(db);
+            // Handle --set flag
+            if (flags.set && flags.set.length > 0) {
+                for (const setValue of flags.set) {
+                    const [key, ...valueParts] = setValue.split(' ');
+                    const value = valueParts.join(' ');
+                    if (!key || !value) {
+                        if (jsonMode) {
+                            outputErrorAsJson('INVALID_SET_FORMAT', `Invalid format: "${setValue}". Use: --set "key value"`, createMetadata('execution config', flags));
+                        }
+                        else {
+                            this.error(`Invalid format: "${setValue}". Use: --set "key value"`);
+                        }
+                        continue;
+                    }
+                    this.setConfigValue(db, key, value, jsonMode);
+                }
+                db.close();
+                return;
+            }
+            // Handle --list or --json flag without --setting (just show config)
+            if ((flags.list || flags.json) && !flags.setting) {
+                if (jsonMode) {
+                    outputSuccessAsJson({
+                        terminal: {
+                            app: config.terminal.app,
+                            openInBackground: config.terminal.openInBackground,
+                        },
+                        shell: config.shell,
+                        tmux: {
+                            controlMode: config.tmux.controlMode,
+                        },
+                        defaultEnvironment: config.defaultEnvironment,
+                        defaultExecutor: config.defaultExecutor,
+                        outputMode: config.outputMode,
+                        sandboxed: config.sandboxed,
+                    }, createMetadata('execution config', flags));
+                }
+                else {
+                    this.log('');
+                    this.log(styles.header('Execution Configuration'));
+                    this.log('═'.repeat(50));
+                    this.log('');
+                    this.log(styles.emphasis('Environment'));
+                    this.log(`  defaultEnvironment: ${config.defaultEnvironment}`);
+                    this.log(`  defaultExecutor:    ${config.defaultExecutor}`);
+                    this.log('');
+                    this.log(styles.emphasis('Output'));
+                    this.log(`  outputMode:         ${config.outputMode}`);
+                    this.log(`  sandboxed:          ${config.sandboxed}`);
+                    this.log('');
+                    this.log(styles.emphasis('Terminal'));
+                    this.log(`  app:                ${config.terminal.app}`);
+                    this.log(`  openInBackground:   ${config.terminal.openInBackground}`);
+                    this.log('');
+                    this.log(styles.emphasis('Shell'));
+                    this.log(`  shell:              ${config.shell}`);
+                    this.log('');
+                    this.log(styles.emphasis('Tmux'));
+                    this.log(`  controlMode:        ${config.tmux.controlMode}`);
+                    this.log('');
+                }
+                db.close();
+                return;
+            }
+            // Handle --setting flag (navigate directly to a sub-prompt)
+            if (flags.setting) {
+                await this.handleSettingPrompt(db, config, flags.setting, jsonModeConfig);
+                db.close();
+                return;
+            }
+            // Interactive menu
+            const settingChoices = [
+                { name: `Default Environment: ${config.defaultEnvironment}`, value: 'defaultEnvironment', command: 'prlt execution config --setting defaultEnvironment --json' },
+                { name: `Output Mode: ${config.outputMode}`, value: 'outputMode', command: 'prlt execution config --setting outputMode --json' },
+                { name: `Permission Mode: ${config.sandboxed ? 'safe' : 'danger'}`, value: 'sandboxed', command: 'prlt execution config --setting sandboxed --json' },
+                { name: `Terminal App: ${config.terminal.app}`, value: 'terminal.app', command: 'prlt execution config --setting terminal.app --json' },
+                { name: `Open Tabs in Background: ${config.terminal.openInBackground}`, value: 'terminal.openInBackground', command: 'prlt execution config --setting terminal.openInBackground --json' },
+                { name: `Shell: ${config.shell}`, value: 'shell', command: 'prlt execution config --setting shell --json' },
+                { name: `Tmux Control Mode: ${config.tmux.controlMode}`, value: 'tmux.controlMode', command: 'prlt execution config --setting tmux.controlMode --json' },
+            ];
+            const { setting } = await this.promptUser([
+                {
+                    type: 'list',
+                    name: 'setting',
+                    message: 'Select setting to configure:',
+                    choices: [
+                        new inquirer.Separator('── Execution ──'),
+                        ...settingChoices.slice(0, 3),
+                        new inquirer.Separator('── Terminal ──'),
+                        ...settingChoices.slice(3, 5),
+                        new inquirer.Separator('── Shell ──'),
+                        settingChoices[5],
+                        new inquirer.Separator('── Tmux ──'),
+                        settingChoices[6],
+                        new inquirer.Separator(),
+                        { name: 'Exit', value: '__exit__' },
+                    ],
+                },
+            ], jsonModeConfig);
+            if (setting === '__exit__') {
+                db.close();
+                return;
+            }
+            // Handle the selected setting
+            await this.handleSettingPrompt(db, config, setting, jsonModeConfig);
+            db.close();
+        }
+        catch (error) {
+            db.close();
+            throw error;
+        }
+    }
+    /**
+     * Handle a specific setting's sub-prompt
+     */
+    async handleSettingPrompt(db, config, setting, jsonModeConfig) {
+        switch (setting) {
+            case 'defaultEnvironment': {
+                const envChoices = [
+                    { name: 'host - Run directly on host machine', value: 'host', command: 'prlt execution config --set "defaultEnvironment host" --json' },
+                    { name: 'devcontainer - Run in a devcontainer (sandboxed)', value: 'devcontainer', command: 'prlt execution config --set "defaultEnvironment devcontainer" --json' },
+                    { name: 'docker - Run in a Docker container', value: 'docker', command: 'prlt execution config --set "defaultEnvironment docker" --json' },
+                    { name: 'vm - Run on a remote VM', value: 'vm', command: 'prlt execution config --set "defaultEnvironment vm" --json' },
+                ];
+                const { newEnv } = await this.promptUser([
+                    {
+                        type: 'list',
+                        name: 'newEnv',
+                        message: 'Select default execution environment:',
+                        choices: envChoices,
+                        default: config.defaultEnvironment,
+                    },
+                ], jsonModeConfig);
+                saveExecutionSetting(db, 'defaultMode', newEnv);
+                this.log(styles.success(`Default environment set to: ${newEnv}`));
+                break;
+            }
+            case 'outputMode': {
+                const outputChoices = [
+                    { name: 'interactive - Watch Claude work in real-time (streaming UI)', value: 'interactive', command: 'prlt execution config --set "outputMode interactive" --json' },
+                    { name: 'print - Show final result only (better for logs)', value: 'print', command: 'prlt execution config --set "outputMode print" --json' },
+                ];
+                const { newOutput } = await this.promptUser([
+                    {
+                        type: 'list',
+                        name: 'newOutput',
+                        message: 'Select output mode:',
+                        choices: outputChoices,
+                        default: config.outputMode,
+                    },
+                ], jsonModeConfig);
+                this.setConfigValue(db, 'outputMode', newOutput, false);
+                this.log(styles.success(`Output mode set to: ${newOutput}`));
+                break;
+            }
+            case 'sandboxed': {
+                const permChoices = [
+                    { name: 'safe - Requires approval for dangerous operations (recommended)', value: 'true', command: 'prlt execution config --set "sandboxed true" --json' },
+                    { name: 'danger - Skip permission checks (--dangerously-skip-permissions)', value: 'false', command: 'prlt execution config --set "sandboxed false" --json' },
+                ];
+                const { newPerm } = await this.promptUser([
+                    {
+                        type: 'list',
+                        name: 'newPerm',
+                        message: 'Select permission mode:',
+                        choices: permChoices,
+                        default: String(config.sandboxed),
+                    },
+                ], jsonModeConfig);
+                this.setConfigValue(db, 'sandboxed', newPerm, false);
+                this.log(styles.success(`Permission mode set to: ${newPerm === 'true' ? 'safe' : 'danger'}`));
+                break;
+            }
+            case 'terminal.app': {
+                const appChoices = [
+                    { name: 'iTerm', value: 'iTerm', command: 'prlt execution config --set "terminal.app iTerm" --json' },
+                    { name: 'Terminal.app (macOS default)', value: 'Terminal', command: 'prlt execution config --set "terminal.app Terminal" --json' },
+                    { name: 'Ghostty', value: 'Ghostty', command: 'prlt execution config --set "terminal.app Ghostty" --json' },
+                    { name: 'Alacritty', value: 'Alacritty', command: 'prlt execution config --set "terminal.app Alacritty" --json' },
+                    { name: 'Kitty', value: 'Kitty', command: 'prlt execution config --set "terminal.app Kitty" --json' },
+                    { name: 'WezTerm', value: 'WezTerm', command: 'prlt execution config --set "terminal.app WezTerm" --json' },
+                    { name: 'Warp', value: 'Warp', command: 'prlt execution config --set "terminal.app Warp" --json' },
+                    { name: 'tmux', value: 'tmux', command: 'prlt execution config --set "terminal.app tmux" --json' },
+                ];
+                const { newApp } = await this.promptUser([
+                    {
+                        type: 'list',
+                        name: 'newApp',
+                        message: 'Select terminal app:',
+                        choices: appChoices,
+                        default: config.terminal.app,
+                    },
+                ], jsonModeConfig);
+                saveTerminalApp(db, newApp);
+                this.log(styles.success(`Terminal app set to: ${newApp}`));
+                break;
+            }
+            case 'terminal.openInBackground': {
+                const bgChoices = [
+                    { name: 'Yes - Open tabs in background (don\'t steal focus)', value: 'true', command: 'prlt execution config --set "terminal.openInBackground true" --json' },
+                    { name: 'No - Bring terminal to foreground when opening tabs', value: 'false', command: 'prlt execution config --set "terminal.openInBackground false" --json' },
+                ];
+                const { openInBg } = await this.promptUser([
+                    {
+                        type: 'list',
+                        name: 'openInBg',
+                        message: 'Open terminal tabs in background?',
+                        choices: bgChoices,
+                        default: String(config.terminal.openInBackground),
+                    },
+                ], jsonModeConfig);
+                saveTerminalOpenInBackground(db, openInBg === 'true');
+                this.log(styles.success(`Open in background set to: ${openInBg}`));
+                break;
+            }
+            case 'shell': {
+                const shellChoices = [
+                    { name: 'zsh (macOS default)', value: 'zsh', command: 'prlt execution config --set "shell zsh" --json' },
+                    { name: 'bash', value: 'bash', command: 'prlt execution config --set "shell bash" --json' },
+                    { name: 'fish', value: 'fish', command: 'prlt execution config --set "shell fish" --json' },
+                ];
+                const { newShell } = await this.promptUser([
+                    {
+                        type: 'list',
+                        name: 'newShell',
+                        message: 'Select shell:',
+                        choices: shellChoices,
+                        default: config.shell,
+                    },
+                ], jsonModeConfig);
+                saveShell(db, newShell);
+                this.log(styles.success(`Shell set to: ${newShell}`));
+                break;
+            }
+            case 'tmux.controlMode': {
+                const ccChoices = [
+                    { name: 'Yes - Use tmux -CC for native iTerm integration', value: 'true', command: 'prlt execution config --set "tmux.controlMode true" --json' },
+                    { name: 'No - Standard tmux interface', value: 'false', command: 'prlt execution config --set "tmux.controlMode false" --json' },
+                ];
+                const { controlMode } = await this.promptUser([
+                    {
+                        type: 'list',
+                        name: 'controlMode',
+                        message: 'Enable tmux control mode (-CC)?',
+                        choices: ccChoices,
+                        default: String(config.tmux.controlMode),
+                    },
+                ], jsonModeConfig);
+                saveTmuxControlMode(db, controlMode === 'true');
+                this.log(styles.success(`Tmux control mode set to: ${controlMode}`));
+                break;
+            }
+            default: {
+                const jsonMode = shouldOutputJson(jsonModeConfig?.flags ?? {});
+                if (jsonMode) {
+                    outputErrorAsJson('UNKNOWN_SETTING', `Unknown setting: ${setting}`, createMetadata('execution config', jsonModeConfig?.flags ?? {}));
+                }
+                this.error(`Unknown setting: ${setting}`);
+            }
+        }
+    }
+    setConfigValue(db, key, value, jsonMode) {
+        const normalizedKey = key.toLowerCase();
+        // Define valid values for each config key
+        const VALID_VALUES = {
+            defaultenvironment: ['host', 'devcontainer', 'docker', 'vm'],
+            outputmode: ['interactive', 'print'],
+            sandboxed: ['true', 'false'],
+            'terminal.app': ['Terminal', 'iTerm', 'Alacritty', 'Ghostty', 'Kitty', 'tmux', 'Warp', 'WezTerm'],
+            'terminal.openinbackground': ['true', 'false'],
+            shell: ['bash', 'zsh', 'fish'],
+            'tmux.controlmode': ['true', 'false'],
+        };
+        // Validate value against allowed options
+        const validValues = VALID_VALUES[normalizedKey];
+        if (validValues && !validValues.includes(value)) {
+            const errorMsg = `Invalid value "${value}" for ${key}. Valid options: ${validValues.join(', ')}`;
+            if (jsonMode) {
+                outputErrorAsJson('INVALID_VALUE', errorMsg, createMetadata('execution config', {}));
+            }
+            else {
+                this.error(errorMsg);
+            }
+            return;
+        }
+        switch (normalizedKey) {
+            case 'defaultenvironment':
+                saveExecutionSetting(db, 'defaultMode', value);
+                break;
+            case 'outputmode':
+                // Store output mode - need to add this to the config storage
+                this.setOutputMode(db, value);
+                break;
+            case 'sandboxed':
+                // Store sandboxed preference
+                this.setSandboxed(db, value.toLowerCase() === 'true');
+                break;
+            case 'terminal.app':
+                saveTerminalApp(db, value);
+                break;
+            case 'terminal.openinbackground':
+                saveTerminalOpenInBackground(db, value.toLowerCase() === 'true');
+                break;
+            case 'shell':
+                saveShell(db, value);
+                break;
+            case 'tmux.controlmode':
+                saveTmuxControlMode(db, value.toLowerCase() === 'true');
+                break;
+            default:
+                if (jsonMode) {
+                    outputErrorAsJson('UNKNOWN_KEY', `Unknown config key: ${key}`, createMetadata('execution config', {}));
+                }
+                else {
+                    this.warn(`Unknown config key: ${key}`);
+                }
+                return;
+        }
+        if (jsonMode) {
+            outputSuccessAsJson({ key, value }, createMetadata('execution config', {}));
+        }
+        else {
+            this.log(styles.success(`Set ${key} = ${value}`));
+        }
+    }
+    /**
+     * Save output mode to workspace settings
+     */
+    setOutputMode(db, mode) {
+        db.prepare(`
+      INSERT INTO workspace_settings (key, value)
+      VALUES (?, ?)
+      ON CONFLICT(key) DO UPDATE SET value = excluded.value
+    `).run('execution.output_mode', mode);
+    }
+    /**
+     * Save sandboxed preference to workspace settings
+     */
+    setSandboxed(db, sandboxed) {
+        db.prepare(`
+      INSERT INTO workspace_settings (key, value)
+      VALUES (?, ?)
+      ON CONFLICT(key) DO UPDATE SET value = excluded.value
+    `).run('execution.sandboxed', sandboxed.toString());
+    }
+}

package/dist/commands/execution/index.js

@@ -2,9 +2,10 @@ import { Flags } from '@oclif/core';
 import inquirer from 'inquirer';
 import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
 export default class Execution extends PMOCommand {
-    static description = 'Single execution operations (logs, stop)';
+    static description = 'Single execution operations (view, logs, stop)';
     static examples = [
         '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> view WORK-001',
         '<%= config.bin %> <%= command.id %> logs WORK-001',
         '<%= config.bin %> <%= command.id %> stop WORK-001',
     ];
@@ -28,9 +29,11 @@ export default class Execution extends PMOCommand {
                 message: 'What would you like to do?',
                 choices: [
                     { name: '📋 List all executions', value: 'list', command: 'prlt execution list --json' },
+                    { name: '🔍 View execution details', value: 'view', command: 'prlt execution view --json' },
                     { name: '📜 View logs for an execution', value: 'logs', command: 'prlt execution logs --json' },
                     { name: '🛑 Stop an execution', value: 'stop', command: 'prlt execution stop --json' },
                     { name: '🛑 Stop all running', value: 'stop-all', command: 'prlt execution stop --all --json' },
+                    { name: '⚙️  Configure execution preferences', value: 'config', command: 'prlt execution config --json' },
                     new inquirer.Separator(),
                     { name: '❌ Cancel', value: 'cancel', command: '' },
                 ],
@@ -42,9 +45,11 @@ export default class Execution extends PMOCommand {
         // Run the selected subcommand
         const commands = {
             list: { cmd: 'execution:list', args: [] },
+            view: { cmd: 'execution:view', args: [] },
             logs: { cmd: 'execution:logs', args: [] },
             stop: { cmd: 'execution:stop', args: [] },
             'stop-all': { cmd: 'execution:stop', args: ['--all'] },
+            config: { cmd: 'execution:config', args: [] },
         };
         const command = commands[action];
         if (command) {

package/dist/commands/execution/kill.d.ts

@@ -0,0 +1,12 @@
+import ExecutionStop from './stop.js';
+/**
+ * Alias for 'execution stop' command.
+ * Users intuitively try 'execution kill' so this provides a familiar interface.
+ */
+export default class ExecutionKill extends ExecutionStop {
+    static description: string;
+    static args: {
+        id: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static examples: string[];
+}

package/dist/commands/execution/kill.js

@@ -0,0 +1,17 @@
+import ExecutionStop from './stop.js';
+/**
+ * Alias for 'execution stop' command.
+ * Users intuitively try 'execution kill' so this provides a familiar interface.
+ */
+export default class ExecutionKill extends ExecutionStop {
+    static description = 'Stop running execution(s) (alias for "execution stop")';
+    static args = ExecutionStop.args;
+    static examples = [
+        '<%= config.bin %> <%= command.id %> WORK-001',
+        '<%= config.bin %> <%= command.id %> WORK-001 --force',
+        '<%= config.bin %> <%= command.id %>  # Interactive mode',
+        '<%= config.bin %> <%= command.id %> --all',
+        '<%= config.bin %> <%= command.id %> --all --force',
+        '<%= config.bin %> <%= command.id %> --agent altman',
+    ];
+}

package/dist/commands/execution/list.js

@@ -28,6 +28,7 @@ export default class ExecutionList extends PMOCommand {
             char: 'l',
             description: 'Number of results',
             default: 20,
+            min: 1,
         }),
     };
     getPMOOptions() {
@@ -61,10 +62,10 @@ export default class ExecutionList extends PMOCommand {
             this.log('');
             this.log(styles.header('🚀 Agent Work'));
             this.log('═'.repeat(100));
-            this.log(styles.muted(padEnd('ID', 11) +
+            this.log(styles.muted(padEnd('ID', 14) +
                 padEnd('Ticket', 9) +
                 padEnd('Agent', 10) +
-                padEnd('Env', 12) +
+                padEnd('Env', 13) +
                 padEnd('Display', 11) +
                 padEnd('Perms', 8) +
                 padEnd('Status', 10) +
@@ -78,10 +79,10 @@ export default class ExecutionList extends PMOCommand {
                 const envStr = `${envIcon} ${exec.environment}`;
                 const permsStr = exec.sandboxed ? 'safe' : 'danger';
                 const permsColor = exec.sandboxed ? styles.success : styles.warning;
-                this.log(padEnd(exec.id, 11) +
+                this.log(padEnd(exec.id, 14) +
                     padEnd(exec.ticketId, 9) +
                     padEnd(exec.agentName, 10) +
-                    padEnd(envStr, 12) +
+                    padEnd(envStr, 13) +
                     padEnd(exec.displayMode, 11) +
                     permsColor(padEnd(permsStr, 8)) +
                     statusColor(padEnd(exec.status, 10)) +

package/dist/commands/execution/logs.js

@@ -32,6 +32,7 @@ export default class ExecutionLogs extends PMOCommand {
         tail: Flags.integer({
             char: 'n',
             description: 'Show last n lines',
+            min: 1,
         }),
         json: Flags.boolean({
             description: 'Output prompt configuration as JSON (for AI agents/scripts)',

package/dist/commands/execution/view.d.ts

@@ -0,0 +1,17 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class ExecutionView extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        machine: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    protected getPMOOptions(): {
+        promptIfMultiple: boolean;
+    };
+    execute(): Promise<void>;
+}