@lifestreamdynamics/vault-cli 1.0.0

package/dist/commands/teams.js

@@ -0,0 +1,322 @@
+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 registerTeamCommands(program) {
+    const teams = program.command('teams').description('Manage teams, members, invitations, and shared vaults');
+    // ── Team CRUD ──────────────────────────────────────────────────────
+    addGlobalFlags(teams.command('list')
+        .description('List all teams you belong to'))
+        .action(async (_opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Fetching teams...');
+        try {
+            const client = getClient();
+            const teamList = await client.teams.list();
+            out.stopSpinner();
+            out.list(teamList.map(t => ({ name: t.name, id: t.id, description: t.description || 'No description' })), {
+                emptyMessage: 'No teams found.',
+                columns: [
+                    { key: 'name', header: 'Name' },
+                    { key: 'id', header: 'ID' },
+                    { key: 'description', header: 'Description' },
+                ],
+                textFn: (t) => `${chalk.cyan(String(t.name))} ${chalk.dim(`(${String(t.id)})`)} -- ${String(t.description)}`,
+            });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to fetch teams');
+        }
+    });
+    addGlobalFlags(teams.command('get')
+        .description('Show detailed information about a team')
+        .argument('<teamId>', 'Team ID'))
+        .action(async (teamId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Fetching team...');
+        try {
+            const client = getClient();
+            const team = await client.teams.get(teamId);
+            out.stopSpinner();
+            out.record({
+                name: team.name,
+                id: team.id,
+                ownerId: team.ownerId,
+                description: team.description,
+                createdAt: team.createdAt,
+                updatedAt: team.updatedAt,
+            });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to fetch team');
+        }
+    });
+    addGlobalFlags(teams.command('create')
+        .description('Create a new team workspace')
+        .argument('<name>', 'Team name')
+        .option('-d, --description <desc>', 'Team description')
+        .addHelpText('after', `
+EXAMPLES
+  lsvault teams create "Engineering" --description "Dev team workspace"
+  lsvault teams create "Marketing"`))
+        .action(async (name, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Creating team...');
+        try {
+            const client = getClient();
+            const team = await client.teams.create({ name, description: _opts.description });
+            out.success(`Team created: ${chalk.cyan(team.name)} (${team.id})`, { id: team.id, name: team.name });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to create team');
+        }
+    });
+    addGlobalFlags(teams.command('update')
+        .description('Update a team')
+        .argument('<teamId>', 'Team ID')
+        .option('-n, --name <name>', 'New team name')
+        .option('-d, --description <desc>', 'New description'))
+        .action(async (teamId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Updating team...');
+        try {
+            const client = getClient();
+            const team = await client.teams.update(teamId, {
+                name: _opts.name,
+                description: _opts.description,
+            });
+            out.success(`Team updated: ${chalk.cyan(team.name)}`, { id: team.id, name: team.name });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to update team');
+        }
+    });
+    addGlobalFlags(teams.command('delete')
+        .description('Permanently delete a team and all its data')
+        .argument('<teamId>', 'Team ID'))
+        .action(async (teamId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Deleting team...');
+        try {
+            const client = getClient();
+            await client.teams.delete(teamId);
+            out.success('Team deleted.', { id: teamId, deleted: true });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to delete team');
+        }
+    });
+    // ── Members ────────────────────────────────────────────────────────
+    const members = teams.command('members').description('List, update roles, and remove team members');
+    addGlobalFlags(members.command('list')
+        .description('List team members')
+        .argument('<teamId>', 'Team ID'))
+        .action(async (teamId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Fetching members...');
+        try {
+            const client = getClient();
+            const memberList = await client.teams.listMembers(teamId);
+            out.stopSpinner();
+            out.list(memberList.map(m => ({
+                name: m.user.name || m.user.email,
+                userId: m.userId,
+                role: m.role,
+                email: m.user.email,
+            })), {
+                emptyMessage: 'No members found.',
+                columns: [
+                    { key: 'name', header: 'Name' },
+                    { key: 'email', header: 'Email' },
+                    { key: 'role', header: 'Role' },
+                ],
+                textFn: (m) => `${chalk.cyan(String(m.name))} ${chalk.dim(`(${String(m.userId)})`)} -- ${chalk.magenta(String(m.role))}`,
+            });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to fetch members');
+        }
+    });
+    addGlobalFlags(members.command('update')
+        .description('Update a member role')
+        .argument('<teamId>', 'Team ID')
+        .argument('<userId>', 'User ID')
+        .requiredOption('-r, --role <role>', 'New role (admin or member)'))
+        .action(async (teamId, userId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        const role = String(_opts.role);
+        out.startSpinner('Updating member role...');
+        try {
+            const client = getClient();
+            const member = await client.teams.updateMemberRole(teamId, userId, role);
+            out.success(`Role updated to ${chalk.magenta(member.role)} for ${member.user.email}`, {
+                userId,
+                role: member.role,
+                email: member.user.email,
+            });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to update member role');
+        }
+    });
+    addGlobalFlags(members.command('remove')
+        .description('Remove a member from the team')
+        .argument('<teamId>', 'Team ID')
+        .argument('<userId>', 'User ID'))
+        .action(async (teamId, userId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Removing member...');
+        try {
+            const client = getClient();
+            await client.teams.removeMember(teamId, userId);
+            out.success('Member removed.', { teamId, userId, removed: true });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to remove member');
+        }
+    });
+    addGlobalFlags(teams.command('leave')
+        .description('Leave a team')
+        .argument('<teamId>', 'Team ID'))
+        .action(async (teamId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Leaving team...');
+        try {
+            const client = getClient();
+            await client.teams.leave(teamId);
+            out.success('Left the team.', { teamId, left: true });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to leave team');
+        }
+    });
+    // ── Invitations ────────────────────────────────────────────────────
+    const invitations = teams.command('invitations').description('Send, list, and revoke team invitations');
+    addGlobalFlags(invitations.command('list')
+        .description('List pending invitations')
+        .argument('<teamId>', 'Team ID'))
+        .action(async (teamId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Fetching invitations...');
+        try {
+            const client = getClient();
+            const invitationList = await client.teams.listInvitations(teamId);
+            out.stopSpinner();
+            out.list(invitationList.map(inv => ({
+                email: inv.email,
+                id: inv.id,
+                role: inv.role,
+                expiresAt: inv.expiresAt,
+            })), {
+                emptyMessage: 'No pending invitations.',
+                columns: [
+                    { key: 'email', header: 'Email' },
+                    { key: 'role', header: 'Role' },
+                    { key: 'expiresAt', header: 'Expires' },
+                ],
+                textFn: (inv) => `${chalk.cyan(String(inv.email))} ${chalk.dim(`(${String(inv.id)})`)} -- ${chalk.magenta(String(inv.role))} -- expires ${String(inv.expiresAt)}`,
+            });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to fetch invitations');
+        }
+    });
+    addGlobalFlags(invitations.command('create')
+        .description('Invite a user to the team')
+        .argument('<teamId>', 'Team ID')
+        .argument('<email>', 'Email address')
+        .requiredOption('-r, --role <role>', 'Role (admin or member)'))
+        .action(async (teamId, email, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        const role = String(_opts.role);
+        out.startSpinner('Sending invitation...');
+        try {
+            const client = getClient();
+            const invitation = await client.teams.inviteMember(teamId, email, role);
+            out.success(`Invited ${chalk.cyan(invitation.email)} as ${chalk.magenta(invitation.role)}`, {
+                id: invitation.id,
+                email: invitation.email,
+                role: invitation.role,
+            });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to send invitation');
+        }
+    });
+    addGlobalFlags(invitations.command('revoke')
+        .description('Revoke a pending invitation')
+        .argument('<teamId>', 'Team ID')
+        .argument('<invitationId>', 'Invitation ID'))
+        .action(async (teamId, invitationId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Revoking invitation...');
+        try {
+            const client = getClient();
+            await client.teams.revokeInvitation(teamId, invitationId);
+            out.success('Invitation revoked.', { id: invitationId, revoked: true });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to revoke invitation');
+        }
+    });
+    // ── Team Vaults ────────────────────────────────────────────────────
+    const vaults = teams.command('vaults').description('Manage shared vaults within a team');
+    addGlobalFlags(vaults.command('list')
+        .description('List team vaults')
+        .argument('<teamId>', 'Team ID'))
+        .action(async (teamId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Fetching team vaults...');
+        try {
+            const client = getClient();
+            const vaultList = await client.teams.listVaults(teamId);
+            out.stopSpinner();
+            out.list(vaultList.map(v => ({ name: String(v.name), slug: String(v.slug), description: String(v.description) || 'No description' })), {
+                emptyMessage: 'No team vaults found.',
+                columns: [
+                    { key: 'name', header: 'Name' },
+                    { key: 'slug', header: 'Slug' },
+                    { key: 'description', header: 'Description' },
+                ],
+                textFn: (v) => `${chalk.cyan(String(v.name))} ${chalk.dim(`(${String(v.slug)})`)} -- ${String(v.description)}`,
+            });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to fetch team vaults');
+        }
+    });
+    addGlobalFlags(vaults.command('create')
+        .description('Create a team vault')
+        .argument('<teamId>', 'Team ID')
+        .argument('<name>', 'Vault name')
+        .option('-d, --description <desc>', 'Description'))
+        .action(async (teamId, name, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Creating team vault...');
+        try {
+            const client = getClient();
+            const vault = await client.teams.createVault(teamId, { name, description: _opts.description });
+            out.success(`Team vault created: ${chalk.cyan(String(vault.name))}`, {
+                name: String(vault.name),
+                slug: String(vault.slug),
+            });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to create team vault');
+        }
+    });
+}

