@lifestreamdynamics/vault-cli 1.2.0 → 1.3.0

package/dist/commands/completion.d.ts

@@ -0,0 +1,5 @@
+import type { Command } from 'commander';
+export declare function generateBashCompletion(program: Command): string;
+export declare function generateZshCompletion(program: Command): string;
+export declare function generateFishCompletion(program: Command): string;
+export declare function registerCompletionCommands(program: Command): void;

package/dist/commands/completion.js

@@ -0,0 +1,60 @@
+const SAFE_COMMAND_NAME = /^[a-z][a-z0-9-]*$/;
+function collectCommandNames(cmd, prefix = '') {
+    const names = [];
+    for (const sub of cmd.commands) {
+        const name = sub.name();
+        // Skip any name that doesn't match the safe pattern to prevent shell injection
+        if (!SAFE_COMMAND_NAME.test(name))
+            continue;
+        const full = prefix ? `${prefix} ${name}` : name;
+        names.push(name);
+        names.push(...collectCommandNames(sub, full));
+    }
+    return names;
+}
+export function generateBashCompletion(program) {
+    const commands = collectCommandNames(program);
+    return `# Bash completion for lsvault
+# Add to ~/.bashrc: eval "$(lsvault completion bash)"
+_lsvault_completions() {
+  local cur="\${COMP_WORDS[COMP_CWORD]}"
+  local commands="${commands.join(' ')}"
+  COMPREPLY=($(compgen -W "\${commands}" -- "\${cur}"))
+}
+complete -F _lsvault_completions lsvault
+`;
+}
+export function generateZshCompletion(program) {
+    const commands = collectCommandNames(program);
+    return `# Zsh completion for lsvault
+# Add to ~/.zshrc: eval "$(lsvault completion zsh)"
+_lsvault() {
+  local -a commands
+  commands=(${commands.map(c => `'${c}'`).join(' ')})
+  _describe 'lsvault commands' commands
+}
+compdef _lsvault lsvault
+`;
+}
+export function generateFishCompletion(program) {
+    const commands = collectCommandNames(program);
+    return commands.map(c => `complete -c lsvault -n '__fish_use_subcommand' -a '${c}' -d '${c} command'`).join('\n') + '\n';
+}
+export function registerCompletionCommands(program) {
+    const completion = program.command('completion').description('Generate shell completion scripts');
+    completion.command('bash')
+        .description('Generate bash completion script')
+        .action(() => {
+        process.stdout.write(generateBashCompletion(program));
+    });
+    completion.command('zsh')
+        .description('Generate zsh completion script')
+        .action(() => {
+        process.stdout.write(generateZshCompletion(program));
+    });
+    completion.command('fish')
+        .description('Generate fish completion script')
+        .action(() => {
+        process.stdout.write(generateFishCompletion(program));
+    });
+}

package/dist/commands/config.js

@@ -1,5 +1,6 @@
 import chalk from 'chalk';
 import { resolveProfileName, getActiveProfile, setActiveProfile, loadProfile, setProfileValue, getProfileValue, listProfiles, deleteProfile, } from '../lib/profiles.js';
+const SENSITIVE_KEY_PATTERN = /key|token|secret|password|credential/i;
 export function registerConfigCommands(program) {
     const config = program
         .command('config')
@@ -26,7 +27,7 @@ EXAMPLES
         .action((key, value, opts) => {
         const profile = resolveProfileName(opts.profile);
         setProfileValue(profile, key, value);
-        console.log(chalk.green(`Set ${chalk.bold(key)} in profile ${chalk.bold(profile)}`));
+        process.stdout.write(chalk.green(`Set ${chalk.bold(key)} in profile ${chalk.bold(profile)}`) + '\n');
     });
     config
         .command('get')
@@ -41,10 +42,10 @@ EXAMPLES
         const profile = resolveProfileName(opts.profile);
         const value = getProfileValue(profile, key);
         if (value !== undefined) {
-            console.log(value);
+            process.stdout.write(value + '\n');
         }
         else {
-            console.log(chalk.yellow(`Key "${key}" not set in profile "${profile}"`));
+            process.stdout.write(chalk.yellow(`Key "${key}" not set in profile "${profile}"`) + '\n');
         }
     });
     config
