@lifestreamdynamics/vault-cli 1.0.0

package/dist/commands/auth.js

@@ -0,0 +1,256 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { LifestreamVaultClient } from '@lifestreamdynamics/vault-sdk';
+import { loadConfigAsync, getCredentialManager } from '../config.js';
+import { getClient } from '../client.js';
+import { migrateCredentials, hasPlaintextCredentials, checkAndPromptMigration } from '../lib/migration.js';
+export function registerAuthCommands(program) {
+    const auth = program.command('auth').description('Authentication and credential management');
+    auth.command('login')
+        .description('Authenticate with an API key or email/password credentials')
+        .option('--api-key <key>', 'API key (lsv_k_... prefix)')
+        .option('--email <email>', 'Email address for password login')
+        .option('--password <password>', 'Password (prompts interactively if omitted)')
+        .option('--api-url <url>', 'API server URL (default: http://localhost:4660)')
+        .addHelpText('after', `
+EXAMPLES
+  lsvault auth login --api-key lsv_k_abc123
+  lsvault auth login --email user@example.com
+  lsvault auth login --email user@example.com --api-url https://api.example.com`)
+        .action(async (opts) => {
+        const cm = getCredentialManager();
+        // Set API URL first if provided
+        if (opts.apiUrl) {
+            try {
+                await cm.saveCredentials({ apiUrl: opts.apiUrl });
+                console.log(chalk.green(`API URL set to ${opts.apiUrl}`));
+            }
+            catch {
+                const { saveConfig } = await import('../config.js');
+                saveConfig({ apiUrl: opts.apiUrl });
+                console.log(chalk.green(`API URL set to ${opts.apiUrl}`));
+            }
+        }
+        // Password-based login
+        if (opts.email) {
+            const password = opts.password ?? await promptPassword();
+            if (!password) {
+                console.error(chalk.red('Password is required for email login.'));
+                return;
+            }
+            const config = await loadConfigAsync();
+            const apiUrl = opts.apiUrl ?? config.apiUrl;
+            const spinner = ora('Authenticating...').start();
+            try {
+                const { tokens, refreshToken } = await LifestreamVaultClient.login(apiUrl, opts.email, password);
+                // Save tokens to secure storage
+                await cm.saveCredentials({
+                    accessToken: tokens.accessToken,
+                    refreshToken: refreshToken ?? undefined,
+                });
+                spinner.succeed(`Logged in as ${chalk.cyan(tokens.user.email)}`);
+                console.log(`  Name: ${tokens.user.name || chalk.dim('not set')}`);
+                console.log(`  Role: ${tokens.user.role}`);
+                if (!refreshToken) {
+                    console.log(chalk.yellow('  Note: No refresh token received. Session will expire.'));
+                }
+            }
+            catch (err) {
+                spinner.fail('Login failed');
+                console.error(err instanceof Error ? err.message : String(err));
+            }
+            return;
+        }
+        // API key login
+        if (opts.apiKey) {
+            const spinner = ora('Saving API key to secure storage...').start();
+            try {
+                await cm.saveCredentials({ apiKey: opts.apiKey });
+                const method = await cm.getStorageMethod();
+                spinner.succeed(`API key saved to ${formatMethod(method)}.`);
+            }
+            catch (err) {
+                spinner.fail('Failed to save API key to secure storage');
+                console.error(err instanceof Error ? err.message : String(err));
+            }
+            return;
+        }
+        if (!opts.apiUrl) {
+            console.log('Usage: lsvault auth login --api-key <key> [--api-url <url>]');
+            console.log('   or: lsvault auth login --email <email> [--password <pass>] [--api-url <url>]');
+        }
+    });
+    auth.command('refresh')
+        .description('Refresh the JWT access token using the stored refresh token')
+        .action(async () => {
+        const cm = getCredentialManager();
+        const config = await loadConfigAsync();
+        if (!config.refreshToken) {
+            console.error(chalk.red('No refresh token stored. Login first with --email.'));
+            return;
+        }
+        const spinner = ora('Refreshing access token...').start();
+        try {
+            // Create a client with the current tokens to trigger refresh
+            const client = new LifestreamVaultClient({
+                baseUrl: config.apiUrl,
+                accessToken: config.accessToken || 'expired',
+                refreshToken: config.refreshToken,
+                refreshBufferMs: Number.MAX_SAFE_INTEGER, // Force immediate refresh
+                onTokenRefresh: async (tokens) => {
+                    await cm.saveCredentials({
+                        accessToken: tokens.accessToken,
+                    });
+                },
+            });
+            // Trigger the refresh by making a request
+            const user = await client.user.me();
+            spinner.succeed(`Token refreshed. Logged in as ${chalk.cyan(user.email)}`);
+        }
+        catch (err) {
+            spinner.fail('Token refresh failed');
+            console.error(err instanceof Error ? err.message : String(err));
+            console.log(chalk.dim('You may need to log in again: lsvault auth login --email <email>'));
+        }
+    });
+    auth.command('logout')
+        .description('Clear all stored credentials from keychain and config')
+        .action(async () => {
+        const cm = getCredentialManager();
+        const spinner = ora('Clearing credentials...').start();
+        try {
+            await cm.clearCredentials();
+            spinner.succeed('All credentials cleared.');
+        }
+        catch (err) {
+            spinner.fail('Failed to clear credentials');
+            console.error(err instanceof Error ? err.message : String(err));
+        }
+    });
+    auth.command('status')
+        .description('Show credential storage method, auth type, and connection info')
+        .action(async () => {
+        const cm = getCredentialManager();
+        const method = await cm.getStorageMethod();
+        const config = await loadConfigAsync();
+        console.log(chalk.bold('Credential Storage Status'));
+        console.log(`  Storage method: ${formatMethod(method)}`);
+        console.log(`  API URL:        ${config.apiUrl}`);
+        console.log(`  API Key:        ${config.apiKey ? config.apiKey.slice(0, 12) + '...' : chalk.yellow('not set')}`);
+        console.log(`  JWT Auth:       ${config.accessToken ? chalk.green('active') : chalk.dim('not set')}`);
+        console.log(`  Refresh Token:  ${config.refreshToken ? chalk.green('stored') : chalk.dim('not set')}`);
+        if (hasPlaintextCredentials()) {
+            console.log('');
+            console.log(chalk.yellow('  Warning: Plaintext credentials found in ~/.lsvault/config.json'));
+            console.log(chalk.yellow('  Run `lsvault auth migrate` to migrate to secure storage.'));
+        }
+    });
+    auth.command('migrate')
+        .description('Migrate plaintext credentials from config.json to secure storage')
+        .action(async () => {
+        if (!hasPlaintextCredentials()) {
+            console.log('No plaintext credentials found. Nothing to migrate.');
+            return;
+        }
+        const cm = getCredentialManager();
+        const spinner = ora('Migrating credentials to secure storage...').start();
+        const result = await migrateCredentials(cm);
+        if (result.migrated) {
+            spinner.succeed(`API key migrated to ${formatMethod(result.method)}.`);
+        }
+        else if (result.error) {
+            spinner.fail(`Migration failed: ${result.error}`);
+        }
+        else {
+            spinner.info('Migration skipped.');
+        }
+    });
+    auth.command('whoami')
+        .description('Show the currently authenticated user, plan, and API URL')
+        .action(async () => {
+        const config = await loadConfigAsync();
+        console.log(`API URL: ${config.apiUrl}`);
+        console.log(`API Key: ${config.apiKey ? config.apiKey.slice(0, 12) + '...' : chalk.yellow('not set')}`);
+        if (config.accessToken) {
+            console.log(`Auth:    ${chalk.green('JWT (email/password)')}`);
+        }
+        // Warn about plaintext credentials
+        await checkAndPromptMigration(getCredentialManager());
+        if (config.apiKey || config.accessToken) {
+            const spinner = ora('Fetching user info...').start();
+            try {
+                const client = getClient();
+                const user = await client.user.me();
+                spinner.stop();
+                console.log(`User:    ${chalk.cyan(user.email)}`);
+                console.log(`Name:    ${user.name || chalk.dim('not set')}`);
+                console.log(`Role:    ${user.role}`);
+                console.log(`Plan:    ${chalk.green(user.subscriptionTier)}`);
+            }
+            catch (err) {
+                spinner.fail('Could not fetch user info');
+                console.error(err instanceof Error ? err.message : err);
+            }
+        }
+    });
+}
+/**
+ * Prompt for a password from stdin (non-echoing).
+ * Returns the password or null if stdin is not a TTY.
+ */
+async function promptPassword() {
+    // In non-interactive mode, cannot prompt
+    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,
+        });
+        // Disable echoing
+        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();
+    });
+}
+function formatMethod(method) {
+    switch (method) {
+        case 'keychain': return chalk.green('OS Keychain');
+        case 'encrypted-config': return chalk.cyan('Encrypted Config (~/.lsvault/credentials.enc)');
+        case 'env': return chalk.blue('Environment Variable');
+        case 'plaintext-config': return chalk.yellow('Plaintext Config (deprecated)');
+        default: return chalk.dim(method);
+    }
+}

