@lifestreamdynamics/vault-cli 1.3.4 → 1.3.6

package/dist/commands/docs.js

@@ -4,32 +4,45 @@ import { addGlobalFlags, resolveFlags } from '../utils/flags.js';
 import { createOutput, handleError } from '../utils/output.js';
 import { getCredentialManager } from '../config.js';
 import { confirmAction } from '../utils/confirm.js';
+import { resolveVaultId } from '../utils/resolve-vault.js';
 export function registerDocCommands(program) {
     const docs = program.command('docs').description('Read, write, move, and delete documents in a vault');
     addGlobalFlags(docs.command('list')
         .description('List documents in a vault, optionally filtered by directory')
-        .argument('<vaultId>', 'Vault ID')
+        .argument('<vaultId>', 'Vault ID or slug')
         .option('--dir <path>', 'Filter by directory path')
+        .option('--limit <n>', 'Maximum number of documents to return')
+        .option('--offset <n>', 'Number of documents to skip')
+        .option('--tag <tags>', 'Filter by tags (comma-separated)')
         .addHelpText('after', `
 EXAMPLES
   lsvault docs list abc123
-  lsvault docs list abc123 --dir notes/meetings`))
+  lsvault docs list abc123 --dir notes/meetings
+  lsvault docs list abc123 --tag work,project --limit 20
+  lsvault docs list abc123 --limit 50 --offset 100`))
         .action(async (vaultId, _opts) => {
         const flags = resolveFlags(_opts);
         const out = createOutput(flags);
         out.startSpinner('Fetching documents...');
         try {
+            vaultId = await resolveVaultId(vaultId);
             const client = await getClientAsync();
-            const documents = await client.documents.list(vaultId, _opts.dir);
+            const dirPath = _opts.dir ? String(_opts.dir).replace(/\/+$/, '') : undefined;
+            const limit = _opts.limit !== undefined ? Number(_opts.limit) : undefined;
+            const offset = _opts.offset !== undefined ? Number(_opts.offset) : undefined;
+            const tags = _opts.tag ? String(_opts.tag).split(',').map((t) => t.trim()).filter(Boolean) : undefined;
+            const documents = await client.documents.list(vaultId, dirPath, { limit, offset, tags });
             out.stopSpinner();
             out.list(documents.map(doc => ({
+                id: doc.id,
                 path: doc.path,
-                title: doc.title || '',
+                title: doc.title ?? null,
                 tags: Array.isArray(doc.tags) ? doc.tags.join(', ') : '',
                 sizeBytes: doc.sizeBytes,
             })), {
                 emptyMessage: 'No documents found.',
                 columns: [
+                    { key: 'id', header: 'ID' },
                     { key: 'path', header: 'Path' },
                     { key: 'title', header: 'Title' },
                     { key: 'tags', header: 'Tags' },
@@ -38,7 +51,7 @@ EXAMPLES
                 textFn: (doc) => {
                     const title = doc.title ? chalk.dim(` -- ${String(doc.title)}`) : '';
                     const tags = doc.tags ? chalk.blue(` [${String(doc.tags)}]`) : '';
-                    return `${chalk.cyan(String(doc.path))}${title}${tags}`;
+                    return `${chalk.cyan(String(doc.path))}${title}${tags} ${chalk.dim(String(doc.id))}`;
                 },
             });
             if (flags.output === 'text' && documents.length > 0) {
@@ -51,7 +64,7 @@ EXAMPLES
     });
     addGlobalFlags(docs.command('get')
         .description('Print document content to stdout, or show metadata with --meta')
-        .argument('<vaultId>', 'Vault ID')
+        .argument('<vaultId>', 'Vault ID or slug')
         .argument('<path>', 'Document path (e.g., notes/todo.md)')
         .option('--meta', 'Show metadata instead of content')
         .addHelpText('after', `
@@ -63,6 +76,7 @@ EXAMPLES
         const flags = resolveFlags(_opts);
         const out = createOutput(flags);
         try {
+            vaultId = await resolveVaultId(vaultId);
             const client = await getClientAsync();
             const result = await client.documents.get(vaultId, docPath);
             // Auto-decrypt if the document is encrypted
@@ -82,6 +96,7 @@ EXAMPLES
             if (_opts.meta) {
                 const doc = result.document;
                 out.record({
+                    id: doc.id,
                     path: doc.path,
                     title: doc.title,
                     sizeBytes: doc.sizeBytes,
@@ -93,6 +108,9 @@ EXAMPLES
                     updatedAt: doc.updatedAt,
                 });
             }
+            else if (flags.output === 'json') {
+                out.raw(JSON.stringify({ path: result.document.path, content: result.content }) + '\n');
+            }
             else {
                 out.raw(result.content);
             }
@@ -103,7 +121,7 @@ EXAMPLES
     });
     addGlobalFlags(docs.command('put')
         .description('Create or update a document by reading content from stdin')
-        .argument('<vaultId>', 'Vault ID')
+        .argument('<vaultId>', 'Vault ID or slug')
         .argument('<path>', 'Document path (must end with .md)')
         .addHelpText('after', `
 EXAMPLES
@@ -114,11 +132,19 @@ EXAMPLES
         const out = createOutput(flags);
         out.startSpinner('Reading stdin...');
         try {
+            vaultId = await resolveVaultId(vaultId);
             const content = await new Promise((resolve) => {
                 let data = '';
                 process.stdin.on('data', (chunk) => data += chunk);
                 process.stdin.on('end', () => resolve(data));
             });
+            if (!content.trim()) {
+                out.failSpinner('No content received');
+                out.error('No content received on stdin. Pipe content to this command:');
+                out.status(chalk.dim(`  echo "# Hello" | lsvault docs put ${vaultId} ${docPath}`));
+                process.exitCode = 1;
+                return;
+            }
             out.startSpinner('Uploading document...');
             const client = await getClientAsync();
             // Check if vault is encrypted and auto-encrypt
@@ -139,10 +165,10 @@ EXAMPLES
             else {
                 doc = await client.documents.put(vaultId, docPath, content);
             }
-            out.success(`Document saved: ${chalk.cyan(doc.path)} (${doc.sizeBytes} bytes)`, {
+            out.success(`Document saved: ${chalk.cyan(doc.path)} (${doc.sizeBytes ?? 0} bytes)`, {
                 path: doc.path,
-                sizeBytes: doc.sizeBytes,
-                encrypted: doc.encrypted,
+                sizeBytes: doc.sizeBytes ?? 0,
+                encrypted: doc.encrypted ?? false,
             });
         }
         catch (err) {
@@ -151,13 +177,14 @@ EXAMPLES
     });
     addGlobalFlags(docs.command('delete')
         .description('Permanently delete a document from a vault')
-        .argument('<vaultId>', 'Vault ID')
+        .argument('<vaultId>', 'Vault ID or slug')
         .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);
         try {
+            vaultId = await resolveVaultId(vaultId);
             const confirmed = await confirmAction(`Permanently delete "${docPath}" from vault ${vaultId}?`, { yes: _opts.yes });
             if (!confirmed) {
                 out.status('Deletion cancelled.');
@@ -174,7 +201,7 @@ EXAMPLES
     });
     addGlobalFlags(docs.command('move')
         .description('Move or rename a document within a vault')
-        .argument('<vaultId>', 'Vault ID')
+        .argument('<vaultId>', 'Vault ID or slug')
         .argument('<source>', 'Current document path')
         .argument('<dest>', 'New document path')
         .option('--overwrite', 'Overwrite if destination already exists')
@@ -185,8 +212,17 @@ EXAMPLES
         .action(async (vaultId, source, dest, _opts) => {
         const flags = resolveFlags(_opts);
         const out = createOutput(flags);
+        if (flags.dryRun) {
+            out.success(`[dry-run] Would move: ${source} → ${dest}`, {
+                dryRun: true,
+                source,
+                destination: dest,
+            });
+            return;
+        }
         out.startSpinner('Moving document...');
         try {
+            vaultId = await resolveVaultId(vaultId);
             const client = await getClientAsync();
             const result = await client.documents.move(vaultId, source, dest, _opts.overwrite);
             out.success(`Moved: ${chalk.cyan(result.source)} -> ${chalk.cyan(result.destination)}`, {
@@ -200,7 +236,7 @@ EXAMPLES
     });
     addGlobalFlags(docs.command('bulk-move')
         .description('Move multiple documents to a target directory')
-        .argument('<vaultId>', 'Vault ID')
+        .argument('<vaultId>', 'Vault ID or slug')
         .requiredOption('--paths <csv>', 'Comma-separated list of document paths')
         .requiredOption('--target <dir>', 'Target directory'))
         .action(async (vaultId, _opts) => {
@@ -208,9 +244,10 @@ EXAMPLES
         const out = createOutput(flags);
         out.startSpinner('Moving documents...');
         try {
+            vaultId = await resolveVaultId(vaultId);
             const client = await getClientAsync();
             const paths = (String(_opts.paths)).split(',').map(p => p.trim()).filter(Boolean);
-            const result = await client.documents.bulkMove(vaultId, { paths, targetDirectory: _opts.target });
+            const result = await client.documents.bulkMove(vaultId, { items: paths, destination: _opts.target });
             out.stopSpinner();
             if (flags.output === 'json') {
                 out.raw(JSON.stringify(result, null, 2) + '\n');
@@ -229,7 +266,7 @@ EXAMPLES
     });
     addGlobalFlags(docs.command('bulk-copy')
         .description('Copy multiple documents to a target directory')
-        .argument('<vaultId>', 'Vault ID')
+        .argument('<vaultId>', 'Vault ID or slug')
         .requiredOption('--paths <csv>', 'Comma-separated list of document paths')
         .requiredOption('--target <dir>', 'Target directory'))
         .action(async (vaultId, _opts) => {
@@ -237,9 +274,10 @@ EXAMPLES
         const out = createOutput(flags);
         out.startSpinner('Copying documents...');
         try {
+            vaultId = await resolveVaultId(vaultId);
             const client = await getClientAsync();
             const paths = (String(_opts.paths)).split(',').map(p => p.trim()).filter(Boolean);
-            const result = await client.documents.bulkCopy(vaultId, { paths, targetDirectory: _opts.target });
+            const result = await client.documents.bulkCopy(vaultId, { items: paths, destination: _opts.target });
             out.stopSpinner();
             if (flags.output === 'json') {
                 out.raw(JSON.stringify(result, null, 2) + '\n');
@@ -258,16 +296,17 @@ EXAMPLES
     });
     addGlobalFlags(docs.command('bulk-delete')
         .description('Delete multiple documents')
-        .argument('<vaultId>', 'Vault ID')
+        .argument('<vaultId>', 'Vault ID or slug')
         .requiredOption('--paths <csv>', 'Comma-separated list of document paths'))
         .action(async (vaultId, _opts) => {
         const flags = resolveFlags(_opts);
         const out = createOutput(flags);
         out.startSpinner('Deleting documents...');
         try {
+            vaultId = await resolveVaultId(vaultId);
             const client = await getClientAsync();
             const paths = (String(_opts.paths)).split(',').map(p => p.trim()).filter(Boolean);
-            const result = await client.documents.bulkDelete(vaultId, { paths });
+            const result = await client.documents.bulkDelete(vaultId, { items: paths });
             out.stopSpinner();
             if (flags.output === 'json') {
                 out.raw(JSON.stringify(result, null, 2) + '\n');
@@ -286,7 +325,7 @@ EXAMPLES
     });
     addGlobalFlags(docs.command('bulk-tag')
         .description('Add or remove tags from multiple documents')
-        .argument('<vaultId>', 'Vault ID')
+        .argument('<vaultId>', 'Vault ID or slug')
         .requiredOption('--paths <csv>', 'Comma-separated list of document paths')
         .option('--add <csv>', 'Tags to add (comma-separated)')
         .option('--remove <csv>', 'Tags to remove (comma-separated)'))
@@ -300,11 +339,12 @@ EXAMPLES
         }
         out.startSpinner('Tagging documents...');
         try {
+            vaultId = await resolveVaultId(vaultId);
             const client = await getClientAsync();
             const paths = (String(_opts.paths)).split(',').map(p => p.trim()).filter(Boolean);
             const addTags = _opts.add ? (String(_opts.add)).split(',').map(t => t.trim()).filter(Boolean) : undefined;
             const removeTags = _opts.remove ? (String(_opts.remove)).split(',').map(t => t.trim()).filter(Boolean) : undefined;
-            const result = await client.documents.bulkTag(vaultId, { paths, addTags, removeTags });
+            const result = await client.documents.bulkTag(vaultId, { items: paths, addTags, removeTags });
             out.stopSpinner();
             if (flags.output === 'json') {
                 out.raw(JSON.stringify(result, null, 2) + '\n');
@@ -323,16 +363,18 @@ EXAMPLES
     });
     addGlobalFlags(docs.command('mkdir')
         .description('Create a directory in a vault')
-        .argument('<vaultId>', 'Vault ID')
+        .argument('<vaultId>', 'Vault ID or slug')
         .argument('<path>', 'Directory path to create'))
         .action(async (vaultId, path, _opts) => {
         const flags = resolveFlags(_opts);
         const out = createOutput(flags);
         out.startSpinner('Creating directory...');
         try {
+            vaultId = await resolveVaultId(vaultId);
             const client = await getClientAsync();
-            const result = await client.documents.createDirectory(vaultId, path);
-            out.success(`Directory ${result.created ? 'created' : 'already exists'}: ${result.path}`, { path: result.path, created: result.created });
+            const normalizedPath = path.replace(/\/+$/, '');
+            const result = await client.documents.createDirectory(vaultId, normalizedPath);
+            out.success(`Directory ${result.created !== false ? 'created' : 'already exists'}: ${result.path}`, { path: result.path, created: result.created ?? true });
         }
         catch (err) {
             handleError(out, err, 'Failed to create directory');

package/dist/commands/hooks.js

@@ -2,16 +2,18 @@ import chalk from 'chalk';
 import { getClientAsync } from '../client.js';
 import { addGlobalFlags, resolveFlags } from '../utils/flags.js';
 import { createOutput, handleError } from '../utils/output.js';
+import { resolveVaultId } from '../utils/resolve-vault.js';
 export function registerHookCommands(program) {
-    const hooks = program.command('hooks').description('Manage vault event hooks (auto-tag, template, etc.)');
+    const hooks = program.command('hooks').description('Manage vault event hooks');
     addGlobalFlags(hooks.command('list')
         .description('List all hooks for a vault')
-        .argument('<vaultId>', 'Vault ID'))
+        .argument('<vaultId>', 'Vault ID or slug'))
         .action(async (vaultId, _opts) => {
         const flags = resolveFlags(_opts);
         const out = createOutput(flags);
         out.startSpinner('Fetching hooks...');
         try {
+            vaultId = await resolveVaultId(vaultId);
             const client = await getClientAsync();
             const hookList = await client.hooks.list(vaultId);
             out.stopSpinner();
@@ -45,12 +47,31 @@ export function registerHookCommands(program) {
     });
     addGlobalFlags(hooks.command('create')
         .description('Create a new hook')
-        .argument('<vaultId>', 'Vault ID')
+        .argument('<vaultId>', 'Vault ID or slug')
         .argument('<name>', 'Hook name')
-        .requiredOption('--trigger <event>', 'Trigger event (e.g., document.create)')
-        .requiredOption('--action <type>', 'Action type (e.g., auto-tag, template)')
+        .requiredOption('--trigger <event>', 'Trigger event (document.created, document.updated, document.deleted, document.moved, document.copied)')
+        .requiredOption('--action <type>', 'Action type (webhook, ai_prompt, document_operation, auto_calendar_event, auto_booking_process)')
         .requiredOption('--config <json>', 'Action configuration as JSON')
-        .option('--filter <json>', 'Trigger filter as JSON'))
+        .option('--filter <json>', 'Trigger filter as JSON')
+        .addHelpText('after', `
+VALID TRIGGER EVENTS
+  document.created        Document was created
+  document.updated        Document content was updated
+  document.deleted        Document was deleted
+  document.moved          Document was moved or renamed
+  document.copied         Document was copied
+
+VALID ACTION TYPES
+  webhook                 Send an HTTP notification to a URL
+  ai_prompt               Run an AI prompt on the document
+  document_operation      Perform a document operation (move, copy, tag)
+  auto_calendar_event     Automatically create a calendar event
+  auto_booking_process    Automatically process a booking
+
+EXAMPLES
+  lsvault hooks create <vaultId> my-hook --trigger document.created --action webhook --config '{"url":"https://example.com/hook"}'
+  lsvault hooks create <vaultId> ai-tag --trigger document.created --action ai_prompt --config '{"prompt":"Suggest tags"}'
+  lsvault hooks create <vaultId> move-docs --trigger document.created --action document_operation --config '{"operation":"move","targetPath":"inbox/"}'`))
         .action(async (vaultId, name, _opts) => {
         const flags = resolveFlags(_opts);
         const out = createOutput(flags);
@@ -74,8 +95,23 @@ export function registerHookCommands(program) {
                 return;
             }
         }
+        const VALID_TRIGGERS = ['document.created', 'document.updated', 'document.deleted', 'document.moved', 'document.copied'];
+        const VALID_ACTIONS = ['webhook', 'ai_prompt', 'document_operation', 'auto_calendar_event', 'auto_booking_process'];
+        const trigger = String(_opts.trigger);
+        const action = String(_opts.action);
+        if (!VALID_TRIGGERS.includes(trigger)) {
+            out.error(`Invalid trigger "${trigger}". Valid values: document.created, document.updated, document.deleted, document.moved, document.copied`);
+            process.exitCode = 1;
+            return;
+        }
+        if (!VALID_ACTIONS.includes(action)) {
+            out.error(`Invalid action "${action}". Valid values: webhook, ai_prompt, document_operation, auto_calendar_event, auto_booking_process`);
+            process.exitCode = 1;
+            return;
+        }
         out.startSpinner('Creating hook...');
         try {
+            vaultId = await resolveVaultId(vaultId);
             const client = await getClientAsync();
             const params = {
                 name,
@@ -99,7 +135,7 @@ export function registerHookCommands(program) {
     });
     addGlobalFlags(hooks.command('delete')
         .description('Delete a hook')
-        .argument('<vaultId>', 'Vault ID')
+        .argument('<vaultId>', 'Vault ID or slug')
         .argument('<hookId>', 'Hook ID')
         .option('-y, --yes', 'Skip confirmation prompt'))
         .action(async (vaultId, hookId, _opts) => {
@@ -111,6 +147,7 @@ export function registerHookCommands(program) {
         }
         out.startSpinner('Deleting hook...');
         try {
+            vaultId = await resolveVaultId(vaultId);
             const client = await getClientAsync();
             await client.hooks.delete(vaultId, hookId);
             out.success('Hook deleted successfully', { id: hookId, deleted: true });
@@ -121,13 +158,14 @@ export function registerHookCommands(program) {
     });
     addGlobalFlags(hooks.command('executions')
         .description('List recent executions for a hook')
-        .argument('<vaultId>', 'Vault ID')
+        .argument('<vaultId>', 'Vault ID or slug')
         .argument('<hookId>', 'Hook ID'))
         .action(async (vaultId, hookId, _opts) => {
         const flags = resolveFlags(_opts);
         const out = createOutput(flags);
         out.startSpinner('Fetching executions...');
         try {
+            vaultId = await resolveVaultId(vaultId);
             const client = await getClientAsync();
             const executions = await client.hooks.listExecutions(vaultId, hookId);
             out.stopSpinner();

package/dist/commands/keys.js

@@ -3,7 +3,9 @@ import { getClientAsync } from '../client.js';
 import { addGlobalFlags, resolveFlags } from '../utils/flags.js';
 import { createOutput, handleError } from '../utils/output.js';
 export function registerKeyCommands(program) {
-    const keys = program.command('keys').description('Create, list, update, and revoke API keys');
+    const keys = program.command('keys')
+        .description('Create, list, update, and revoke API keys (requires JWT auth — use "lsvault auth login" first)')
+        .addHelpText('after', '\nNOTE: API key management requires JWT authentication. API key auth is not sufficient.\nRun "lsvault auth login" to authenticate with email/password first.');
     addGlobalFlags(keys.command('list')
         .description('List all API keys for the current user'))
         .action(async (_opts) => {
@@ -148,10 +150,15 @@ EXAMPLES
     });
     addGlobalFlags(keys.command('revoke')
         .description('Permanently revoke and delete an API key')
-        .argument('<keyId>', 'API key ID'))
+        .argument('<keyId>', 'API key ID')
+        .option('-y, --yes', 'Skip confirmation prompt'))
         .action(async (keyId, _opts) => {
         const flags = resolveFlags(_opts);
         const out = createOutput(flags);
+        if (!_opts.yes) {
+            out.status(chalk.yellow(`Pass -y/--yes to permanently revoke key ${keyId}.`));
+            return;
+        }
         out.startSpinner('Revoking API key...');
         try {
             const client = await getClientAsync();

package/dist/commands/links.js

@@ -2,18 +2,20 @@ import chalk from 'chalk';
 import { getClientAsync } from '../client.js';
 import { addGlobalFlags, resolveFlags } from '../utils/flags.js';
 import { createOutput, handleError } from '../utils/output.js';
+import { resolveVaultId } from '../utils/resolve-vault.js';
 export function registerLinkCommands(program) {
     const links = program.command('links').description('Manage document links and backlinks');
     // lsvault links list <vaultId> <path> — forward links
     addGlobalFlags(links.command('list')
         .description('List forward links from a document')
-        .argument('<vaultId>', 'Vault ID')
+        .argument('<vaultId>', 'Vault ID or slug')
         .argument('<path>', 'Document path'))
         .action(async (vaultId, docPath, _opts) => {
         const flags = resolveFlags(_opts);
         const out = createOutput(flags);
         out.startSpinner('Fetching links...');
         try {
+            vaultId = await resolveVaultId(vaultId);
             const client = await getClientAsync();
             const linkList = await client.documents.getLinks(vaultId, docPath);
             out.stopSpinner();
@@ -41,13 +43,14 @@ export function registerLinkCommands(program) {
     // lsvault links backlinks <vaultId> <path>
     addGlobalFlags(links.command('backlinks')
         .description('List backlinks pointing to a document')
-        .argument('<vaultId>', 'Vault ID')
+        .argument('<vaultId>', 'Vault ID or slug')
         .argument('<path>', 'Document path'))
         .action(async (vaultId, docPath, _opts) => {
         const flags = resolveFlags(_opts);
         const out = createOutput(flags);
         out.startSpinner('Fetching backlinks...');
         try {
+            vaultId = await resolveVaultId(vaultId);
             const client = await getClientAsync();
             const backlinks = await client.documents.getBacklinks(vaultId, docPath);
             out.stopSpinner();
@@ -78,12 +81,13 @@ export function registerLinkCommands(program) {
     // lsvault links graph <vaultId>
     addGlobalFlags(links.command('graph')
         .description('Get the link graph for a vault')
-        .argument('<vaultId>', 'Vault ID'))
+        .argument('<vaultId>', 'Vault ID or slug'))
         .action(async (vaultId, _opts) => {
         const flags = resolveFlags(_opts);
         const out = createOutput(flags);
         out.startSpinner('Fetching link graph...');
         try {
+            vaultId = await resolveVaultId(vaultId);
             const client = await getClientAsync();
             const graph = await client.vaults.getGraph(vaultId);
             out.stopSpinner();
@@ -104,15 +108,20 @@ export function registerLinkCommands(program) {
     // lsvault links broken <vaultId>
     addGlobalFlags(links.command('broken')
         .description('List unresolved (broken) links in a vault')
-        .argument('<vaultId>', 'Vault ID'))
+        .argument('<vaultId>', 'Vault ID or slug'))
         .action(async (vaultId, _opts) => {
         const flags = resolveFlags(_opts);
         const out = createOutput(flags);
         out.startSpinner('Fetching unresolved links...');
         try {
+            vaultId = await resolveVaultId(vaultId);
             const client = await getClientAsync();
             const unresolved = await client.vaults.getUnresolvedLinks(vaultId);
             out.stopSpinner();
+            if (flags.output === 'json') {
+                process.stdout.write(JSON.stringify(unresolved) + '\n');
+                return;
+            }
             if (unresolved.length === 0) {
                 out.success('No broken links found!');
                 return;

package/dist/commands/mfa.js

@@ -3,7 +3,9 @@ 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');
+    const mfa = program.command('mfa')
+        .description('Multi-factor authentication management (requires JWT auth — use "lsvault auth login" first)')
+        .addHelpText('after', '\nNOTE: MFA management requires JWT authentication. API key auth is not sufficient.\nRun "lsvault auth login" to authenticate with email/password first.');
     mfa.command('status')
         .description('Show MFA status and configured methods')
         .action(async () => {
@@ -129,6 +131,7 @@ export function registerMfaCommands(program) {
             catch (err) {
                 spinner.fail('Failed to regenerate backup codes');
                 console.error(err instanceof Error ? err.message : String(err));
+                process.exitCode = 1;
             }
         }
         else {
@@ -149,6 +152,7 @@ export function registerMfaCommands(program) {
             catch (err) {
                 spinner.fail('Failed to fetch backup code count');
                 console.error(err instanceof Error ? err.message : String(err));
+                process.exitCode = 1;
             }
         }
     });

package/dist/commands/plugins.js

@@ -71,12 +71,13 @@ export function registerPluginCommands(program) {
     addGlobalFlags(plugins.command('uninstall')
         .description('Uninstall a plugin')
         .argument('<pluginId>', 'Plugin marketplace identifier')
-        .option('--confirm', 'Skip confirmation prompt'))
+        .option('-y, --yes', 'Skip confirmation prompt')
+        .option('--confirm', 'Alias for --yes (deprecated)'))
         .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');
+        if (!_opts.yes && !_opts.confirm) {
+            out.raw(chalk.yellow(`Pass -y/--yes or --confirm to uninstall plugin ${pluginId}.`) + '\n');
             return;
         }
         out.startSpinner('Uninstalling plugin...');