@@ -60,17 +61,17 @@ EXAMPLES
         const profileConfig = loadProfile(profile);
         const keys = Object.keys(profileConfig);
         if (keys.length === 0) {
-            console.log(chalk.yellow(`Profile "${profile}" has no configuration values.`));
+            process.stdout.write(chalk.yellow(`Profile "${profile}" has no configuration values.`) + '\n');
             return;
         }
-        console.log(chalk.bold(`Profile: ${profile}\n`));
+        process.stdout.write(chalk.bold(`Profile: ${profile}\n`) + '\n');
         for (const key of keys) {
             const value = profileConfig[key];
-            // Mask API keys for display
-            const display = key.toLowerCase().includes('key') && value
+            // Mask sensitive values for display
+            const display = SENSITIVE_KEY_PATTERN.test(key) && value
                 ? value.slice(0, 12) + '...'
                 : value;
-            console.log(`  ${chalk.cyan(key)}: ${display}`);
+            process.stdout.write(`  ${chalk.cyan(key)}: ${display}\n`);
         }
     });
     config
@@ -83,7 +84,7 @@ EXAMPLES
   lsvault config use dev`)
         .action((name) => {
         setActiveProfile(name);
-        console.log(chalk.green(`Active profile set to ${chalk.bold(name)}`));
+        process.stdout.write(chalk.green(`Active profile set to ${chalk.bold(name)}`) + '\n');
     });
     config
         .command('profiles')
@@ -95,14 +96,14 @@ EXAMPLES
         const profiles = listProfiles();
         const active = getActiveProfile();
         if (profiles.length === 0) {
-            console.log(chalk.yellow('No profiles configured.'));
-            console.log(chalk.dim('Create one with: lsvault config set <key> <value> --profile <name>'));
+            process.stdout.write(chalk.yellow('No profiles configured.') + '\n');
+            process.stdout.write(chalk.dim('Create one with: lsvault config set <key> <value> --profile <name>') + '\n');
             return;
         }
-        console.log(chalk.bold('Available profiles:\n'));
+        process.stdout.write(chalk.bold('Available profiles:\n') + '\n');
         for (const name of profiles) {
             const marker = name === active ? chalk.green(' (active)') : '';
-            console.log(`  ${chalk.cyan(name)}${marker}`);
+            process.stdout.write(`  ${chalk.cyan(name)}${marker}\n`);
         }
     });
     config
@@ -114,10 +115,10 @@ EXAMPLES
   lsvault config delete staging`)
         .action((name) => {
         if (deleteProfile(name)) {
-            console.log(chalk.green(`Profile "${name}" deleted.`));
+            process.stdout.write(chalk.green(`Profile "${name}" deleted.`) + '\n');
         }
         else {
-            console.log(chalk.yellow(`Profile "${name}" not found.`));
+            process.stdout.write(chalk.yellow(`Profile "${name}" not found.`) + '\n');
         }
     });
     config
@@ -125,6 +126,6 @@ EXAMPLES
         .description('Show the active profile name')
         .action(() => {
         const active = getActiveProfile();
-        console.log(active);
+        process.stdout.write(active + '\n');
     });
 }

package/dist/commands/connectors.js

@@ -2,6 +2,7 @@ import chalk from 'chalk';
 import { getClientAsync } from '../client.js';
 import { addGlobalFlags, resolveFlags } from '../utils/flags.js';
 import { createOutput, handleError } from '../utils/output.js';
