@lifestreamdynamics/vault-cli 1.1.0 → 1.2.0

package/dist/commands/publish-vault.js

@@ -0,0 +1,117 @@
+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 registerPublishVaultCommands(program) {
+    const pv = program.command('publish-vault').description('Manage whole-vault publishing (public sites)');
+    addGlobalFlags(pv.command('list')
+        .description('List your published vault sites'))
+        .action(async (_opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Fetching published vaults...');
+        try {
+            const client = await getClientAsync();
+            const list = await client.publishVault.listMine();
+            out.stopSpinner();
+            out.list(list.map(pv => ({ slug: pv.slug, title: pv.title, isPublished: pv.isPublished ? 'yes' : 'no', createdAt: pv.createdAt })), {
+                emptyMessage: 'No published vault sites found.',
+                columns: [
+                    { key: 'slug', header: 'Slug' },
+                    { key: 'title', header: 'Title' },
+                    { key: 'isPublished', header: 'Published' },
+                    { key: 'createdAt', header: 'Created' },
+                ],
+                textFn: (pv) => `${chalk.cyan(String(pv.slug))} — ${String(pv.title)} [${pv.isPublished === 'yes' ? chalk.green('live') : chalk.dim('draft')}]`,
+            });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to fetch published vaults');
+        }
+    });
+    addGlobalFlags(pv.command('publish')
+        .description('Publish a vault as a public site')
+        .argument('<vaultId>', 'Vault ID')
+        .requiredOption('--slug <slug>', 'URL slug for the site')
+        .requiredOption('--title <title>', 'Site title')
+        .option('--description <desc>', 'Site description')
+        .option('--show-sidebar', 'Show sidebar navigation')
+        .option('--enable-search', 'Enable search on the site')
+        .option('--theme <theme>', 'Site theme')
+        .option('--domain <domainId>', 'Custom domain ID'))
+        .action(async (vaultId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Publishing vault...');
+        try {
+            const client = await getClientAsync();
+            const published = await client.publishVault.publish(vaultId, {
+                slug: _opts.slug,
+                title: _opts.title,
+                description: _opts.description,
+                showSidebar: _opts.showSidebar === true,
+                enableSearch: _opts.enableSearch === true,
+                theme: _opts.theme,
+                customDomainId: _opts.domain,
+            });
+            out.success(`Vault published at /${published.slug}`, { id: published.id, slug: published.slug, title: published.title });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to publish vault');
+        }
+    });
+    addGlobalFlags(pv.command('update')
+        .description('Update a published vault site')
+        .argument('<vaultId>', 'Vault ID')
+        .option('--slug <slug>', 'URL slug')
+        .option('--title <title>', 'Site title')
+        .option('--description <desc>', 'Site description')
+        .option('--show-sidebar', 'Show sidebar')
+        .option('--enable-search', 'Enable search')
+        .option('--theme <theme>', 'Site theme')
+        .option('--domain <domainId>', 'Custom domain ID'))
+        .action(async (vaultId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Updating published vault...');
+        try {
+            const client = await getClientAsync();
+            const params = {};
+            if (_opts.slug)
+                params.slug = _opts.slug;
+            if (_opts.title)
+                params.title = _opts.title;
+            if (_opts.description)
+                params.description = _opts.description;
+            if (_opts.showSidebar !== undefined)
+                params.showSidebar = _opts.showSidebar === true;
+            if (_opts.enableSearch !== undefined)
+                params.enableSearch = _opts.enableSearch === true;
+            if (_opts.theme)
+                params.theme = _opts.theme;
+            if (_opts.domain)
+                params.customDomainId = _opts.domain;
+            const published = await client.publishVault.update(vaultId, params);
+            out.success('Published vault updated', { id: published.id, slug: published.slug });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to update published vault');
+        }
+    });
+    addGlobalFlags(pv.command('unpublish')
+        .description('Unpublish a vault site')
+        .argument('<vaultId>', 'Vault ID'))
+        .action(async (vaultId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Unpublishing vault...');
+        try {
+            const client = await getClientAsync();
+            await client.publishVault.unpublish(vaultId);
+            out.success('Vault unpublished', { vaultId });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to unpublish vault');
+        }
+    });
+}

package/dist/commands/publish.js

@@ -135,4 +135,55 @@ export function registerPublishCommands(program) {
             handleError(out, err, 'Failed to unpublish document');
         }
     });
