@lifestreamdynamics/vault-cli 1.1.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.d.ts

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

package/dist/commands/custom-domains.js

@@ -0,0 +1,154 @@
+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 registerCustomDomainCommands(program) {
+    const domains = program.command('custom-domains').description('Manage custom domains for published vaults');
+    addGlobalFlags(domains.command('list')
+        .description('List custom domains'))
+        .action(async (_opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Fetching custom domains...');
+        try {
+            const client = await getClientAsync();
+            const list = await client.customDomains.list();
+            out.stopSpinner();
+            out.list(list.map(d => ({ id: d.id, domain: d.domain, verified: d.verified ? 'yes' : 'no', createdAt: d.createdAt })), {
+                emptyMessage: 'No custom domains found.',
+                columns: [
+                    { key: 'id', header: 'ID' },
+                    { key: 'domain', header: 'Domain' },
+                    { key: 'verified', header: 'Verified' },
+                    { key: 'createdAt', header: 'Created' },
+                ],
+                textFn: (d) => `${chalk.cyan(String(d.domain))} — ${d.verified === 'yes' ? chalk.green('verified') : chalk.yellow('unverified')}`,
+            });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to fetch custom domains');
+        }
+    });
+    addGlobalFlags(domains.command('get')
+        .description('Get a custom domain')
+        .argument('<domainId>', 'Domain ID'))
+        .action(async (domainId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Fetching custom domain...');
+        try {
+            const client = await getClientAsync();
+            const d = await client.customDomains.get(domainId);
+            out.stopSpinner();
+            out.record({ id: d.id, domain: d.domain, verified: d.verified, verificationToken: d.verificationToken, createdAt: d.createdAt });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to fetch custom domain');
+        }
+    });
+    addGlobalFlags(domains.command('add')
+        .description('Add a custom domain')
+        .argument('<domain>', 'Domain name (e.g., docs.example.com)'))
+        .action(async (domain, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Adding custom domain...');
+        try {
+            const client = await getClientAsync();
+            const d = await client.customDomains.create({ domain });
+            out.success(`Domain added: ${d.domain}`, { id: d.id, domain: d.domain, verificationToken: d.verificationToken });
+            if (flags.output !== 'json') {
+                process.stdout.write(`\nTo verify, add this DNS TXT record:\n`);
+                process.stdout.write(`  ${chalk.cyan('_lsvault-verification.' + d.domain)} TXT ${chalk.green(d.verificationToken)}\n`);
+                process.stdout.write(`\nThen run: lsvault custom-domains verify ${d.id}\n`);
+            }
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to add custom domain');
+        }
+    });
+    addGlobalFlags(domains.command('update')
+        .description('Update a custom domain')
+        .argument('<domainId>', 'Domain ID')
+        .requiredOption('--domain <domain>', 'New domain name'))
+        .action(async (domainId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Updating custom domain...');
+        try {
+            const client = await getClientAsync();
+            const d = await client.customDomains.update(domainId, { domain: _opts.domain });
+            out.success(`Domain updated: ${d.domain}`, { id: d.id, domain: d.domain });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to update custom domain');
+        }
+    });
+    addGlobalFlags(domains.command('remove')
+        .description('Remove a custom domain')
+        .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();
+            await client.customDomains.delete(domainId);
+            out.success('Custom domain removed', { id: domainId });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to remove custom domain');
+        }
+    });
+    addGlobalFlags(domains.command('verify')
+        .description('Verify a custom domain via DNS')
+        .argument('<domainId>', 'Domain ID'))
+        .action(async (domainId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Verifying custom domain...');
+        try {
+            const client = await getClientAsync();
+            const d = await client.customDomains.verify(domainId);
+            out.success(`Domain ${d.verified ? 'verified' : 'not yet verified'}: ${d.domain}`, { id: d.id, domain: d.domain, verified: d.verified });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to verify custom domain');
+        }
+    });
+    addGlobalFlags(domains.command('check')
+        .description('Check DNS configuration for a custom domain')
+        .argument('<domainId>', 'Domain ID'))
+        .action(async (domainId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Checking DNS...');
+        try {
+            const client = await getClientAsync();
+            const result = await client.customDomains.checkDns(domainId);
+            out.stopSpinner();
+            out.record({
+                domain: result.domain,
+                resolved: result.resolved,
+                expectedValue: result.expectedValue,
+                actualValue: result.actualValue ?? 'N/A',
+            });
+            if (flags.output !== 'json') {
+                if (result.resolved) {
+                    process.stdout.write(chalk.green('\n✓ DNS configured correctly\n'));
+                }
+                else {
+                    process.stdout.write(chalk.yellow(`\n⚠ DNS not yet propagated. Expected: ${result.expectedValue}\n`));
+                }
+            }
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to check DNS');
+        }
+    });
+}

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 });
@@ -191,4 +198,144 @@ EXAMPLES
             handleError(out, err, 'Failed to move document');
         }
     });
