@lifestreamdynamics/vault-cli 1.2.0 → 1.3.0

package/dist/commands/calendar.js

@@ -8,8 +8,8 @@ export function registerCalendarCommands(program) {
     addGlobalFlags(calendar.command('view')
         .description('View calendar activity for a vault')
         .argument('<vaultId>', 'Vault ID')
-        .option('--start <date>', 'Start date (YYYY-MM-DD)', getDefaultStart())
-        .option('--end <date>', 'End date (YYYY-MM-DD)', getDefaultEnd()))
+        .option('--start <date>', 'Start date (YYYY-MM-DD)')
+        .option('--end <date>', 'End date (YYYY-MM-DD)'))
         .action(async (vaultId, _opts) => {
         const flags = resolveFlags(_opts);
         const out = createOutput(flags);
@@ -17,8 +17,8 @@ export function registerCalendarCommands(program) {
         try {
             const client = await getClientAsync();
             const response = await client.calendar.getActivity(vaultId, {
-                start: _opts.start,
-                end: _opts.end,
+                start: _opts.start ?? getDefaultStart(),
+                end: _opts.end ?? getDefaultEnd(),
             });
             out.stopSpinner();
             if (flags.output === 'text') {
@@ -50,6 +50,7 @@ export function registerCalendarCommands(program) {
         }
     });
     // calendar due
+    const VALID_DUE_STATUSES = ['overdue', 'upcoming', 'all'];
     addGlobalFlags(calendar.command('due')
         .description('List documents with due dates')
         .argument('<vaultId>', 'Vault ID')
@@ -57,11 +58,17 @@ export function registerCalendarCommands(program) {
         .action(async (vaultId, _opts) => {
         const flags = resolveFlags(_opts);
         const out = createOutput(flags);
+        const statusVal = _opts.status;
+        if (statusVal && !VALID_DUE_STATUSES.includes(statusVal)) {
+            out.error(`Invalid --status "${statusVal}". Must be one of: ${VALID_DUE_STATUSES.join(', ')}`);
+            process.exitCode = 1;
+            return;
+        }
         out.startSpinner('Loading due dates...');
         try {
             const client = await getClientAsync();
             const docs = await client.calendar.getDueDates(vaultId, {
-                status: _opts.status,
+                status: (statusVal ?? 'all'),
             });
             out.stopSpinner();
             out.list(docs.map(d => ({
@@ -117,7 +124,7 @@ export function registerCalendarCommands(program) {
             handleError(out, err, 'Set due date failed');
         }
     });
-    // calendar events
+    // calendar events (list)
     addGlobalFlags(calendar.command('events')
         .description('List calendar events')
         .argument('<vaultId>', 'Vault ID')
@@ -154,6 +161,307 @@ export function registerCalendarCommands(program) {
             handleError(out, err, 'Calendar events failed');
         }
     });
+    // ---------------------------------------------------------------------------
+    // calendar event subgroup (CRUD)
+    // ---------------------------------------------------------------------------
+    const event = calendar.command('event').description('Calendar event CRUD operations');
+    // calendar event create
+    addGlobalFlags(event.command('create')
+        .description('Create a new calendar event')
+        .argument('<vaultId>', 'Vault ID')
+        .requiredOption('--title <title>', 'Event title')
+        .requiredOption('--start <date>', 'Start date/time (YYYY-MM-DD or ISO 8601)')
+        .option('--end <date>', 'End date/time (YYYY-MM-DD or ISO 8601)')
+        .option('--all-day', 'Mark as all-day event')
+        .option('--priority <priority>', 'Priority (low/medium/high)')
+        .option('--color <color>', 'Event color (e.g. red, blue, #ff0000)')
+        .option('--description <description>', 'Event description'))
+        .action(async (vaultId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Creating event...');
+        try {
+            const client = await getClientAsync();
+            const created = await client.calendar.createEvent(vaultId, {
+                title: _opts.title,
+                startDate: _opts.start,
+                endDate: _opts.end,
+                allDay: Boolean(_opts.allDay),
+                priority: _opts.priority,
+                color: _opts.color,
+                description: _opts.description,
+            });
+            out.stopSpinner();
+            if (flags.output === 'json') {
+                out.raw(JSON.stringify(created, null, 2) + '\n');
+            }
+            else {
+                out.status(chalk.green(`Event created: ${created.title} (${created.id})`));
+            }
+        }
+        catch (err) {
+            handleError(out, err, 'Create event failed');
+        }
+    });
+    // calendar event update
+    addGlobalFlags(event.command('update')
+        .description('Update an existing calendar event')
+        .argument('<vaultId>', 'Vault ID')
+        .argument('<eventId>', 'Event ID')
+        .option('--title <title>', 'Event title')
+        .option('--start <date>', 'Start date/time (YYYY-MM-DD or ISO 8601)')
+        .option('--end <date>', 'End date/time')
+        .option('--all-day', 'Mark as all-day event')
+        .option('--priority <priority>', 'Priority (low/medium/high)')
+        .option('--color <color>', 'Event color')
+        .option('--description <description>', 'Event description'))
+        .action(async (vaultId, eventId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Updating event...');
+        try {
+            const client = await getClientAsync();
+            const data = {};
+            if (_opts.title)
+                data.title = _opts.title;
+            if (_opts.start)
+                data.startDate = _opts.start;
+            if (_opts.end)
+                data.endDate = _opts.end;
+            if (_opts.allDay !== undefined)
+                data.allDay = Boolean(_opts.allDay);
+            if (_opts.priority)
+                data.priority = _opts.priority;
+            if (_opts.color)
+                data.color = _opts.color;
+            if (_opts.description)
+                data.description = _opts.description;
+            const updated = await client.calendar.updateEvent(vaultId, eventId, data);
+            out.stopSpinner();
+            if (flags.output === 'json') {
+                out.raw(JSON.stringify(updated, null, 2) + '\n');
+            }
+            else {
+                out.status(chalk.green(`Event updated: ${updated.title}`));
+            }
+        }
+        catch (err) {
+            handleError(out, err, 'Update event failed');
+        }
+    });
+    // calendar event delete
+    addGlobalFlags(event.command('delete')
+        .description('Delete a calendar event')
+        .argument('<vaultId>', 'Vault ID')
+        .argument('<eventId>', 'Event ID')
+        .option('--confirm', 'Skip confirmation prompt'))
+        .action(async (vaultId, eventId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        if (!_opts.confirm) {
+            out.status(chalk.yellow(`Pass --confirm to delete event ${eventId}`));
+            return;
+        }
+        out.startSpinner('Deleting event...');
+        try {
+            const client = await getClientAsync();
+            await client.calendar.deleteEvent(vaultId, eventId);
+            out.stopSpinner();
+            out.status(chalk.green(`Event ${eventId} deleted.`));
+        }
+        catch (err) {
+            handleError(out, err, 'Delete event failed');
+        }
+    });
+    // calendar event get
+    addGlobalFlags(event.command('get')
+        .description('Get a single calendar event by ID')
+        .argument('<vaultId>', 'Vault ID')
+        .argument('<eventId>', 'Event ID'))
+        .action(async (vaultId, eventId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Loading event...');
+        try {
+            const client = await getClientAsync();
+            const ev = await client.calendar.getEvent(vaultId, eventId);
+            out.stopSpinner();
+            if (flags.output === 'json') {
+                out.raw(JSON.stringify(ev, null, 2) + '\n');
+            }
+            else {
+                out.status(`${chalk.bold(ev.title)}\nID: ${ev.id}\nDate: ${ev.startDate}${ev.endDate ? ` – ${ev.endDate}` : ''}\nPriority: ${ev.priority || '-'}\nCompleted: ${ev.completed ? 'yes' : 'no'}`);
+            }
+        }
+        catch (err) {
+            handleError(out, err, 'Get event failed');
+        }
+    });
+    // ---------------------------------------------------------------------------
+    // calendar timeline
+    // ---------------------------------------------------------------------------
+    addGlobalFlags(calendar.command('timeline')
+        .description('View chronological event timeline for a vault')
+        .argument('<vaultId>', 'Vault ID')
+        .option('--limit <n>', 'Number of items to return')
+        .option('--cursor <cursor>', 'Pagination cursor'))
+        .action(async (vaultId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Loading timeline...');
+        try {
+            const client = await getClientAsync();
+            const timeline = await client.calendar.getTimeline(vaultId, {
+                limit: _opts.limit ? Number(_opts.limit) : undefined,
+                cursor: _opts.cursor,
+            });
+            out.stopSpinner();
+            if (flags.output === 'json') {
+                out.raw(JSON.stringify(timeline, null, 2) + '\n');
+            }
+            else {
+                process.stdout.write(`${chalk.dim(`${timeline.total} total items`)}\n\n`);
+                for (const item of timeline.items) {
+                    const label = item.type === 'event'
+                        ? chalk.cyan(item.event?.title ?? 'Event')
+                        : chalk.yellow(item.document?.path ?? 'Document');
+                    process.stdout.write(`${chalk.dim(item.date)}  ${label} [${item.type}]\n`);
+                }
+                if (timeline.nextCursor) {
+                    process.stdout.write(chalk.dim(`\nNext cursor: ${timeline.nextCursor}\n`));
+                }
+            }
+        }
+        catch (err) {
+            handleError(out, err, 'Timeline failed');
+        }
+    });
+    // ---------------------------------------------------------------------------
+    // calendar upcoming
+    // ---------------------------------------------------------------------------
+    addGlobalFlags(calendar.command('upcoming')
+        .description('Show upcoming events and due items for a vault')
+        .argument('<vaultId>', 'Vault ID'))
+        .action(async (vaultId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Loading upcoming items...');
+        try {
+            const client = await getClientAsync();
+            const upcoming = await client.calendar.getUpcoming(vaultId);
+            out.stopSpinner();
+            if (flags.output === 'json') {
+                out.raw(JSON.stringify(upcoming, null, 2) + '\n');
+            }
+            else {
+                process.stdout.write(chalk.bold('Upcoming Events\n'));
+                if (upcoming.events.length === 0) {
+                    process.stdout.write(chalk.dim('  None\n'));
+                }
+                else {
+                    for (const e of upcoming.events) {
+                        process.stdout.write(`  ${chalk.cyan(e.title)} — ${chalk.dim(e.startDate)}\n`);
+                    }
+                }
+                process.stdout.write(chalk.bold('\nDue Documents\n'));
+                if (upcoming.dueDocs.length === 0) {
+                    process.stdout.write(chalk.dim('  None\n'));
+                }
+                else {
+                    for (const d of upcoming.dueDocs) {
+                        const color = d.overdue ? chalk.red : chalk.yellow;
+                        process.stdout.write(`  ${color(d.path)} — due ${chalk.dim(d.dueAt)}\n`);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            handleError(out, err, 'Upcoming failed');
+        }
+    });
+    // ---------------------------------------------------------------------------
+    // calendar ical-token subgroup
+    // ---------------------------------------------------------------------------
+    const icalToken = calendar.command('ical-token').description('Manage iCal subscription tokens');
+    // calendar ical-token generate
+    addGlobalFlags(icalToken.command('generate')
+        .description('Generate a new iCal subscription token for a vault')
+        .argument('<vaultId>', 'Vault ID'))
+        .action(async (vaultId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Generating iCal token...');
+        try {
+            const client = await getClientAsync();
+            const result = await client.calendar.generateICalToken(vaultId);
+            out.stopSpinner();
+            if (flags.output === 'json') {
+                out.raw(JSON.stringify(result, null, 2) + '\n');
+            }
+            else {
+                out.status(chalk.green('iCal token generated.'));
+                process.stdout.write(`Feed URL: ${chalk.cyan(result.feedUrl)}\nToken: ${result.token}\n`);
+            }
+        }
+        catch (err) {
+            handleError(out, err, 'Generate iCal token failed');
+        }
+    });
+    // calendar ical-token revoke
+    addGlobalFlags(icalToken.command('revoke')
+        .description('Revoke the iCal subscription token for a vault')
+        .argument('<vaultId>', 'Vault ID')
+        .option('--confirm', 'Skip confirmation prompt'))
+        .action(async (vaultId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        if (!_opts.confirm) {
+            out.status(chalk.yellow('Pass --confirm to revoke the iCal token. All subscribers will lose access.'));
+            return;
+        }
+        out.startSpinner('Revoking iCal token...');
+        try {
+            const client = await getClientAsync();
+            await client.calendar.revokeICalToken(vaultId);
+            out.stopSpinner();
+            out.status(chalk.green('iCal token revoked.'));
+        }
+        catch (err) {
+            handleError(out, err, 'Revoke iCal token failed');
+        }
+    });
+    // ---------------------------------------------------------------------------
+    // calendar complete
+    // ---------------------------------------------------------------------------
+    addGlobalFlags(calendar.command('complete')
+        .description('Toggle completed state for a document')
+        .argument('<vaultId>', 'Vault ID')
+        .argument('<documentPath>', 'Document path')
+        .option('--completed', 'Mark as complete (default)', true)
+        .option('--no-completed', 'Mark as incomplete'))
+        .action(async (vaultId, documentPath, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Toggling completion...');
+        try {
+            const client = await getClientAsync();
+            const completed = _opts.completed !== false;
+            const result = await client.calendar.toggleComplete(vaultId, documentPath, completed);
+            out.stopSpinner();
+            if (flags.output === 'json') {
+                out.raw(JSON.stringify(result, null, 2) + '\n');
+            }
+            else {
+                out.status(chalk.green(`Completion toggled for ${documentPath}`));
+            }
+        }
+        catch (err) {
+            handleError(out, err, 'Toggle completion failed');
+        }
+    });
+    // ---------------------------------------------------------------------------
+    // calendar agenda
+    // ---------------------------------------------------------------------------
     addGlobalFlags(calendar.command('agenda')
         .description('View due-date agenda grouped by time period')
         .argument('<vaultId>', 'Vault ID')
@@ -189,6 +497,9 @@ export function registerCalendarCommands(program) {
             handleError(out, err, 'Failed to fetch agenda');
         }
     });
+    // ---------------------------------------------------------------------------
+    // calendar ical (raw feed output)
+    // ---------------------------------------------------------------------------
     addGlobalFlags(calendar.command('ical')
         .description('Output iCal feed for a vault to stdout')
         .argument('<vaultId>', 'Vault ID')
@@ -196,17 +507,425 @@ export function registerCalendarCommands(program) {
         .action(async (vaultId, _opts) => {
         const flags = resolveFlags(_opts);
         const out = createOutput(flags);
+        out.startSpinner('Fetching iCal feed...');
         try {
             const client = await getClientAsync();
             const ical = await client.calendar.getIcalFeed(vaultId, {
                 include: _opts.include,
             });
+            out.stopSpinner();
             process.stdout.write(ical);
         }
         catch (err) {
             handleError(out, err, 'Failed to fetch iCal feed');
         }
     });
+    // ---------------------------------------------------------------------------
+    // calendar connector subgroup (Phase 6.6)
+    // ---------------------------------------------------------------------------
+    const connector = calendar.command('connector').description('Calendar connector management');
+    // calendar connector list
+    addGlobalFlags(connector.command('list')
+        .description('List calendar connectors for a vault')
+        .argument('<vaultId>', 'Vault ID'))
+        .action(async (vaultId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Loading connectors...');
+        try {
+            const client = await getClientAsync();
+            const connectors = await client.calendar.listConnectors(vaultId);
+            out.stopSpinner();
+            out.list(connectors.map(c => ({
+                id: c.id,
+                provider: c.provider,
+                expires: c.expiresAt ? c.expiresAt.split('T')[0] : '-',
+                created: c.createdAt.split('T')[0],
+            })), {
+                emptyMessage: 'No calendar connectors.',
+                columns: [
+                    { key: 'id', header: 'ID' },
+                    { key: 'provider', header: 'Provider' },
+                    { key: 'expires', header: 'Expires' },
+                    { key: 'created', header: 'Created' },
+                ],
+                textFn: (c) => `${chalk.cyan(String(c.provider))} — expires: ${chalk.dim(String(c.expires))} — created: ${chalk.dim(String(c.created))}`,
+            });
+        }
+        catch (err) {
+            handleError(out, err, 'List connectors failed');
+        }
+    });
+    // calendar connector sync
+    addGlobalFlags(connector.command('sync')
+        .description('Trigger a manual sync for a calendar connector')
+        .argument('<vaultId>', 'Vault ID')
+        .argument('<connectorId>', 'Connector ID'))
+        .action(async (vaultId, connectorId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Syncing connector...');
+        try {
+            const client = await getClientAsync();
+            const result = await client.calendar.syncConnector(vaultId, connectorId);
+            out.stopSpinner();
+            if (flags.output === 'json') {
+                out.raw(JSON.stringify(result, null, 2) + '\n');
+            }
+            else {
+                out.status(chalk.green(`Sync complete. ${result.synced} synced, ${result.errors} errors.`));
+            }
+        }
+        catch (err) {
+            handleError(out, err, 'Sync connector failed');
+        }
+    });
+    // calendar connector disconnect
+    addGlobalFlags(connector.command('disconnect')
+        .description('Disconnect a calendar connector from a vault')
+        .argument('<vaultId>', 'Vault ID')
+        .argument('<connectorId>', 'Connector ID')
+        .option('--confirm', 'Skip confirmation prompt'))
+        .action(async (vaultId, connectorId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        if (!_opts.confirm) {
+            out.status(chalk.yellow(`Pass --confirm to disconnect connector ${connectorId}.`));
+            return;
+        }
+        out.startSpinner('Disconnecting connector...');
+        try {
+            const client = await getClientAsync();
+            await client.calendar.disconnectConnector(vaultId, connectorId);
+            out.stopSpinner();
+            out.status(chalk.green(`Connector ${connectorId} disconnected.`));
+        }
+        catch (err) {
+            handleError(out, err, 'Disconnect connector failed');
+        }
+    });
+    // calendar connector connect
+    addGlobalFlags(connector.command('connect')
+        .description('Connect a Google or Outlook calendar to a vault via OAuth')
+        .argument('<vaultId>', 'Vault ID')
+        .requiredOption('--provider <provider>', 'Calendar provider: google or outlook'))
+        .action(async (vaultId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        const provider = _opts.provider;
+        if (provider !== 'google' && provider !== 'outlook') {
+            out.status(chalk.red('--provider must be "google" or "outlook"'));
+            process.exitCode = 1;
+            return;
+        }
+        out.startSpinner(`Connecting ${provider} calendar...`);
+        try {
+            const client = await getClientAsync();
+            const result = provider === 'google'
+                ? await client.calendar.connectGoogleCalendar(vaultId)
+                : await client.calendar.connectOutlookCalendar(vaultId);
+            out.stopSpinner();
+            if (flags.output === 'json') {
+                out.record({ authUrl: result.authUrl });
+            }
+            else {
+                out.status(chalk.cyan('Open this URL to connect: ') + result.authUrl);
+            }
+        }
+        catch (err) {
+            handleError(out, err, 'Connect calendar failed');
+        }
+    });
+    // ---------------------------------------------------------------------------
+    // calendar participants subgroup (Pro tier)
+    // ---------------------------------------------------------------------------
+    const participants = calendar.command('participants').description('Manage event participants');
+    // calendar participants list <vaultId> <eventId>
+    addGlobalFlags(participants.command('list')
+        .description('List participants for a calendar event')
+        .argument('<vaultId>', 'Vault ID')
+        .argument('<eventId>', 'Calendar event ID'))
+        .action(async (vaultId, eventId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Loading participants...');
+        try {
+            const client = await getClientAsync();
+            const items = await client.calendar.listParticipants(vaultId, eventId);
+            out.stopSpinner();
+            out.list(items.map((p) => ({
+                id: p.id,
+                email: p.email,
+                name: p.name ?? '-',
+                role: p.role,
+                status: p.status,
+            })), {
+                emptyMessage: 'No participants for this event.',
+                columns: [
+                    { key: 'id', header: 'ID' },
+                    { key: 'email', header: 'Email' },
+                    { key: 'name', header: 'Name' },
+                    { key: 'role', header: 'Role' },
+                    { key: 'status', header: 'Status' },
+                ],
+                textFn: (p) => {
+                    const statusColor = p.status === 'accepted'
+                        ? chalk.green
+                        : p.status === 'declined'
+                            ? chalk.red
+                            : chalk.yellow;
+                    return `${chalk.cyan(String(p.email))} (${p.role}) — ${statusColor(String(p.status))}`;
+                },
+            });
+        }
+        catch (err) {
+            handleError(out, err, 'List participants failed');
+        }
+    });
+    // calendar participants add <vaultId> <eventId> --email <email> [--name <name>] [--role <role>]
+    addGlobalFlags(participants.command('add')
+        .description('Add a participant to a calendar event')
+        .argument('<vaultId>', 'Vault ID')
+        .argument('<eventId>', 'Calendar event ID')
+        .requiredOption('--email <email>', 'Participant email address')
+        .option('--name <name>', 'Participant display name')
+        .option('--role <role>', 'Participant role: organizer, attendee, optional', 'attendee'))
+        .action(async (vaultId, eventId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Adding participant...');
+        try {
+            const client = await getClientAsync();
+            const participant = await client.calendar.addParticipant(vaultId, eventId, {
+                email: _opts.email,
+                name: _opts.name,
+                role: _opts.role,
+            });
+            out.stopSpinner();
+            if (flags.output === 'json') {
+                out.raw(JSON.stringify(participant, null, 2) + '\n');
+            }
+            else {
+                out.status(chalk.green(`Participant added: ${participant.email} (${participant.id})`));
+            }
+        }
+        catch (err) {
+            handleError(out, err, 'Add participant failed');
+        }
+    });
+    // calendar participants update <vaultId> <eventId> <participantId> --status <status>
+    addGlobalFlags(participants.command('update')
+        .description('Update a participant status')
+        .argument('<vaultId>', 'Vault ID')
+        .argument('<eventId>', 'Calendar event ID')
+        .argument('<participantId>', 'Participant ID')
+        .requiredOption('--status <status>', 'New status: accepted, declined, tentative'))
+        .action(async (vaultId, eventId, participantId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Updating participant...');
+        try {
+            const client = await getClientAsync();
+            const participant = await client.calendar.updateParticipant(vaultId, eventId, participantId, {
+                status: _opts.status,
+            });
+            out.stopSpinner();
+            if (flags.output === 'json') {
+                out.raw(JSON.stringify(participant, null, 2) + '\n');
+            }
+            else {
+                out.status(chalk.green(`Participant ${participant.email} updated to ${participant.status}.`));
+            }
+        }
+        catch (err) {
+            handleError(out, err, 'Update participant failed');
+        }
+    });
+    // calendar participants remove <vaultId> <eventId> <participantId>
+    addGlobalFlags(participants.command('remove')
+        .description('Remove a participant from a calendar event')
+        .argument('<vaultId>', 'Vault ID')
+        .argument('<eventId>', 'Calendar event ID')
+        .argument('<participantId>', 'Participant ID')
+        .option('--confirm', 'Skip confirmation prompt'))
+        .action(async (vaultId, eventId, participantId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        if (!_opts.confirm) {
+            out.status(chalk.yellow(`Pass --confirm to remove participant ${participantId}.`));
+            return;
+        }
+        out.startSpinner('Removing participant...');
+        try {
+            const client = await getClientAsync();
+            await client.calendar.removeParticipant(vaultId, eventId, participantId);
+            out.stopSpinner();
+            out.status(chalk.green(`Participant ${participantId} removed.`));
+        }
+        catch (err) {
+            handleError(out, err, 'Remove participant failed');
+        }
+    });
+    // ---------------------------------------------------------------------------
+    // calendar templates subgroup (Pro tier)
+    // ---------------------------------------------------------------------------
+    const templates = calendar.command('templates').description('Manage calendar event templates');
+    // calendar templates list
+    addGlobalFlags(templates.command('list')
+        .description('List event templates for a vault')
+        .argument('<vaultId>', 'Vault ID'))
+        .action(async (vaultId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Loading templates...');
+        try {
+            const client = await getClientAsync();
+            const items = await client.calendar.listTemplates(vaultId);
+            out.stopSpinner();
+            out.list(items.map((t) => ({
+                id: t.id,
+                name: t.name,
+                duration: String(t.duration),
+                description: t.description ?? '-',
+            })), {
+                emptyMessage: 'No event templates.',
+                columns: [
+                    { key: 'id', header: 'ID' },
+                    { key: 'name', header: 'Name' },
+                    { key: 'duration', header: 'Duration (min)' },
+                    { key: 'description', header: 'Description' },
+                ],
+                textFn: (t) => `${chalk.cyan(String(t.name))} — ${chalk.dim(String(t.duration))} min${t.description !== '-' ? ` — ${t.description}` : ''}`,
+            });
+        }
+        catch (err) {
+            handleError(out, err, 'List templates failed');
+        }
+    });
+    // calendar templates create
+    addGlobalFlags(templates.command('create')
+        .description('Create a new event template for a vault')
+        .argument('<vaultId>', 'Vault ID')
+        .requiredOption('--name <name>', 'Template name')
+        .requiredOption('--duration <minutes>', 'Duration in minutes')
+        .option('--description <description>', 'Template description')
+        .option('--location <location>', 'Default location')
+        .option('--color <color>', 'Default color (e.g. red, blue, #ff0000)'))
+        .action(async (vaultId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Creating template...');
+        try {
+            const client = await getClientAsync();
+            const created = await client.calendar.createTemplate(vaultId, {
+                name: _opts.name,
+                duration: Number(_opts.duration),
+                description: _opts.description,
+                location: _opts.location,
+                color: _opts.color,
+            });
+            out.stopSpinner();
+            if (flags.output === 'json') {
+                out.raw(JSON.stringify(created, null, 2) + '\n');
+            }
+            else {
+                out.success(`Template created: ${created.name} (${created.id})`);
+            }
+        }
+        catch (err) {
+            handleError(out, err, 'Create template failed');
+        }
+    });
+    // calendar templates get
+    addGlobalFlags(templates.command('get')
+        .description('Get a single event template by ID')
+        .argument('<vaultId>', 'Vault ID')
+        .argument('<templateId>', 'Template ID'))
+        .action(async (vaultId, templateId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Loading template...');
+        try {
+            const client = await getClientAsync();
+            const t = await client.calendar.getTemplate(vaultId, templateId);
+            out.stopSpinner();
+            out.record({
+                id: t.id,
+                name: t.name,
+                duration: String(t.duration),
+                description: t.description ?? '-',
+                location: t.location ?? '-',
+                color: t.color ?? '-',
+            });
+        }
+        catch (err) {
+            handleError(out, err, 'Get template failed');
+        }
+    });
+    // calendar templates update
+    addGlobalFlags(templates.command('update')
+        .description('Update an event template')
+        .argument('<vaultId>', 'Vault ID')
+        .argument('<templateId>', 'Template ID')
+        .option('--name <name>', 'New template name')
+        .option('--duration <minutes>', 'New duration in minutes')
+        .option('--description <description>', 'New description')
+        .option('--location <location>', 'Default location')
+        .option('--color <color>', 'Default color (e.g. red, blue, #ff0000)'))
+        .action(async (vaultId, templateId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Updating template...');
+        try {
+            const client = await getClientAsync();
+            const data = {};
+            if (_opts.name)
+                data.name = _opts.name;
+            if (_opts.duration)
+                data.duration = Number(_opts.duration);
+            if (_opts.description)
+                data.description = _opts.description;
+            if (_opts.location)
+                data.location = _opts.location;
+            if (_opts.color)
+                data.color = _opts.color;
+            const updated = await client.calendar.updateTemplate(vaultId, templateId, data);
+            out.stopSpinner();
+            if (flags.output === 'json') {
+                out.raw(JSON.stringify(updated, null, 2) + '\n');
+            }
+            else {
+                out.success(`Template updated: ${updated.name}`);
+            }
+        }
+        catch (err) {
+            handleError(out, err, 'Update template failed');
+        }
+    });
+    // calendar templates delete
+    addGlobalFlags(templates.command('delete')
+        .description('Delete an event template')
+        .argument('<vaultId>', 'Vault ID')
+        .argument('<templateId>', 'Template ID')
+        .option('--confirm', 'Skip confirmation prompt'))
+        .action(async (vaultId, templateId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        if (!_opts.confirm) {
+            out.status(chalk.yellow(`Pass --confirm to delete template ${templateId}`));
+            return;
+        }
+        out.startSpinner('Deleting template...');
+        try {
+            const client = await getClientAsync();
+            await client.calendar.deleteTemplate(vaultId, templateId);
+            out.stopSpinner();
+            out.success(`Template ${templateId} deleted.`);
+        }
+        catch (err) {
+            handleError(out, err, 'Delete template failed');
+        }
+    });
 }
 function getDefaultStart() {
     const d = new Date();