@lifestreamdynamics/vault-cli 1.1.0 → 1.3.0

package/dist/commands/scim.js

@@ -0,0 +1,238 @@
+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 registerScimCommands(program) {
+    const scim = program.command('scim').description('SCIM 2.0 user provisioning management (requires scimToken)');
+    // ── list-users ────────────────────────────────────────────────────────────
+    addGlobalFlags(scim.command('list-users')
+        .description('List SCIM-provisioned users')
+        .option('--filter <expr>', 'SCIM filter expression (e.g. \'userName eq "user@example.com"\')')
+        .option('--start-index <n>', 'Pagination start index (1-based)', parseInt)
+        .option('--count <n>', 'Number of results per page (max 100)', parseInt))
+        .action(async (_opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Fetching SCIM users...');
+        try {
+            const client = await getClientAsync();
+            if (!client.scim) {
+                out.error('SCIM resource is not configured. Provide a scimToken when creating the client.');
+                process.exitCode = 1;
+                return;
+            }
+            const result = await client.scim.listUsers({
+                filter: _opts.filter,
+                startIndex: _opts.startIndex,
+                count: _opts.count,
+            });
+            out.stopSpinner();
+            if (flags.output !== 'json') {
+                out.status(chalk.dim(`Total: ${result.totalResults}  Start: ${result.startIndex}  Page: ${result.itemsPerPage}`));
+            }
+            out.list(result.Resources.map((u) => ({
+                id: u.id,
+                userName: u.userName,
+                name: u.name.formatted,
+                active: u.active ? 'yes' : 'no',
+                externalId: u.externalId ?? '',
+            })), {
+                emptyMessage: 'No SCIM users found.',
+                columns: [
+                    { key: 'id', header: 'ID' },
+                    { key: 'userName', header: 'Username' },
+                    { key: 'name', header: 'Name' },
+                    { key: 'active', header: 'Active' },
+                    { key: 'externalId', header: 'External ID' },
+                ],
+                textFn: (u) => `${chalk.cyan(String(u.userName))} ${chalk.dim(`(${String(u.id)})`)} — ${u.name} — ${u.active === 'yes' ? chalk.green('active') : chalk.red('inactive')}`,
+            });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to list SCIM users');
+        }
+    });
+    // ── get-user ──────────────────────────────────────────────────────────────
+    addGlobalFlags(scim.command('get-user')
+        .description('Get a SCIM user by internal ID')
+        .argument('<id>', 'Internal user ID'))
+        .action(async (id, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Fetching SCIM user...');
+        try {
+            const client = await getClientAsync();
+            if (!client.scim) {
+                out.error('SCIM resource is not configured. Provide a scimToken when creating the client.');
+                process.exitCode = 1;
+                return;
+            }
+            const user = await client.scim.getUser(id);
+            out.stopSpinner();
+            out.record({
+                id: user.id,
+                userName: user.userName,
+                givenName: user.name.givenName,
+                familyName: user.name.familyName,
+                email: user.emails[0]?.value ?? '',
+                active: user.active,
+                externalId: user.externalId,
+                created: user.meta.created,
+                lastModified: user.meta.lastModified,
+            });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to fetch SCIM user');
+        }
+    });
+    // ── create-user ───────────────────────────────────────────────────────────
+    addGlobalFlags(scim.command('create-user')
+        .description('Provision a new user via SCIM')
+        .requiredOption('--user-name <userName>', 'Login name (email address)')
+        .requiredOption('--email <email>', 'Primary email address')
+        .option('--given-name <name>', 'First/given name')
+        .option('--family-name <name>', 'Last/family name')
+        .option('--external-id <id>', 'External IdP subject ID'))
+        .action(async (_opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Creating SCIM user...');
+        try {
+            const client = await getClientAsync();
+            if (!client.scim) {
+                out.error('SCIM resource is not configured. Provide a scimToken when creating the client.');
+                process.exitCode = 1;
+                return;
+            }
+            const created = await client.scim.createUser({
+                userName: _opts.userName,
+                emails: [{ value: _opts.email, primary: true }],
+                name: {
+                    givenName: _opts.givenName,
+                    familyName: _opts.familyName,
+                },
+                externalId: _opts.externalId,
+            });
+            out.stopSpinner();
+            if (flags.output === 'json') {
+                out.raw(JSON.stringify(created, null, 2) + '\n');
+            }
+            else {
+                out.raw(chalk.green(`SCIM user created: ${created.userName} (${created.id})`) + '\n');
+            }
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to create SCIM user');
+        }
+    });
+    // ── update-user ───────────────────────────────────────────────────────────
+    addGlobalFlags(scim.command('update-user')
+        .description('Update a SCIM user (full replace)')
+        .argument('<id>', 'Internal user ID')
+        .option('--user-name <userName>', 'Updated login name')
+        .option('--email <email>', 'Updated primary email')
+        .option('--given-name <name>', 'Updated first/given name')
+        .option('--family-name <name>', 'Updated last/family name'))
+        .action(async (id, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        const data = {};
+        if (_opts.userName)
+            data.userName = _opts.userName;
+        if (_opts.email)
+            data.emails = [{ value: _opts.email, primary: true }];
+        if (_opts.givenName || _opts.familyName) {
+            data.name = {
+                givenName: _opts.givenName,
+                familyName: _opts.familyName,
+            };
+        }
+        if (Object.keys(data).length === 0) {
+            out.error('No updates specified. Use --user-name, --email, --given-name, or --family-name.');
+            process.exitCode = 2;
+            return;
+        }
+        out.startSpinner('Updating SCIM user...');
+        try {
+            const client = await getClientAsync();
+            if (!client.scim) {
+                out.error('SCIM resource is not configured. Provide a scimToken when creating the client.');
+                process.exitCode = 1;
+                return;
+            }
+            const updated = await client.scim.updateUser(id, data);
+            out.stopSpinner();
+            if (flags.output === 'json') {
+                out.raw(JSON.stringify(updated, null, 2) + '\n');
+            }
+            else {
+                out.raw(chalk.green(`SCIM user updated: ${updated.userName} (${updated.id})`) + '\n');
+            }
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to update SCIM user');
+        }
+    });
+    // ── delete-user ───────────────────────────────────────────────────────────
+    addGlobalFlags(scim.command('delete-user')
+        .description('Deprovision a SCIM user (removes SSO bindings)')
+        .argument('<id>', 'Internal user ID')
+        .option('--force', 'Skip confirmation prompt'))
+        .action(async (id, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        if (!_opts.force) {
+            out.raw(chalk.yellow(`Pass --force to deprovision SCIM user ${id}.`) + '\n');
+            return;
+        }
+        out.startSpinner('Deprovisioning SCIM user...');
+        try {
+            const client = await getClientAsync();
+            if (!client.scim) {
+                out.error('SCIM resource is not configured. Provide a scimToken when creating the client.');
+                process.exitCode = 1;
+                return;
+            }
+            await client.scim.deleteUser(id);
+            out.stopSpinner();
+            out.raw(chalk.green(`SCIM user ${id} deprovisioned.`) + '\n');
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to deprovision SCIM user');
+        }
+    });
+    // ── service-config ────────────────────────────────────────────────────────
+    addGlobalFlags(scim.command('service-config')
+        .description('Show SCIM service provider capabilities'))
+        .action(async (_opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Fetching SCIM service provider config...');
+        try {
+            const client = await getClientAsync();
+            if (!client.scim) {
+                out.error('SCIM resource is not configured. Provide a scimToken when creating the client.');
+                process.exitCode = 1;
+                return;
+            }
+            const config = await client.scim.getServiceProviderConfig();
+            out.stopSpinner();
+            if (flags.output === 'json') {
+                out.raw(JSON.stringify(config, null, 2) + '\n');
+            }
+            else {
+                out.record({
+                    patch: String(config.patch.supported),
+                    bulk: String(config.bulk.supported),
+                    filter: String(config.filter.supported),
+                    filterMaxResults: String(config.filter.maxResults),
+                    changePassword: String(config.changePassword.supported),
+                    sort: String(config.sort.supported),
+                });
+            }
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to fetch SCIM service provider config');
+        }
+    });
+}