package/dist/commands/user.d.ts

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

package/dist/commands/user.js

@@ -0,0 +1,48 @@
+import chalk from 'chalk';
+import { getClient } from '../client.js';
+import { addGlobalFlags, resolveFlags } from '../utils/flags.js';
+import { createOutput, handleError } from '../utils/output.js';
+import { formatBytes } from '../utils/format.js';
+export function registerUserCommands(program) {
+    const user = program.command('user').description('View account details and storage usage');
+    addGlobalFlags(user.command('storage')
+        .description('Show storage usage breakdown by vault and plan limits'))
+        .action(async (_opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Fetching storage usage...');
+        try {
+            const client = getClient();
+            const storage = await client.user.getStorage();
+            out.stopSpinner();
+            if (flags.output === 'json') {
+                out.record({
+                    tier: storage.tier,
+                    totalBytes: storage.totalBytes,
+                    limitBytes: storage.limitBytes,
+                    vaultCount: storage.vaultCount,
+                    vaultLimit: storage.vaultLimit,
+                    vaults: storage.vaults,
+                });
+            }
+            else {
+                const pct = storage.limitBytes > 0
+                    ? ((storage.totalBytes / storage.limitBytes) * 100).toFixed(1)
+                    : '0.0';
+                process.stdout.write(`Plan:     ${chalk.green(storage.tier)}\n`);
+                process.stdout.write(`Storage:  ${formatBytes(storage.totalBytes)} / ${formatBytes(storage.limitBytes)} (${pct}%)\n`);
+                process.stdout.write(`Vaults:   ${storage.vaultCount} / ${storage.vaultLimit}\n`);
+                if (storage.vaults.length > 0) {
+                    process.stdout.write('\n');
+                    process.stdout.write(chalk.dim('Per-vault breakdown:') + '\n');
+                    for (const v of storage.vaults) {
+                        process.stdout.write(`  ${chalk.cyan(v.name)}: ${formatBytes(v.bytes)} (${v.documentCount} docs)\n`);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to fetch storage usage');
+        }
+    });
+}

package/dist/commands/vaults.d.ts

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

package/dist/commands/vaults.js

@@ -0,0 +1,157 @@
+import chalk from 'chalk';
+import { getClient } from '../client.js';
+import { addGlobalFlags, resolveFlags } from '../utils/flags.js';
+import { createOutput, handleError } from '../utils/output.js';
+import { generateVaultKey } from '@lifestreamdynamics/vault-sdk';
+import { createCredentialManager } from '../lib/credential-manager.js';
+export function registerVaultCommands(program) {
+    const vaults = program.command('vaults').description('Create, list, and inspect document vaults');
+    addGlobalFlags(vaults.command('list')
+        .description('List all vaults accessible to the current user'))
+        .action(async (_opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Fetching vaults...');
+        try {
+            const client = getClient();
+            const vaultList = await client.vaults.list();
+            out.stopSpinner();
+            out.list(vaultList.map(v => ({ name: v.name, slug: v.slug, encrypted: v.encryptionEnabled ? 'yes' : 'no', description: v.description || 'No description', id: v.id })), {
+                emptyMessage: 'No vaults found.',
+                columns: [
+                    { key: 'name', header: 'Name' },
+                    { key: 'slug', header: 'Slug' },
+                    { key: 'encrypted', header: 'Encrypted' },
+                    { key: 'description', header: 'Description' },
+                    { key: 'id', header: 'ID' },
+                ],
+                textFn: (v) => {
+                    const encIcon = v.encrypted === 'yes' ? chalk.green(' [encrypted]') : '';
+                    return `${chalk.cyan(String(v.name))} ${chalk.dim(`(${String(v.slug)})`)}${encIcon} -- ${String(v.description)}`;
+                },
+            });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to fetch vaults');
+        }
+    });
+    addGlobalFlags(vaults.command('get')
+        .description('Show detailed information about a vault')
+        .argument('<vaultId>', 'Vault ID or slug'))
+        .action(async (vaultId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Fetching vault...');
+        try {
+            const client = getClient();
+            const vault = await client.vaults.get(vaultId);
+            out.stopSpinner();
+            out.record({
+                name: vault.name,
+                slug: vault.slug,
+                id: vault.id,
+                description: vault.description,
+                encrypted: vault.encryptionEnabled ? 'yes' : 'no',
+                createdAt: vault.createdAt,
+                updatedAt: vault.updatedAt,
+            });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to fetch vault');
+        }
+    });
+    addGlobalFlags(vaults.command('create')
+        .description('Create a new vault')
+        .argument('<name>', 'Vault name (used to generate the URL slug)')
+        .option('-d, --description <desc>', 'Vault description')
+        .option('--encrypted', 'Enable client-side encryption (AES-256-GCM)')
+        .addHelpText('after', `
+EXAMPLES
+  lsvault vaults create "My Notes"
+  lsvault vaults create "Work Journal" --description "Daily work log"
+  lsvault vaults create "Secrets" --encrypted`))
+        .action(async (name, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Creating vault...');
+        try {
+            const client = getClient();
+            const isEncrypted = _opts.encrypted === true;
+            const vault = await client.vaults.create({
+                name,
+                description: _opts.description,
+                encryptionEnabled: isEncrypted,
+            });
+            if (isEncrypted) {
+                const key = generateVaultKey();
+                const credManager = createCredentialManager();
+                await credManager.saveVaultKey(vault.id, key);
+                out.success(`Encrypted vault created: ${chalk.cyan(vault.name)} (${vault.slug})`, {
+                    id: vault.id,
+                    name: vault.name,
+                    slug: vault.slug,
+                    encrypted: true,
+                    vaultKey: key,
+                });
+                out.warn('IMPORTANT: Save this encryption key securely. If lost, your data cannot be recovered.');
+                out.status(`Vault Key: ${chalk.green(key)}`);
+                out.status(chalk.dim('The key has been saved to your credential store.'));
+                out.status(chalk.dim('You can export it later with: lsvault vaults export-key ' + vault.id));
+                out.warn('Encrypted vaults disable: full-text search, AI features, hooks, and webhooks.');
+            }
+            else {
+                out.success(`Vault created: ${chalk.cyan(vault.name)} (${vault.slug})`, {
+                    id: vault.id,
+                    name: vault.name,
+                    slug: vault.slug,
+                });
+            }
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to create vault');
+        }
+    });
+    addGlobalFlags(vaults.command('export-key')
+        .description('Export the encryption key for an encrypted vault')
+        .argument('<vaultId>', 'Vault ID'))
+        .action(async (vaultId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        try {
+            const credManager = createCredentialManager();
+            const key = await credManager.getVaultKey(vaultId);
+            if (!key) {
+                out.error('No encryption key found for vault ' + vaultId);
+                out.status(chalk.dim('Keys can be imported with: lsvault vaults import-key <vaultId> --key <key>'));
+                process.exitCode = 1;
+                return;
+            }
+            out.raw(key + '\n');
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to export vault key');
+        }
+    });
+    addGlobalFlags(vaults.command('import-key')
+        .description('Import an encryption key for an encrypted vault')
+        .argument('<vaultId>', 'Vault ID')
+        .requiredOption('--key <key>', 'Encryption key (64-character hex string)'))
+        .action(async (vaultId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        try {
+            const keyValue = _opts.key;
+            if (!/^[0-9a-f]{64}$/.test(keyValue)) {
+                out.error('Invalid key format. Expected a 64-character hex string (256 bits).');
+                process.exitCode = 1;
+                return;
+            }
+            const credManager = createCredentialManager();
+            await credManager.saveVaultKey(vaultId, keyValue);
+            out.success('Vault encryption key saved successfully.', { vaultId });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to import vault key');
+        }
+    });
+}

package/dist/commands/versions.d.ts

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