+    const subdomain = publish.command('subdomain').description('Subdomain management for published vaults');
+    addGlobalFlags(subdomain.command('get')
+        .description('Get the subdomain for a published vault')
+        .argument('<vaultId>', 'Vault ID'))
+        .action(async (vaultId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Fetching subdomain...');
+        try {
+            const client = await getClientAsync();
+            const result = await client.publish.getSubdomain(vaultId);
+            out.stopSpinner();
+            out.record({ subdomain: result.subdomain });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to fetch subdomain');
+        }
+    });
+    addGlobalFlags(subdomain.command('set')
+        .description('Set a subdomain for a published vault')
+        .argument('<vaultId>', 'Vault ID')
+        .argument('<subdomain>', 'Subdomain to assign'))
+        .action(async (vaultId, subdomainArg, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Setting subdomain...');
+        try {
+            const client = await getClientAsync();
+            const result = await client.publish.setSubdomain(vaultId, subdomainArg);
+            out.success(`Subdomain set: ${result.subdomain}`, { subdomain: result.subdomain });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to set subdomain');
+        }
+    });
+    addGlobalFlags(subdomain.command('delete')
+        .description('Remove the subdomain for a published vault')
+        .argument('<vaultId>', 'Vault ID'))
+        .action(async (vaultId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Removing subdomain...');
+        try {
+            const client = await getClientAsync();
+            const result = await client.publish.deleteSubdomain(vaultId);
+            out.success(result.message, { message: result.message });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to delete subdomain');
+        }
+    });
 }

package/dist/commands/teams.js

@@ -319,4 +319,100 @@ EXAMPLES
             handleError(out, err, 'Failed to create team vault');
         }
     });