package/dist/commands/shares.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';
+import { promptPassword, readPasswordFromStdin } from '../utils/prompt.js';
 export function registerShareCommands(program) {
     const shares = program.command('shares').description('Create, list, and revoke document share links');
     addGlobalFlags(shares.command('list')
@@ -55,20 +56,41 @@ export function registerShareCommands(program) {
         .argument('<vaultId>', 'Vault ID')
         .argument('<docPath>', 'Document path (e.g., notes/meeting.md)')
         .option('--permission <perm>', 'Permission level: view or edit', 'view')
-        .option('--password <password>', 'Password to protect the link')
+        .option('--protect-with-password', 'Prompt for a password to protect the link (interactive TTY only)')
+        .option('--password-stdin', 'Read link password from stdin for CI usage')
         .option('--expires <date>', 'Expiration date (ISO 8601)')
         .option('--max-views <count>', 'Maximum number of views'))
         .action(async (vaultId, docPath, _opts) => {
         const flags = resolveFlags(_opts);
         const out = createOutput(flags);
+        // Resolve optional link password without exposing it in the process list.
+        let linkPassword;
+        if (_opts.passwordStdin) {
+            const pw = await readPasswordFromStdin();
+            if (!pw) {
+                out.error('--password-stdin was set but no password was provided on stdin.');
+                process.exitCode = 1;
+                return;
+            }
+            linkPassword = pw;
+        }
+        else if (_opts.protectWithPassword) {
+            const pw = await promptPassword('Share link password: ');
+            if (!pw) {
+                out.error('A password is required when --protect-with-password is set.');
+                process.exitCode = 1;
+                return;
+            }
+            linkPassword = pw;
+        }
         out.startSpinner('Creating share link...');
         try {
             const client = await getClientAsync();
             const params = {};
             if (_opts.permission)
                 params.permission = String(_opts.permission);
-            if (_opts.password)
-                params.password = String(_opts.password);
+            if (linkPassword)
+                params.password = linkPassword;
             if (_opts.expires)
                 params.expiresAt = String(_opts.expires);
             if (_opts.maxViews)

package/dist/commands/subscription.js

@@ -3,6 +3,7 @@ import { getClientAsync } from '../client.js';
 import { addGlobalFlags, resolveFlags } from '../utils/flags.js';
 import { createOutput, handleError } from '../utils/output.js';
 import { formatBytes } from '../utils/format.js';
+import { confirmAction } from '../utils/confirm.js';
 export function registerSubscriptionCommands(program) {
     const sub = program.command('subscription').description('View plans, manage subscription, and access billing');
     addGlobalFlags(sub.command('status')
@@ -98,12 +99,18 @@ EXAMPLES
     });
     addGlobalFlags(sub.command('cancel')
         .description('Cancel your current subscription')
-        .option('--reason <text>', 'Reason for cancellation'))
+        .option('--reason <text>', 'Reason for cancellation')
+        .option('-y, --yes', 'Skip confirmation prompt'))
         .action(async (_opts) => {
         const flags = resolveFlags(_opts);
         const out = createOutput(flags);
-        out.startSpinner('Cancelling subscription...');
         try {
+            const confirmed = await confirmAction('Are you sure you want to cancel your subscription?', { yes: _opts.yes });
+            if (!confirmed) {
+                out.status('Cancellation aborted.');
+                return;
+            }
+            out.startSpinner('Cancelling subscription...');
             const client = await getClientAsync();
             await client.subscription.cancel(_opts.reason);
             out.success('Subscription cancelled', { cancelled: true });

package/dist/commands/sync.js

@@ -35,6 +35,9 @@ export function registerSyncCommands(program) {
             const absPath = path.resolve(localPath);
             const mode = _opts.mode ?? 'sync';
             const onConflict = _opts.onConflict ?? 'newer';
+            if (!_opts.onConflict) {
+                out.warn('No --on-conflict strategy specified; defaulting to "newer" (keeps the file with the more recent modification time). Use --on-conflict local|remote|ask to override.');
+            }
             const ignore = _opts.ignore;
             const syncInterval = _opts.interval;
             const autoSync = _opts.autoSync === true;

package/dist/commands/teams.js

@@ -97,10 +97,15 @@ EXAMPLES
     });
     addGlobalFlags(teams.command('delete')
         .description('Permanently delete a team and all its data')
-        .argument('<teamId>', 'Team ID'))
+        .argument('<teamId>', 'Team ID')
+        .option('-y, --yes', 'Skip confirmation prompt'))
         .action(async (teamId, _opts) => {
         const flags = resolveFlags(_opts);
         const out = createOutput(flags);
+        if (!_opts.yes) {
+            out.status(chalk.yellow(`Pass --yes to permanently delete team ${teamId} and all its data.`));
+            return;
+        }
         out.startSpinner('Deleting team...');
         try {
             const client = await getClientAsync();
@@ -125,7 +130,7 @@ EXAMPLES
             const memberList = await client.teams.listMembers(teamId);
             out.stopSpinner();
             out.list(memberList.map(m => ({
-                name: m.user.name || m.user.email,
+                name: m.user.displayName || m.user.email,
                 userId: m.userId,
                 role: m.role,
                 email: m.user.email,
@@ -169,10 +174,15 @@ EXAMPLES
     addGlobalFlags(members.command('remove')
         .description('Remove a member from the team')
         .argument('<teamId>', 'Team ID')
-        .argument('<userId>', 'User ID'))
+        .argument('<userId>', 'User ID')
+        .option('-y, --yes', 'Skip confirmation prompt'))
         .action(async (teamId, userId, _opts) => {
         const flags = resolveFlags(_opts);
         const out = createOutput(flags);
+        if (!_opts.yes) {
+            out.status(chalk.yellow(`Pass --yes to remove user ${userId} from team ${teamId}.`));
+            return;
+        }
         out.startSpinner('Removing member...');
         try {
             const client = await getClientAsync();
@@ -284,7 +294,7 @@ EXAMPLES
             const client = await getClientAsync();
             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' })), {
+            out.list(vaultList.map(v => ({ name: String(v.name), slug: String(v.slug), description: v.description ?? 'No description' })), {
                 emptyMessage: 'No team vaults found.',
                 columns: [
                     { key: 'name', header: 'Name' },
@@ -319,4 +329,223 @@ 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.activityCount) {
+                        process.stdout.write(`${chalk.cyan(date)}: ${day.activityCount} 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.total) {
+                        process.stdout.write(`${chalk.cyan(day.date)}: ${day.total} 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');
+        }
+    });
+    addGlobalFlags(teamCalendar.command('upcoming')
+        .description('View upcoming events and due items for a team')
+        .argument('<teamId>', 'Team ID'))
+        .action(async (teamId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Fetching upcoming items...');
+        try {
+            const client = await getClientAsync();
+            const upcoming = await client.teams.getUpcoming(teamId);
+            out.stopSpinner();
+            if (flags.output === 'json') {
+                out.raw(JSON.stringify(upcoming, null, 2) + '\n');
+            }
+            else {
+                if (upcoming.events && upcoming.events.length > 0) {
+                    process.stdout.write(chalk.bold('Events:\n'));
+                    for (const e of upcoming.events) {
+                        process.stdout.write(`  ${chalk.cyan(String(e.title))} — ${String(e.startDate)}\n`);
+                    }
+                }
+                else {
+                    process.stdout.write(chalk.dim('No upcoming events.\n'));
+                }
+                if (upcoming.dueDocs && upcoming.dueDocs.length > 0) {
+                    process.stdout.write(chalk.bold('Due Documents:\n'));
+                    for (const d of upcoming.dueDocs) {
+                        process.stdout.write(`  ${chalk.cyan(String(d.path))} — due ${String(d.dueAt)}\n`);
+                    }
+                }
+                else {
+                    process.stdout.write(chalk.dim('No upcoming due documents.\n'));
+                }
+            }
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to fetch upcoming items');
+        }
+    });
+    addGlobalFlags(teamCalendar.command('due')
+        .description('List due documents for a team')
+        .argument('<teamId>', 'Team ID')
+        .option('--status <status>', 'Filter by status (overdue|upcoming|all)'))
+        .action(async (teamId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Fetching due documents...');
+        try {
+            const client = await getClientAsync();
+            const dueDocs = await client.teams.getDue(teamId, {
+                status: _opts.status,
+            });
+            out.stopSpinner();
+            out.list(dueDocs.map(d => ({
+                path: d.path,
+                title: d.title ?? '',
+                dueAt: d.dueAt,
+                overdue: d.overdue ? 'yes' : 'no',
+            })), {
+                emptyMessage: 'No due documents found.',
+                columns: [
+                    { key: 'path', header: 'Path' },
+                    { key: 'title', header: 'Title' },
+                    { key: 'dueAt', header: 'Due At' },
+                    { key: 'overdue', header: 'Overdue' },
+                ],
+                textFn: (d) => `${chalk.cyan(String(d.path))} — due ${String(d.dueAt)} ${d.overdue === 'yes' ? chalk.red('[overdue]') : ''}`,
+            });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to fetch due documents');
+        }
+    });
+    addGlobalFlags(teamCalendar.command('agenda')
+        .description('View the team calendar agenda')
+        .argument('<teamId>', 'Team ID')
+        .option('--range <days>', 'Number of days to include')
+        .option('--group-by <period>', 'Group by period (day|week|month)'))
+        .action(async (teamId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Fetching team agenda...');
+        try {
+            const client = await getClientAsync();
+            const agenda = await client.teams.getAgenda(teamId, {
+                range: _opts.range,
+                groupBy: _opts.groupBy,
+            });
+            out.stopSpinner();
+            if (flags.output === 'json') {
+                out.raw(JSON.stringify(agenda, null, 2) + '\n');
+            }
+            else {
+                process.stdout.write(`Total items: ${chalk.cyan(String(agenda.total))}\n`);
+                for (const group of agenda.groups ?? []) {
+                    process.stdout.write(`\n${chalk.bold(String(group.label))}:\n`);
+                    for (const item of group.items ?? []) {
+                        process.stdout.write(`  ${chalk.cyan(String(item.title ?? item.path))} — ${String(item.dueAt ?? '')}\n`);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to fetch team agenda');
+        }
+    });
+    addGlobalFlags(teamCalendar.command('ical')
+        .description('Get the iCal feed for a team calendar')
+        .argument('<teamId>', 'Team ID'))
+        .action(async (teamId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Fetching iCal feed...');
+        try {
+            const client = await getClientAsync();
+            const ical = await client.teams.getICalFeed(teamId);
+            out.stopSpinner();
+            out.raw(ical);
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to fetch iCal feed');
+        }
+    });
 }