+const VALID_PROVIDERS = ['google_drive', 'dropbox', 'onedrive'];
 export function registerConnectorCommands(program) {
     const connectors = program.command('connectors').description('Manage external service connectors (e.g., Google Drive)');
     addGlobalFlags(connectors.command('list')
@@ -79,6 +80,11 @@ export function registerConnectorCommands(program) {
         .action(async (provider, name, _opts) => {
         const flags = resolveFlags(_opts);
         const out = createOutput(flags);
+        if (!VALID_PROVIDERS.includes(provider)) {
+            out.error(`Invalid provider "${provider}". Must be one of: ${VALID_PROVIDERS.join(', ')}`);
+            process.exitCode = 1;
+            return;
+        }
         out.startSpinner('Creating connector...');
         try {
             const client = await getClientAsync();
@@ -127,10 +133,15 @@ export function registerConnectorCommands(program) {
     });
     addGlobalFlags(connectors.command('delete')
         .description('Delete a connector')
-        .argument('<connectorId>', 'Connector ID'))
+        .argument('<connectorId>', 'Connector ID')
+        .option('-y, --yes', 'Skip confirmation prompt'))
         .action(async (connectorId, _opts) => {
         const flags = resolveFlags(_opts);
         const out = createOutput(flags);
+        if (!_opts.yes) {
+            out.status(chalk.yellow(`Pass --yes to delete connector ${connectorId}.`));
+            return;
+        }
         out.startSpinner('Deleting connector...');
         try {
             const client = await getClientAsync();

package/dist/commands/custom-domains.js

@@ -86,10 +86,15 @@ export function registerCustomDomainCommands(program) {
     });
     addGlobalFlags(domains.command('remove')
         .description('Remove a custom domain')
-        .argument('<domainId>', 'Domain ID'))
+        .argument('<domainId>', 'Domain ID')
+        .option('-y, --yes', 'Skip confirmation prompt'))
         .action(async (domainId, _opts) => {
         const flags = resolveFlags(_opts);
         const out = createOutput(flags);
+        if (!_opts.yes) {
+            out.status(chalk.yellow(`Pass --yes to remove custom domain ${domainId}.`));
+            return;
+        }
         out.startSpinner('Removing custom domain...');
         try {
             const client = await getClientAsync();

package/dist/commands/docs.js

@@ -2,7 +2,8 @@ import chalk from 'chalk';
 import { getClientAsync } from '../client.js';
 import { addGlobalFlags, resolveFlags } from '../utils/flags.js';
 import { createOutput, handleError } from '../utils/output.js';
-import { createCredentialManager } from '../lib/credential-manager.js';
+import { getCredentialManager } from '../config.js';
+import { confirmAction } from '../utils/confirm.js';
 export function registerDocCommands(program) {
     const docs = program.command('docs').description('Read, write, move, and delete documents in a vault');
     addGlobalFlags(docs.command('list')
@@ -66,7 +67,7 @@ EXAMPLES
             const result = await client.documents.get(vaultId, docPath);
             // Auto-decrypt if the document is encrypted
             if (result.document.encrypted && !_opts.meta) {
-                const credManager = createCredentialManager();
+                const credManager = getCredentialManager();
                 const vaultKey = await credManager.getVaultKey(vaultId);
                 if (!vaultKey) {
                     out.error('Document is encrypted but no vault key found.');
@@ -124,7 +125,7 @@ EXAMPLES
             const vault = await client.vaults.get(vaultId);
             let doc;
             if (vault.encryptionEnabled) {
-                const credManager = createCredentialManager();
+                const credManager = getCredentialManager();
                 const vaultKey = await credManager.getVaultKey(vaultId);
                 if (!vaultKey) {
                     out.failSpinner('Failed to save document');
@@ -151,12 +152,18 @@ EXAMPLES
     addGlobalFlags(docs.command('delete')
         .description('Permanently delete a document from a vault')
         .argument('<vaultId>', 'Vault ID')
-        .argument('<path>', 'Document path to delete'))
+        .argument('<path>', 'Document path to delete')
+        .option('-y, --yes', 'Skip confirmation prompt'))
         .action(async (vaultId, docPath, _opts) => {
         const flags = resolveFlags(_opts);
         const out = createOutput(flags);
-        out.startSpinner('Deleting document...');
         try {
+            const confirmed = await confirmAction(`Permanently delete "${docPath}" from vault ${vaultId}?`, { yes: _opts.yes });
+            if (!confirmed) {
+                out.status('Deletion cancelled.');
+                return;
+            }
+            out.startSpinner('Deleting document...');
             const client = await getClientAsync();
             await client.documents.delete(vaultId, docPath);
             out.success(`Deleted: ${chalk.cyan(docPath)}`, { path: docPath, deleted: true });

package/dist/commands/hooks.js

@@ -100,10 +100,15 @@ export function registerHookCommands(program) {
     addGlobalFlags(hooks.command('delete')
         .description('Delete a hook')
         .argument('<vaultId>', 'Vault ID')
-        .argument('<hookId>', 'Hook ID'))
+        .argument('<hookId>', 'Hook ID')
+        .option('-y, --yes', 'Skip confirmation prompt'))
         .action(async (vaultId, hookId, _opts) => {
         const flags = resolveFlags(_opts);
         const out = createOutput(flags);
+        if (!_opts.yes) {
+            out.status(chalk.yellow(`Pass --yes to delete hook ${hookId}.`));
+            return;
+        }
         out.startSpinner('Deleting hook...');
         try {
             const client = await getClientAsync();

package/dist/commands/links.js

@@ -87,8 +87,15 @@ export function registerLinkCommands(program) {
             const client = await getClientAsync();
             const graph = await client.vaults.getGraph(vaultId);
             out.stopSpinner();
-            // For graph, output as JSON structure
-            process.stdout.write(JSON.stringify({ nodes: graph.nodes, edges: graph.edges }) + '\n');
+            if (flags.output === 'json') {
+                process.stdout.write(JSON.stringify({ nodes: graph.nodes, edges: graph.edges }) + '\n');
+            }
+            else {
+                process.stdout.write(chalk.bold(`Nodes: ${graph.nodes.length}  Edges: ${graph.edges.length}\n`));
+                for (const node of graph.nodes) {
+                    process.stdout.write(`  ${chalk.cyan(String(node.path ?? node.id))}\n`);
+                }
+            }
         }
         catch (err) {
             handleError(out, err, 'Failed to fetch link graph');

package/dist/commands/mfa.js

@@ -1,6 +1,7 @@
 import chalk from 'chalk';
 import ora from 'ora';
 import { getClientAsync } from '../client.js';
+import { promptPassword, promptMfaCode } from '../utils/prompt.js';
 export function registerMfaCommands(program) {
     const mfa = program.command('mfa').description('Multi-factor authentication management');
     mfa.command('status')
@@ -152,73 +153,3 @@ export function registerMfaCommands(program) {
         }
     });
 }
-/**
- * Prompt for a password from stdin (non-echoing).
- * Returns the password or null if stdin is not a TTY.
- */
-async function promptPassword() {
-    if (!process.stdin.isTTY) {
-        return null;
-    }
-    const readline = await import('node:readline');
-    return new Promise((resolve) => {
-        const rl = readline.createInterface({
-            input: process.stdin,
-            output: process.stderr,
-            terminal: true,
-        });
-        process.stderr.write('Password: ');
-        process.stdin.setRawMode?.(true);
-        let password = '';
-        const onData = (chunk) => {
-            const char = chunk.toString('utf-8');
-            if (char === '\n' || char === '\r' || char === '\u0004') {
-                process.stderr.write('\n');
-                process.stdin.setRawMode?.(false);
-                process.stdin.removeListener('data', onData);
-                rl.close();
-                resolve(password);
-            }
-            else if (char === '\u0003') {
-                // Ctrl+C
-                process.stderr.write('\n');
-                process.stdin.setRawMode?.(false);
-                process.stdin.removeListener('data', onData);
-                rl.close();
-                resolve(null);
-            }
-            else if (char === '\u007F' || char === '\b') {
-                // Backspace
-                if (password.length > 0) {
-                    password = password.slice(0, -1);
-                }
-            }
-            else {
-                password += char;
-            }
-        };
-        process.stdin.on('data', onData);
-        process.stdin.resume();
-    });
-}
-/**
- * Prompt for an MFA code from stdin (6 digits, echoed for visibility).
- * Returns the code or null if stdin is not a TTY.
- */
-async function promptMfaCode() {
-    if (!process.stdin.isTTY) {
-        return null;
-    }
-    const readline = await import('node:readline');
-    return new Promise((resolve) => {
-        const rl = readline.createInterface({
-            input: process.stdin,
-            output: process.stderr,
-            terminal: true,
-        });
-        rl.question('Enter 6-digit code from authenticator app: ', (answer) => {
-            rl.close();
-            resolve(answer.trim() || null);
-        });
-    });
-}

package/dist/commands/plugins.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerPluginCommands(program: Command): void;

package/dist/commands/plugins.js

@@ -0,0 +1,172 @@
+import chalk from 'chalk';
+import { getClientAsync } from '../client.js';
+import { addGlobalFlags, resolveFlags } from '../utils/flags.js';
+import { createOutput, handleError } from '../utils/output.js';
+export function registerPluginCommands(program) {
+    const plugins = program.command('plugins').description('Plugin/extension marketplace management');
+    // ── list ──────────────────────────────────────────────────────────────────
+    addGlobalFlags(plugins.command('list')
+        .description('List all installed plugins'))
+        .action(async (_opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Loading plugins...');
+        try {
+            const client = await getClientAsync();
+            const list = await client.plugins.list();
+            out.stopSpinner();
+            if (list.length === 0 && flags.output !== 'json') {
+                out.raw('No plugins installed.\n');
+            }
+            else {
+                out.list(list.map((p) => ({
+                    pluginId: p.pluginId,
+                    version: p.version,
+                    enabled: p.enabled ? 'yes' : 'no',
+                    settings: Object.keys(p.settings).length > 0 ? JSON.stringify(p.settings) : '',
+                    installedAt: p.installedAt.slice(0, 10),
+                })), {
+                    columns: [
+                        { key: 'pluginId', header: 'Plugin ID' },
+                        { key: 'version', header: 'Version' },
+                        { key: 'enabled', header: 'Enabled' },
+                        { key: 'installedAt', header: 'Installed' },
+                    ],
+                    textFn: (p) => `${chalk.cyan(String(p.pluginId))}@${p.version} ${p.enabled === 'yes' ? chalk.green('enabled') : chalk.dim('disabled')} ${chalk.dim(String(p.installedAt))}`,
+                });
+            }
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to list plugins');
+        }
+    });
+    // ── install ───────────────────────────────────────────────────────────────
+    addGlobalFlags(plugins.command('install')
+        .description('Install a plugin from the marketplace')
+        .requiredOption('--plugin-id <pluginId>', 'Plugin marketplace identifier (e.g. org/plugin-name)')
+        .requiredOption('--version <version>', 'Version to install'))
+        .action(async (_opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Installing plugin...');
+        try {
+            const client = await getClientAsync();
+            const installed = await client.plugins.install({
+                pluginId: _opts.pluginId,
+                version: _opts.version,
+            });
+            out.stopSpinner();
+            if (flags.output === 'json') {
+                out.raw(JSON.stringify(installed, null, 2) + '\n');
+            }
+            else {
+                out.raw(chalk.green(`Plugin installed: ${installed.pluginId}@${installed.version}`) + '\n');
+            }
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to install plugin');
+        }
+    });
+    // ── uninstall ─────────────────────────────────────────────────────────────
+    addGlobalFlags(plugins.command('uninstall')
+        .description('Uninstall a plugin')
+        .argument('<pluginId>', 'Plugin marketplace identifier')
+        .option('--confirm', 'Skip confirmation prompt'))
+        .action(async (pluginId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        if (!_opts.confirm) {
+            out.raw(chalk.yellow(`Pass --confirm to uninstall plugin ${pluginId}.`) + '\n');
+            return;
+        }
+        out.startSpinner('Uninstalling plugin...');
+        try {
+            const client = await getClientAsync();
+            await client.plugins.uninstall(pluginId);
+            out.stopSpinner();
+            out.raw(chalk.green(`Plugin ${pluginId} uninstalled.`) + '\n');
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to uninstall plugin');
+        }
+    });
+    // ── enable ────────────────────────────────────────────────────────────────
+    addGlobalFlags(plugins.command('enable')
+        .description('Enable a plugin')
+        .argument('<pluginId>', 'Plugin marketplace identifier'))
+        .action(async (pluginId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Enabling plugin...');
+        try {
+            const client = await getClientAsync();
+            const updated = await client.plugins.enable(pluginId);
+            out.stopSpinner();
+            if (flags.output === 'json') {
+                out.raw(JSON.stringify(updated, null, 2) + '\n');
+            }
+            else {
+                out.raw(chalk.green(`Plugin ${updated.pluginId} enabled.`) + '\n');
+            }
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to enable plugin');
+        }
+    });
+    // ── disable ───────────────────────────────────────────────────────────────
+    addGlobalFlags(plugins.command('disable')
+        .description('Disable a plugin')
+        .argument('<pluginId>', 'Plugin marketplace identifier'))
+        .action(async (pluginId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Disabling plugin...');
+        try {
+            const client = await getClientAsync();
+            const updated = await client.plugins.disable(pluginId);
+            out.stopSpinner();
+            if (flags.output === 'json') {
+                out.raw(JSON.stringify(updated, null, 2) + '\n');
+            }
+            else {
+                out.raw(chalk.dim(`Plugin ${updated.pluginId} disabled.`) + '\n');
+            }
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to disable plugin');
+        }
+    });
+    // ── update-settings ───────────────────────────────────────────────────────
+    addGlobalFlags(plugins.command('update-settings')
+        .description('Update plugin-specific settings')
+        .argument('<pluginId>', 'Plugin marketplace identifier')
+        .requiredOption('--settings <json>', 'Settings as a JSON string (e.g. \'{"theme":"dark"}\')'))
+        .action(async (pluginId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        let settings;
+        try {
+            settings = JSON.parse(_opts.settings);
+        }
+        catch {
+            out.error('Invalid JSON for --settings. Provide a valid JSON object.');
+            process.exitCode = 2;
+            return;
+        }
+        out.startSpinner('Updating plugin settings...');
+        try {
+            const client = await getClientAsync();
+            const updated = await client.plugins.updateSettings(pluginId, settings);
+            out.stopSpinner();
+            if (flags.output === 'json') {
+                out.raw(JSON.stringify(updated, null, 2) + '\n');
+            }
+            else {
+                out.raw(chalk.green(`Settings updated for ${updated.pluginId}.`) + '\n');
+            }
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to update plugin settings');
+        }
+    });
+}

package/dist/commands/publish.js

@@ -1,7 +1,7 @@
+import chalk from 'chalk';
 import { getClientAsync } from '../client.js';
 import { addGlobalFlags, resolveFlags } from '../utils/flags.js';
 import { createOutput, handleError } from '../utils/output.js';
-import chalk from 'chalk';
 export function registerPublishCommands(program) {
     const publish = program.command('publish').description('Publish documents to public profile pages');
     addGlobalFlags(publish.command('list')
@@ -121,10 +121,15 @@ export function registerPublishCommands(program) {
     addGlobalFlags(publish.command('delete')
         .description('Unpublish a document')
         .argument('<vaultId>', 'Vault ID')
-        .argument('<docPath>', 'Document path (e.g., blog/post.md)'))
+        .argument('<docPath>', 'Document path (e.g., blog/post.md)')
+        .option('-y, --yes', 'Skip confirmation prompt'))
         .action(async (vaultId, docPath, _opts) => {
         const flags = resolveFlags(_opts);
         const out = createOutput(flags);
+        if (!_opts.yes) {
+            out.status(chalk.yellow(`Pass --yes to unpublish document ${docPath}.`));
+            return;
+        }
         out.startSpinner('Unpublishing document...');
         try {
             const client = await getClientAsync();
@@ -172,10 +177,15 @@ export function registerPublishCommands(program) {
     });
     addGlobalFlags(subdomain.command('delete')
         .description('Remove the subdomain for a published vault')
-        .argument('<vaultId>', 'Vault ID'))
+        .argument('<vaultId>', 'Vault ID')
+        .option('-y, --yes', 'Skip confirmation prompt'))
         .action(async (vaultId, _opts) => {
         const flags = resolveFlags(_opts);
         const out = createOutput(flags);
+        if (!_opts.yes) {
+            out.status(chalk.yellow(`Pass --yes to remove the subdomain for vault ${vaultId}.`));
+            return;
+        }
         out.startSpinner('Removing subdomain...');
         try {
             const client = await getClientAsync();

package/dist/commands/saml.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerSamlCommands(program: Command): void;