+    const teamCalendar = teams.command('calendar').description('Team calendar operations');
+    addGlobalFlags(teamCalendar.command('view')
+        .description('View team calendar')
+        .argument('<teamId>', 'Team ID')
+        .requiredOption('--start <date>', 'Start date (YYYY-MM-DD)')
+        .requiredOption('--end <date>', 'End date (YYYY-MM-DD)')
+        .option('--types <types>', 'Event types to include'))
+        .action(async (teamId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Fetching team calendar...');
+        try {
+            const client = await getClientAsync();
+            const cal = await client.teams.getCalendar(teamId, {
+                start: _opts.start,
+                end: _opts.end,
+                types: _opts.types,
+            });
+            out.stopSpinner();
+            if (flags.output === 'json') {
+                out.raw(JSON.stringify(cal, null, 2) + '\n');
+            }
+            else {
+                for (const [date, day] of Object.entries(cal.days ?? {})) {
+                    if (day && day.count) {
+                        process.stdout.write(`${chalk.cyan(date)}: ${day.count} events\n`);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to fetch team calendar');
+        }
+    });
+    addGlobalFlags(teamCalendar.command('activity')
+        .description('View team calendar activity')
+        .argument('<teamId>', 'Team ID')
+        .requiredOption('--start <date>', 'Start date (YYYY-MM-DD)')
+        .requiredOption('--end <date>', 'End date (YYYY-MM-DD)'))
+        .action(async (teamId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Fetching team calendar activity...');
+        try {
+            const client = await getClientAsync();
+            const activity = await client.teams.getCalendarActivity(teamId, {
+                start: _opts.start,
+                end: _opts.end,
+            });
+            out.stopSpinner();
+            if (flags.output === 'json') {
+                out.raw(JSON.stringify(activity, null, 2) + '\n');
+            }
+            else {
+                for (const day of activity.days ?? []) {
+                    if (day.count) {
+                        process.stdout.write(`${chalk.cyan(day.date)}: ${day.count} activities\n`);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to fetch team calendar activity');
+        }
+    });
+    addGlobalFlags(teamCalendar.command('events')
+        .description('List team calendar events')
+        .argument('<teamId>', 'Team ID')
+        .option('--start <date>', 'Start date (YYYY-MM-DD)')
+        .option('--end <date>', 'End date (YYYY-MM-DD)'))
+        .action(async (teamId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Fetching team calendar events...');
+        try {
+            const client = await getClientAsync();
+            const events = await client.teams.getCalendarEvents(teamId, {
+                start: _opts.start,
+                end: _opts.end,
+            });
+            out.stopSpinner();
+            out.list(events.map(e => ({ id: e.id, title: e.title, startDate: e.startDate, endDate: e.endDate ?? '' })), {
+                emptyMessage: 'No events found.',
+                columns: [
+                    { key: 'id', header: 'ID' },
+                    { key: 'title', header: 'Title' },
+                    { key: 'startDate', header: 'Start' },
+                    { key: 'endDate', header: 'End' },
+                ],
+                textFn: (e) => `${chalk.cyan(String(e.title))} — ${String(e.startDate)}`,
+            });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to fetch team calendar events');
+        }
+    });
 }

package/dist/commands/user.js

@@ -45,4 +45,335 @@ export function registerUserCommands(program) {
             handleError(out, err, 'Failed to fetch storage usage');
         }
     });
+    // user me
+    addGlobalFlags(user.command('me')
+        .description('Show your user profile'))
+        .action(async (_opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Fetching profile...');
+        try {
+            const client = await getClientAsync();
+            const me = await client.user.me();
+            out.stopSpinner();
+            out.record({ id: me.id, email: me.email, name: me.name, role: me.role, createdAt: me.createdAt });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to fetch profile');
+        }
+    });
+    // user password
+    addGlobalFlags(user.command('password')
+        .description('Change your password')
+        .requiredOption('--current <pwd>', 'Current password')
+        .requiredOption('--new <pwd>', 'New password'))
+        .action(async (_opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Changing password...');
+        try {
+            const client = await getClientAsync();
+            await client.user.changePassword({ currentPassword: _opts.current, newPassword: _opts.new });
+            out.success('Password changed successfully', { changed: true });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to change password');
+        }
+    });
+    // user email
+    addGlobalFlags(user.command('email')
+        .description('Request email address change')
+        .requiredOption('--new <email>', 'New email address')
+        .requiredOption('--password <pwd>', 'Current password'))
+        .action(async (_opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Requesting email change...');
+        try {
+            const client = await getClientAsync();
+            const result = await client.user.requestEmailChange({ newEmail: _opts.new, password: _opts.password });
+            out.success(result.message, { message: result.message });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to request email change');
+        }
+    });
+    // user email-verify
+    addGlobalFlags(user.command('email-verify')
+        .description('Confirm email change with verification token')
+        .requiredOption('--token <token>', 'Verification token from email'))
+        .action(async (_opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Verifying email change...');
+        try {
+            const client = await getClientAsync();
+            const result = await client.user.confirmEmailChange(_opts.token);
+            out.success(result.message, { message: result.message });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to verify email change');
+        }
+    });
+    // user profile
+    addGlobalFlags(user.command('profile')
+        .description('Update your profile')
+        .option('--name <name>', 'Display name')
+        .option('--slug <slug>', 'Profile URL slug'))
+        .action(async (_opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Updating profile...');
+        try {
+            const client = await getClientAsync();
+            const result = await client.user.updateProfile({ name: _opts.name, slug: _opts.slug });
+            out.success(result.message, { message: result.message });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to update profile');
+        }
+    });
+    // user delete
+    addGlobalFlags(user.command('delete')
+        .description('Request account deletion')
+        .requiredOption('--password <pwd>', 'Current password')
+        .option('--reason <reason>', 'Reason for deletion')
+        .option('--export-data', 'Request data export before deletion'))
+        .action(async (_opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Requesting account deletion...');
+        try {
+            const client = await getClientAsync();
+            const result = await client.user.requestAccountDeletion({
+                password: _opts.password,
+                reason: _opts.reason,
+                exportData: _opts.exportData === true,
+            });
+            out.success(result.message, { message: result.message, scheduledAt: result.scheduledAt });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to request account deletion');
+        }
+    });
+    // user delete-cancel
+    addGlobalFlags(user.command('delete-cancel')
+        .description('Cancel a pending account deletion'))
+        .action(async (_opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Cancelling account deletion...');
+        try {
+            const client = await getClientAsync();
+            const result = await client.user.cancelAccountDeletion();
+            out.success(result.message, { message: result.message });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to cancel account deletion');
+        }
+    });
+    // user sessions subgroup
+    const sessions = user.command('sessions').description('Session management');
+    addGlobalFlags(sessions.command('list')
+        .description('List active sessions'))
+        .action(async (_opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Fetching sessions...');
+        try {
+            const client = await getClientAsync();
+            const list = await client.user.getSessions();
+            out.stopSpinner();
+            out.list(list.map(s => ({ id: s.id, current: s.current ? 'yes' : 'no', ip: s.ipAddress || '', createdAt: s.createdAt, lastSeen: s.lastSeenAt })), {
+                emptyMessage: 'No sessions found.',
+                columns: [
+                    { key: 'id', header: 'ID' },
+                    { key: 'current', header: 'Current' },
+                    { key: 'ip', header: 'IP' },
+                    { key: 'createdAt', header: 'Created' },
+                    { key: 'lastSeen', header: 'Last Seen' },
+                ],
+                textFn: (s) => `${String(s.id)} ${s.current === 'yes' ? chalk.green('[current]') : ''} — ${String(s.ip)}`,
+            });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to fetch sessions');
+        }
+    });
+    addGlobalFlags(sessions.command('revoke')
+        .description('Revoke a session')
+        .argument('<sessionId>', 'Session ID'))
+        .action(async (sessionId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Revoking session...');
+        try {
+            const client = await getClientAsync();
+            const result = await client.user.revokeSession(sessionId);
+            out.success(result.message, { message: result.message });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to revoke session');
+        }
+    });
+    addGlobalFlags(sessions.command('revoke-all')
+        .description('Revoke all sessions'))
+        .action(async (_opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Revoking all sessions...');
+        try {
+            const client = await getClientAsync();
+            const result = await client.user.revokeAllSessions();
+            out.success(result.message, { message: result.message });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to revoke sessions');
+        }
+    });
+    // user export subgroup
+    const userExport = user.command('export').description('Data export management');
+    addGlobalFlags(userExport.command('create')
+        .description('Request a data export')
+        .option('--format <format>', 'Export format (json)', 'json'))
+        .action(async (_opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Creating data export...');
+        try {
+            const client = await getClientAsync();
+            const exp = await client.user.requestDataExport(_opts.format);
+            out.success('Data export requested', { id: exp.id, status: exp.status, format: exp.format });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to create data export');
+        }
+    });
+    addGlobalFlags(userExport.command('get')
+        .description('Get a data export status')
+        .argument('<exportId>', 'Export ID'))
+        .action(async (exportId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Fetching export status...');
+        try {
+            const client = await getClientAsync();
+            const exp = await client.user.getDataExport(exportId);
+            out.stopSpinner();
+            out.record({ id: exp.id, status: exp.status, format: exp.format, createdAt: exp.createdAt, completedAt: exp.completedAt, downloadUrl: exp.downloadUrl });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to fetch export status');
+        }
+    });
+    // user consents subgroup
+    const consents = user.command('consents').description('Consent management');
+    addGlobalFlags(consents.command('list')
+        .description('List consent records'))
+        .action(async (_opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Fetching consents...');
+        try {
+            const client = await getClientAsync();
+            const list = await client.user.getConsents();
+            out.stopSpinner();
+            out.list(list.map(c => ({ type: c.consentType, version: c.version, granted: c.granted ? 'yes' : 'no', recordedAt: c.recordedAt })), {
+                emptyMessage: 'No consents found.',
+                columns: [
+                    { key: 'type', header: 'Type' },
+                    { key: 'version', header: 'Version' },
+                    { key: 'granted', header: 'Granted' },
+                    { key: 'recordedAt', header: 'Recorded' },
+                ],
+                textFn: (c) => `${String(c.type)} v${String(c.version)}: ${c.granted === 'yes' ? chalk.green('granted') : chalk.red('denied')}`,
+            });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to fetch consents');
+        }
+    });
+    addGlobalFlags(consents.command('set')
+        .description('Record a consent decision')
+        .requiredOption('--type <t>', 'Consent type')
+        .requiredOption('--version <v>', 'Policy version')
+        .option('--granted', 'Grant consent')
+        .option('--no-granted', 'Deny consent'))
+        .action(async (_opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Recording consent...');
+        try {
+            const client = await getClientAsync();
+            const result = await client.user.recordConsent({
+                consentType: _opts.type,
+                version: _opts.version,
+                granted: _opts.granted !== false,
+            });
+            out.success(result.message, { message: result.message });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to record consent');
+        }
+    });
+    // user invitations subgroup
+    const invitations = user.command('invitations').description('Team invitation management');
+    addGlobalFlags(invitations.command('list')
+        .description('List pending team invitations'))
+        .action(async (_opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Fetching invitations...');
+        try {
+            const client = await getClientAsync();
+            const list = await client.user.listTeamInvitations();
+            out.stopSpinner();
+            out.list(list.map(i => ({ id: i.id, team: i.teamName, role: i.role, invitedBy: i.invitedBy, expiresAt: i.expiresAt })), {
+                emptyMessage: 'No pending invitations.',
+                columns: [
+                    { key: 'id', header: 'ID' },
+                    { key: 'team', header: 'Team' },
+                    { key: 'role', header: 'Role' },
+                    { key: 'invitedBy', header: 'Invited By' },
+                    { key: 'expiresAt', header: 'Expires' },
+                ],
+                textFn: (i) => `${chalk.cyan(String(i.team))} [${String(i.role)}] — invited by ${String(i.invitedBy)}`,
+            });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to fetch invitations');
+        }
+    });
+    addGlobalFlags(invitations.command('accept')
+        .description('Accept a team invitation')
+        .argument('<id>', 'Invitation ID'))
+        .action(async (id, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Accepting invitation...');
+        try {
+            const client = await getClientAsync();
+            const result = await client.user.acceptTeamInvitation(id);
+            out.success(result.message, { message: result.message });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to accept invitation');
+        }
+    });
+    addGlobalFlags(invitations.command('decline')
+        .description('Decline a team invitation')
+        .argument('<id>', 'Invitation ID'))
+        .action(async (id, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Declining invitation...');
+        try {
+            const client = await getClientAsync();
+            const result = await client.user.declineTeamInvitation(id);
+            out.success(result.message, { message: result.message });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to decline invitation');
+        }
+    });
 }