+    addGlobalFlags(docs.command('bulk-move')
+        .description('Move multiple documents to a target directory')
+        .argument('<vaultId>', 'Vault ID')
+        .requiredOption('--paths <csv>', 'Comma-separated list of document paths')
+        .requiredOption('--target <dir>', 'Target directory'))
+        .action(async (vaultId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Moving documents...');
+        try {
+            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 });
+            out.stopSpinner();
+            if (flags.output === 'json') {
+                out.raw(JSON.stringify(result, null, 2) + '\n');
+            }
+            else {
+                process.stdout.write(`Succeeded: ${result.succeeded.length}, Failed: ${result.failed.length}\n`);
+                if (result.failed.length > 0) {
+                    for (const f of result.failed)
+                        process.stdout.write(`  ${chalk.red('✗')} ${f.path}: ${f.error}\n`);
+                }
+            }
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to bulk move documents');
+        }
+    });
+    addGlobalFlags(docs.command('bulk-copy')
+        .description('Copy multiple documents to a target directory')
+        .argument('<vaultId>', 'Vault ID')
+        .requiredOption('--paths <csv>', 'Comma-separated list of document paths')
+        .requiredOption('--target <dir>', 'Target directory'))
+        .action(async (vaultId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Copying documents...');
+        try {
+            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 });
+            out.stopSpinner();
+            if (flags.output === 'json') {
+                out.raw(JSON.stringify(result, null, 2) + '\n');
+            }
+            else {
+                process.stdout.write(`Succeeded: ${result.succeeded.length}, Failed: ${result.failed.length}\n`);
+                if (result.failed.length > 0) {
+                    for (const f of result.failed)
+                        process.stdout.write(`  ${chalk.red('✗')} ${f.path}: ${f.error}\n`);
+                }
+            }
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to bulk copy documents');
+        }
+    });
+    addGlobalFlags(docs.command('bulk-delete')
+        .description('Delete multiple documents')
+        .argument('<vaultId>', 'Vault ID')
+        .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 {
+            const client = await getClientAsync();
+            const paths = (String(_opts.paths)).split(',').map(p => p.trim()).filter(Boolean);
+            const result = await client.documents.bulkDelete(vaultId, { paths });
+            out.stopSpinner();
+            if (flags.output === 'json') {
+                out.raw(JSON.stringify(result, null, 2) + '\n');
+            }
+            else {
+                process.stdout.write(`Succeeded: ${result.succeeded.length}, Failed: ${result.failed.length}\n`);
+                if (result.failed.length > 0) {
+                    for (const f of result.failed)
+                        process.stdout.write(`  ${chalk.red('✗')} ${f.path}: ${f.error}\n`);
+                }
+            }
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to bulk delete documents');
+        }
+    });
+    addGlobalFlags(docs.command('bulk-tag')
+        .description('Add or remove tags from multiple documents')
+        .argument('<vaultId>', 'Vault ID')
+        .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)'))
+        .action(async (vaultId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        if (!_opts.add && !_opts.remove) {
+            out.error('At least one of --add or --remove must be specified');
+            process.exitCode = 1;
+            return;
+        }
+        out.startSpinner('Tagging documents...');
+        try {
+            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 });
+            out.stopSpinner();
+            if (flags.output === 'json') {
+                out.raw(JSON.stringify(result, null, 2) + '\n');
+            }
+            else {
+                process.stdout.write(`Succeeded: ${result.succeeded.length}, Failed: ${result.failed.length}\n`);
+                if (result.failed.length > 0) {
+                    for (const f of result.failed)
+                        process.stdout.write(`  ${chalk.red('✗')} ${f.path}: ${f.error}\n`);
+                }
+            }
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to bulk tag documents');
+        }
+    });
+    addGlobalFlags(docs.command('mkdir')
+        .description('Create a directory in a vault')
+        .argument('<vaultId>', 'Vault ID')
+        .argument('<path>', 'Directory path to create'))
+        .action(async (vaultId, path, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Creating directory...');
+        try {
+            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 });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to create directory');
+        }
+    });
 }

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);
-        });
-    });
-}