package/dist/commands/config.d.ts

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

package/dist/commands/config.js

@@ -0,0 +1,130 @@
+import chalk from 'chalk';
+import { resolveProfileName, getActiveProfile, setActiveProfile, loadProfile, setProfileValue, getProfileValue, listProfiles, deleteProfile, } from '../lib/profiles.js';
+export function registerConfigCommands(program) {
+    const config = program
+        .command('config')
+        .description('Manage CLI configuration profiles')
+        .addHelpText('after', `
+EXAMPLES
+  lsvault config set apiUrl https://api.example.com --profile prod
+  lsvault config set apiKey lsv_k_abc123 --profile prod
+  lsvault config get apiUrl --profile prod
+  lsvault config list --profile prod
+  lsvault config use prod
+  lsvault config profiles`);
+    config
+        .command('set')
+        .description('Set a configuration value in a profile')
+        .argument('<key>', 'Configuration key (e.g., apiUrl, apiKey)')
+        .argument('<value>', 'Configuration value')
+        .option('-p, --profile <name>', 'Profile name (default: active profile)')
+        .addHelpText('after', `
+EXAMPLES
+  lsvault config set apiUrl https://api.lifestream.com --profile prod
+  lsvault config set apiKey lsv_k_prod... --profile prod
+  lsvault config set apiUrl http://localhost:4660 --profile dev`)
+        .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)}`));
+    });
+    config
+        .command('get')
+        .description('Get a configuration value from a profile')
+        .argument('<key>', 'Configuration key to read')
+        .option('-p, --profile <name>', 'Profile name (default: active profile)')
+        .addHelpText('after', `
+EXAMPLES
+  lsvault config get apiUrl
+  lsvault config get apiKey --profile prod`)
+        .action((key, opts) => {
+        const profile = resolveProfileName(opts.profile);
+        const value = getProfileValue(profile, key);
+        if (value !== undefined) {
+            console.log(value);
+        }
+        else {
+            console.log(chalk.yellow(`Key "${key}" not set in profile "${profile}"`));
+        }
+    });
+    config
+        .command('list')
+        .description('List all configuration values in a profile')
+        .option('-p, --profile <name>', 'Profile name (default: active profile)')
+        .addHelpText('after', `
+EXAMPLES
+  lsvault config list
+  lsvault config list --profile prod`)
+        .action((opts) => {
+        const profile = resolveProfileName(opts.profile);
+        const profileConfig = loadProfile(profile);
+        const keys = Object.keys(profileConfig);
+        if (keys.length === 0) {
+            console.log(chalk.yellow(`Profile "${profile}" has no configuration values.`));
+            return;
+        }
+        console.log(chalk.bold(`Profile: ${profile}\n`));
+        for (const key of keys) {
+            const value = profileConfig[key];
+            // Mask API keys for display
+            const display = key.toLowerCase().includes('key') && value
+                ? value.slice(0, 12) + '...'
+                : value;
+            console.log(`  ${chalk.cyan(key)}: ${display}`);
+        }
+    });
+    config
+        .command('use')
+        .description('Set the default active profile')
+        .argument('<name>', 'Profile name to activate')
+        .addHelpText('after', `
+EXAMPLES
+  lsvault config use prod
+  lsvault config use dev`)
+        .action((name) => {
+        setActiveProfile(name);
+        console.log(chalk.green(`Active profile set to ${chalk.bold(name)}`));
+    });
+    config
+        .command('profiles')
+        .description('List all available profiles')
+        .addHelpText('after', `
+EXAMPLES
+  lsvault config profiles`)
+        .action(() => {
+        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>'));
+            return;
+        }
+        console.log(chalk.bold('Available profiles:\n'));
+        for (const name of profiles) {
+            const marker = name === active ? chalk.green(' (active)') : '';
+            console.log(`  ${chalk.cyan(name)}${marker}`);
+        }
+    });
+    config
+        .command('delete')
+        .description('Delete a configuration profile')
+        .argument('<name>', 'Profile name to delete')
+        .addHelpText('after', `
+EXAMPLES
+  lsvault config delete staging`)
+        .action((name) => {
+        if (deleteProfile(name)) {
+            console.log(chalk.green(`Profile "${name}" deleted.`));
+        }
+        else {
+            console.log(chalk.yellow(`Profile "${name}" not found.`));
+        }
+    });
+    config
+        .command('current')
+        .description('Show the active profile name')
+        .action(() => {
+        const active = getActiveProfile();
+        console.log(active);
+    });
+}

package/dist/commands/connectors.d.ts

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

package/dist/commands/connectors.js

@@ -0,0 +1,224 @@
+import chalk from 'chalk';
+import { getClient } from '../client.js';
+import { addGlobalFlags, resolveFlags } from '../utils/flags.js';
+import { createOutput, handleError } from '../utils/output.js';
+export function registerConnectorCommands(program) {
+    const connectors = program.command('connectors').description('Manage external service connectors (e.g., Google Drive)');
+    addGlobalFlags(connectors.command('list')
+        .description('List connectors')
+        .option('--vault <vaultId>', 'Filter by vault ID'))
+        .action(async (_opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Fetching connectors...');
+        try {
+            const client = getClient();
+            const connectorList = await client.connectors.list(_opts.vault);
+            out.stopSpinner();
+            out.list(connectorList.map(c => ({
+                name: c.name,
+                id: c.id,
+                provider: c.provider,
+                status: c.status,
+                syncDirection: c.syncDirection,
+            })), {
+                emptyMessage: 'No connectors found.',
+                columns: [
+                    { key: 'name', header: 'Name' },
+                    { key: 'provider', header: 'Provider' },
+                    { key: 'status', header: 'Status' },
+                    { key: 'syncDirection', header: 'Direction' },
+                ],
+                textFn: (c) => {
+                    const status = String(c.status) === 'active' ? chalk.green(String(c.status)) :
+                        String(c.status) === 'error' ? chalk.red(String(c.status)) : chalk.dim(String(c.status));
+                    return `${chalk.cyan(String(c.name))} ${chalk.dim(`(${String(c.id)})`)} -- ${String(c.provider)} ${status} [${String(c.syncDirection)}]`;
+                },
+            });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to fetch connectors');
+        }
+    });
+    addGlobalFlags(connectors.command('get')
+        .description('Get connector details')
+        .argument('<connectorId>', 'Connector ID'))
+        .action(async (connectorId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Fetching connector...');
+        try {
+            const client = getClient();
+            const c = await client.connectors.get(connectorId);
+            out.stopSpinner();
+            out.record({
+                name: c.name,
+                id: c.id,
+                provider: c.provider,
+                vaultId: c.vaultId,
+                syncDirection: c.syncDirection,
+                syncPath: c.syncPath,
+                status: c.status,
+                isActive: c.isActive,
+                lastSyncAt: c.lastSyncAt,
+                createdAt: c.createdAt,
+                updatedAt: c.updatedAt,
+            });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to fetch connector');
+        }
+    });
+    addGlobalFlags(connectors.command('create')
+        .description('Create a connector')
+        .argument('<provider>', 'Provider (e.g., google_drive)')
+        .argument('<name>', 'Connector name')
+        .requiredOption('--vault <vaultId>', 'Vault ID')
+        .requiredOption('-d, --direction <direction>', 'Sync direction (pull, push, bidirectional)')
+        .option('-p, --sync-path <path>', 'Sync path prefix'))
+        .action(async (provider, name, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Creating connector...');
+        try {
+            const client = getClient();
+            const connector = await client.connectors.create({
+                provider: provider,
+                name,
+                vaultId: String(_opts.vault),
+                syncDirection: String(_opts.direction),
+                syncPath: _opts.syncPath,
+            });
+            out.success(`Connector created: ${chalk.cyan(connector.name)} (${connector.id})`, {
+                id: connector.id,
+                name: connector.name,
+                provider: connector.provider,
+            });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to create connector');
+        }
+    });
+    addGlobalFlags(connectors.command('update')
+        .description('Update a connector')
+        .argument('<connectorId>', 'Connector ID')
+        .option('-n, --name <name>', 'New name')
+        .option('-d, --direction <direction>', 'New sync direction'))
+        .action(async (connectorId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Updating connector...');
+        try {
+            const client = getClient();
+            const params = {};
+            if (_opts.name)
+                params.name = _opts.name;
+            if (_opts.direction)
+                params.syncDirection = _opts.direction;
+            const connector = await client.connectors.update(connectorId, params);
+            out.success(`Connector updated: ${chalk.cyan(connector.name)}`, {
+                id: connector.id,
+                name: connector.name,
+            });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to update connector');
+        }
+    });
+    addGlobalFlags(connectors.command('delete')
+        .description('Delete a connector')
+        .argument('<connectorId>', 'Connector ID'))
+        .action(async (connectorId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Deleting connector...');
+        try {
+            const client = getClient();
+            await client.connectors.delete(connectorId);
+            out.success('Connector deleted.', { id: connectorId, deleted: true });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to delete connector');
+        }
+    });
+    addGlobalFlags(connectors.command('test')
+        .description('Test a connector connection')
+        .argument('<connectorId>', 'Connector ID'))
+        .action(async (connectorId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Testing connection...');
+        try {
+            const client = getClient();
+            const result = await client.connectors.test(connectorId);
+            if (result.success) {
+                out.success('Connection test passed.', { success: true });
+            }
+            else {
+                out.failSpinner(`Connection test failed: ${result.error || 'Unknown error'}`);
+                if (flags.output === 'json') {
+                    out.record({ success: false, error: result.error });
+                }
+                process.exitCode = 1;
+            }
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to test connection');
+        }
+    });
+    addGlobalFlags(connectors.command('sync')
+        .description('Trigger a sync for a connector')
+        .argument('<connectorId>', 'Connector ID'))
+        .action(async (connectorId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Triggering sync...');
+        try {
+            const client = getClient();
+            const result = await client.connectors.sync(connectorId);
+            out.success(result.message, { message: result.message });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to trigger sync');
+        }
+    });
+    addGlobalFlags(connectors.command('logs')
+        .description('View sync logs for a connector')
+        .argument('<connectorId>', 'Connector ID'))
+        .action(async (connectorId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Fetching sync logs...');
+        try {
+            const client = getClient();
+            const logs = await client.connectors.logs(connectorId);
+            out.stopSpinner();
+            out.list(logs.map(log => ({
+                status: log.status,
+                createdAt: log.createdAt,
+                filesAdded: log.filesAdded,
+                filesUpdated: log.filesUpdated,
+                filesDeleted: log.filesDeleted,
+                durationMs: log.durationMs,
+            })), {
+                emptyMessage: 'No sync logs found.',
+                columns: [
+                    { key: 'status', header: 'Status' },
+                    { key: 'createdAt', header: 'Time' },
+                    { key: 'filesAdded', header: 'Added' },
+                    { key: 'filesUpdated', header: 'Updated' },
+                    { key: 'filesDeleted', header: 'Deleted' },
+                    { key: 'durationMs', header: 'Duration (ms)' },
+                ],
+                textFn: (log) => {
+                    const status = String(log.status) === 'success' ? chalk.green(String(log.status)) : chalk.red(String(log.status));
+                    const duration = log.durationMs ? `${String(log.durationMs)}ms` : 'n/a';
+                    return `${status} ${chalk.dim(String(log.createdAt))} -- +${String(log.filesAdded)} ~${String(log.filesUpdated)} -${String(log.filesDeleted)} (${duration})`;
+                },
+            });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to fetch sync logs');
+        }
+    });
+}

package/dist/commands/docs.d.ts

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