@lifestreamdynamics/vault-cli 1.3.5 → 1.3.7

package/dist/commands/calendar.js

@@ -2,12 +2,27 @@ import chalk from 'chalk';
 import { getClientAsync } from '../client.js';
 import { addGlobalFlags, resolveFlags } from '../utils/flags.js';
 import { createOutput, handleError } from '../utils/output.js';
+import { resolveVaultId } from '../utils/resolve-vault.js';
+const NAMED_COLORS = {
+    red: '#ff0000', green: '#00ff00', blue: '#0000ff', yellow: '#ffff00',
+    orange: '#ff8c00', purple: '#800080', pink: '#ff69b4', cyan: '#00ffff',
+    white: '#ffffff', black: '#000000', gray: '#808080', grey: '#808080',
+};
+/** Resolve a color value to #RRGGBB hex format. Pass through if already hex. */
+function resolveColor(value) {
+    if (!value)
+        return undefined;
+    const hex = NAMED_COLORS[value.toLowerCase()];
+    if (hex)
+        return hex;
+    return value; // pass through (API validates the format)
+}
 export function registerCalendarCommands(program) {
     const calendar = program.command('calendar').description('Document calendar and due date management');
     // calendar view
     addGlobalFlags(calendar.command('view')
         .description('View calendar activity for a vault')
-        .argument('<vaultId>', 'Vault ID')
+        .argument('<vaultId>', 'Vault ID or slug')
         .option('--start <date>', 'Start date (YYYY-MM-DD)')
         .option('--end <date>', 'End date (YYYY-MM-DD)'))
         .action(async (vaultId, _opts) => {
@@ -15,6 +30,7 @@ export function registerCalendarCommands(program) {
         const out = createOutput(flags);
         out.startSpinner('Loading calendar...');
         try {
+            vaultId = await resolveVaultId(vaultId);
             const client = await getClientAsync();
             const response = await client.calendar.getActivity(vaultId, {
                 start: _opts.start ?? getDefaultStart(),
@@ -53,7 +69,7 @@ export function registerCalendarCommands(program) {
     const VALID_DUE_STATUSES = ['overdue', 'upcoming', 'all'];
     addGlobalFlags(calendar.command('due')
         .description('List documents with due dates')
-        .argument('<vaultId>', 'Vault ID')
+        .argument('<vaultId>', 'Vault ID or slug')
         .option('--status <status>', 'Filter: overdue, upcoming, all', 'all'))
         .action(async (vaultId, _opts) => {
         const flags = resolveFlags(_opts);
@@ -66,6 +82,7 @@ export function registerCalendarCommands(program) {
         }
         out.startSpinner('Loading due dates...');
         try {
+            vaultId = await resolveVaultId(vaultId);
             const client = await getClientAsync();
             const docs = await client.calendar.getDueDates(vaultId, {
                 status: (statusVal ?? 'all'),
@@ -98,7 +115,7 @@ export function registerCalendarCommands(program) {
     // calendar set-due
     addGlobalFlags(calendar.command('set-due')
         .description('Set due date on a document')
-        .argument('<vaultId>', 'Vault ID')
+        .argument('<vaultId>', 'Vault ID or slug')
         .argument('<path>', 'Document path')
         .requiredOption('--date <date>', 'Due date (YYYY-MM-DD or "clear")')
         .option('--priority <priority>', 'Priority (low/medium/high)')
@@ -108,6 +125,7 @@ export function registerCalendarCommands(program) {
         const out = createOutput(flags);
         out.startSpinner('Setting due date...');
         try {
+            vaultId = await resolveVaultId(vaultId);
             const client = await getClientAsync();
             const dateStr = _opts.date;
             await client.calendar.setDocumentDue(vaultId, path, {
@@ -126,8 +144,8 @@ export function registerCalendarCommands(program) {
     });
     // calendar events (list)
     addGlobalFlags(calendar.command('events')
-        .description('List calendar events')
-        .argument('<vaultId>', 'Vault ID')
+        .description('Full CRUD management for calendar events (list, create, update, delete)')
+        .argument('<vaultId>', 'Vault ID or slug')
         .option('--start <date>', 'Start date')
         .option('--end <date>', 'End date'))
         .action(async (vaultId, _opts) => {
@@ -135,6 +153,7 @@ export function registerCalendarCommands(program) {
         const out = createOutput(flags);
         out.startSpinner('Loading events...');
         try {
+            vaultId = await resolveVaultId(vaultId);
             const client = await getClientAsync();
             const events = await client.calendar.listEvents(vaultId, {
                 start: _opts.start,
@@ -168,7 +187,7 @@ export function registerCalendarCommands(program) {
     // calendar event create
     addGlobalFlags(event.command('create')
         .description('Create a new calendar event')
-        .argument('<vaultId>', 'Vault ID')
+        .argument('<vaultId>', 'Vault ID or slug')
         .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)')
@@ -181,6 +200,7 @@ export function registerCalendarCommands(program) {
         const out = createOutput(flags);
         out.startSpinner('Creating event...');
         try {
+            vaultId = await resolveVaultId(vaultId);
             const client = await getClientAsync();
             const created = await client.calendar.createEvent(vaultId, {
                 title: _opts.title,
@@ -188,7 +208,7 @@ export function registerCalendarCommands(program) {
                 endDate: _opts.end,
                 allDay: Boolean(_opts.allDay),
                 priority: _opts.priority,
-                color: _opts.color,
+                color: resolveColor(_opts.color),
                 description: _opts.description,
             });
             out.stopSpinner();
@@ -206,7 +226,7 @@ export function registerCalendarCommands(program) {
     // calendar event update
     addGlobalFlags(event.command('update')
         .description('Update an existing calendar event')
-        .argument('<vaultId>', 'Vault ID')
+        .argument('<vaultId>', 'Vault ID or slug')
         .argument('<eventId>', 'Event ID')
         .option('--title <title>', 'Event title')
         .option('--start <date>', 'Start date/time (YYYY-MM-DD or ISO 8601)')
@@ -220,6 +240,7 @@ export function registerCalendarCommands(program) {
         const out = createOutput(flags);
         out.startSpinner('Updating event...');
         try {
+            vaultId = await resolveVaultId(vaultId);
             const client = await getClientAsync();
             const data = {};
             if (_opts.title)
@@ -233,7 +254,7 @@ export function registerCalendarCommands(program) {
             if (_opts.priority)
                 data.priority = _opts.priority;
             if (_opts.color)
-                data.color = _opts.color;
+                data.color = resolveColor(_opts.color);
             if (_opts.description)
                 data.description = _opts.description;
             const updated = await client.calendar.updateEvent(vaultId, eventId, data);
@@ -252,18 +273,20 @@ export function registerCalendarCommands(program) {
     // calendar event delete
     addGlobalFlags(event.command('delete')
         .description('Delete a calendar event')
-        .argument('<vaultId>', 'Vault ID')
+        .argument('<vaultId>', 'Vault ID or slug')
         .argument('<eventId>', 'Event ID')
-        .option('--confirm', 'Skip confirmation prompt'))
+        .option('-y, --yes', 'Skip confirmation prompt')
+        .option('--confirm', 'Alias for --yes (deprecated)'))
         .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}`));
+        if (!_opts.yes && !_opts.confirm) {
+            out.status(chalk.yellow(`Pass -y/--yes to delete event ${eventId}`));
             return;
         }
         out.startSpinner('Deleting event...');
         try {
+            vaultId = await resolveVaultId(vaultId);
             const client = await getClientAsync();
             await client.calendar.deleteEvent(vaultId, eventId);
             out.stopSpinner();
@@ -276,13 +299,14 @@ export function registerCalendarCommands(program) {
     // calendar event get
     addGlobalFlags(event.command('get')
         .description('Get a single calendar event by ID')
-        .argument('<vaultId>', 'Vault ID')
+        .argument('<vaultId>', 'Vault ID or slug')
         .argument('<eventId>', 'Event ID'))
         .action(async (vaultId, eventId, _opts) => {
         const flags = resolveFlags(_opts);
         const out = createOutput(flags);
         out.startSpinner('Loading event...');
         try {
+            vaultId = await resolveVaultId(vaultId);
             const client = await getClientAsync();
             const ev = await client.calendar.getEvent(vaultId, eventId);
             out.stopSpinner();
@@ -301,15 +325,20 @@ export function registerCalendarCommands(program) {
     // calendar timeline
     // ---------------------------------------------------------------------------
     addGlobalFlags(calendar.command('timeline')
-        .description('View chronological event timeline for a vault')
-        .argument('<vaultId>', 'Vault ID')
+        .description('Cursor-paginated event feed with before/after navigation')
+        .argument('<vaultId>', 'Vault ID or slug')
         .option('--limit <n>', 'Number of items to return')
-        .option('--cursor <cursor>', 'Pagination cursor'))
+        .option('--cursor <cursor>', 'Pagination cursor')
+        .addHelpText('after', `
+NOTE
+  Use "events" for CRUD operations on calendar events.
+  Use "timeline" for a cursor-paginated event feed across all event types.`))
         .action(async (vaultId, _opts) => {
         const flags = resolveFlags(_opts);
         const out = createOutput(flags);
         out.startSpinner('Loading timeline...');
         try {
+            vaultId = await resolveVaultId(vaultId);
             const client = await getClientAsync();
             const timeline = await client.calendar.getTimeline(vaultId, {
                 limit: _opts.limit ? Number(_opts.limit) : undefined,
@@ -341,12 +370,13 @@ export function registerCalendarCommands(program) {
     // ---------------------------------------------------------------------------
     addGlobalFlags(calendar.command('upcoming')
         .description('Show upcoming events and due items for a vault')
-        .argument('<vaultId>', 'Vault ID'))
+        .argument('<vaultId>', 'Vault ID or slug'))
         .action(async (vaultId, _opts) => {
         const flags = resolveFlags(_opts);
         const out = createOutput(flags);
         out.startSpinner('Loading upcoming items...');
         try {
+            vaultId = await resolveVaultId(vaultId);
             const client = await getClientAsync();
             const upcoming = await client.calendar.getUpcoming(vaultId);
             out.stopSpinner();
@@ -386,12 +416,13 @@ export function registerCalendarCommands(program) {
     // calendar ical-token generate
     addGlobalFlags(icalToken.command('generate')
         .description('Generate a new iCal subscription token for a vault')
-        .argument('<vaultId>', 'Vault ID'))
+        .argument('<vaultId>', 'Vault ID or slug'))
         .action(async (vaultId, _opts) => {
         const flags = resolveFlags(_opts);
         const out = createOutput(flags);
         out.startSpinner('Generating iCal token...');
         try {
+            vaultId = await resolveVaultId(vaultId);
             const client = await getClientAsync();
             const result = await client.calendar.generateICalToken(vaultId);
             out.stopSpinner();
@@ -410,17 +441,19 @@ export function registerCalendarCommands(program) {
     // 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'))
+        .argument('<vaultId>', 'Vault ID or slug')
+        .option('-y, --yes', 'Skip confirmation prompt')
+        .option('--confirm', 'Alias for --yes (deprecated)'))
         .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.'));
+        if (!_opts.yes && !_opts.confirm) {
+            out.status(chalk.yellow('Pass -y/--yes to revoke the iCal token. All subscribers will lose access.'));
             return;
         }
         out.startSpinner('Revoking iCal token...');
         try {
+            vaultId = await resolveVaultId(vaultId);
             const client = await getClientAsync();
             await client.calendar.revokeICalToken(vaultId);
             out.stopSpinner();
@@ -435,7 +468,7 @@ export function registerCalendarCommands(program) {
     // ---------------------------------------------------------------------------
     addGlobalFlags(calendar.command('complete')
         .description('Toggle completed state for a document')
-        .argument('<vaultId>', 'Vault ID')
+        .argument('<vaultId>', 'Vault ID or slug')
         .argument('<documentPath>', 'Document path')
         .option('--completed', 'Mark as complete (default)', true)
         .option('--no-completed', 'Mark as incomplete'))
@@ -444,6 +477,7 @@ export function registerCalendarCommands(program) {
         const out = createOutput(flags);
         out.startSpinner('Toggling completion...');
         try {
+            vaultId = await resolveVaultId(vaultId);
             const client = await getClientAsync();
             const completed = _opts.completed !== false;
             const result = await client.calendar.toggleComplete(vaultId, documentPath, completed);
@@ -464,19 +498,23 @@ export function registerCalendarCommands(program) {
     // ---------------------------------------------------------------------------
     addGlobalFlags(calendar.command('agenda')
         .description('View due-date agenda grouped by time period')
-        .argument('<vaultId>', 'Vault ID')
+        .argument('<vaultId>', 'Vault ID or slug')
         .option('--status <status>', 'Filter by status')
-        .option('--range <range>', 'Time range (e.g., week, month)')
+        .option('--range <range>', 'Time range: number of days, or week (7), month (30), quarter (90), year (365)')
         .option('--group-by <groupBy>', 'Group by field'))
         .action(async (vaultId, _opts) => {
         const flags = resolveFlags(_opts);
         const out = createOutput(flags);
         out.startSpinner('Fetching agenda...');
         try {
+            vaultId = await resolveVaultId(vaultId);
             const client = await getClientAsync();
+            const rangeMap = { week: '7', month: '30', quarter: '90', year: '365' };
+            const rawRange = _opts.range;
+            const resolvedRange = rawRange ? (rangeMap[rawRange.toLowerCase()] ?? rawRange) : undefined;
             const agenda = await client.calendar.getAgenda(vaultId, {
                 status: _opts.status,
-                range: _opts.range,
+                range: resolvedRange,
                 groupBy: _opts.groupBy,
             });
             out.stopSpinner();
@@ -502,13 +540,14 @@ export function registerCalendarCommands(program) {
     // ---------------------------------------------------------------------------
     addGlobalFlags(calendar.command('ical')
         .description('Output iCal feed for a vault to stdout')
-        .argument('<vaultId>', 'Vault ID')
+        .argument('<vaultId>', 'Vault ID or slug')
         .option('--include <types>', 'Types to include'))
         .action(async (vaultId, _opts) => {
         const flags = resolveFlags(_opts);
         const out = createOutput(flags);
         out.startSpinner('Fetching iCal feed...');
         try {
+            vaultId = await resolveVaultId(vaultId);
             const client = await getClientAsync();
             const ical = await client.calendar.getIcalFeed(vaultId, {
                 include: _opts.include,
@@ -527,12 +566,13 @@ export function registerCalendarCommands(program) {
     // calendar connector list
     addGlobalFlags(connector.command('list')
         .description('List calendar connectors for a vault')
-        .argument('<vaultId>', 'Vault ID'))
+        .argument('<vaultId>', 'Vault ID or slug'))
         .action(async (vaultId, _opts) => {
         const flags = resolveFlags(_opts);
         const out = createOutput(flags);
         out.startSpinner('Loading connectors...');
         try {
+            vaultId = await resolveVaultId(vaultId);
             const client = await getClientAsync();
             const connectors = await client.calendar.listConnectors(vaultId);
             out.stopSpinner();
@@ -559,13 +599,14 @@ export function registerCalendarCommands(program) {
     // calendar connector sync
     addGlobalFlags(connector.command('sync')
         .description('Trigger a manual sync for a calendar connector')
-        .argument('<vaultId>', 'Vault ID')
+        .argument('<vaultId>', 'Vault ID or slug')
         .argument('<connectorId>', 'Connector ID'))
         .action(async (vaultId, connectorId, _opts) => {
         const flags = resolveFlags(_opts);
         const out = createOutput(flags);
         out.startSpinner('Syncing connector...');
         try {
+            vaultId = await resolveVaultId(vaultId);
             const client = await getClientAsync();
             const result = await client.calendar.syncConnector(vaultId, connectorId);
             out.stopSpinner();
@@ -583,18 +624,20 @@ export function registerCalendarCommands(program) {
     // calendar connector disconnect
     addGlobalFlags(connector.command('disconnect')
         .description('Disconnect a calendar connector from a vault')
-        .argument('<vaultId>', 'Vault ID')
+        .argument('<vaultId>', 'Vault ID or slug')
         .argument('<connectorId>', 'Connector ID')
-        .option('--confirm', 'Skip confirmation prompt'))
+        .option('-y, --yes', 'Skip confirmation prompt')
+        .option('--confirm', 'Alias for --yes (deprecated)'))
         .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}.`));
+        if (!_opts.yes && !_opts.confirm) {
+            out.status(chalk.yellow(`Pass -y/--yes to disconnect connector ${connectorId}.`));
             return;
         }
         out.startSpinner('Disconnecting connector...');
         try {
+            vaultId = await resolveVaultId(vaultId);
             const client = await getClientAsync();
             await client.calendar.disconnectConnector(vaultId, connectorId);
             out.stopSpinner();
@@ -607,7 +650,7 @@ export function registerCalendarCommands(program) {
     // calendar connector connect
     addGlobalFlags(connector.command('connect')
         .description('Connect a Google or Outlook calendar to a vault via OAuth')
-        .argument('<vaultId>', 'Vault ID')
+        .argument('<vaultId>', 'Vault ID or slug')
         .requiredOption('--provider <provider>', 'Calendar provider: google or outlook'))
         .action(async (vaultId, _opts) => {
         const flags = resolveFlags(_opts);
@@ -620,6 +663,7 @@ export function registerCalendarCommands(program) {
         }
         out.startSpinner(`Connecting ${provider} calendar...`);
         try {
+            vaultId = await resolveVaultId(vaultId);
             const client = await getClientAsync();
             const result = provider === 'google'
                 ? await client.calendar.connectGoogleCalendar(vaultId)
@@ -643,13 +687,14 @@ export function registerCalendarCommands(program) {
     // calendar participants list <vaultId> <eventId>
     addGlobalFlags(participants.command('list')
         .description('List participants for a calendar event')
-        .argument('<vaultId>', 'Vault ID')
+        .argument('<vaultId>', 'Vault ID or slug')
         .argument('<eventId>', 'Calendar event ID'))
         .action(async (vaultId, eventId, _opts) => {
         const flags = resolveFlags(_opts);
         const out = createOutput(flags);
         out.startSpinner('Loading participants...');
         try {
+            vaultId = await resolveVaultId(vaultId);
             const client = await getClientAsync();
             const items = await client.calendar.listParticipants(vaultId, eventId);
             out.stopSpinner();
@@ -685,7 +730,7 @@ export function registerCalendarCommands(program) {
     // 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('<vaultId>', 'Vault ID or slug')
         .argument('<eventId>', 'Calendar event ID')
         .requiredOption('--email <email>', 'Participant email address')
         .option('--name <name>', 'Participant display name')
@@ -695,6 +740,7 @@ export function registerCalendarCommands(program) {
         const out = createOutput(flags);
         out.startSpinner('Adding participant...');
         try {
+            vaultId = await resolveVaultId(vaultId);
             const client = await getClientAsync();
             const participant = await client.calendar.addParticipant(vaultId, eventId, {
                 email: _opts.email,
@@ -716,7 +762,7 @@ export function registerCalendarCommands(program) {
     // calendar participants update <vaultId> <eventId> <participantId> --status <status>
     addGlobalFlags(participants.command('update')
         .description('Update a participant status')
-        .argument('<vaultId>', 'Vault ID')
+        .argument('<vaultId>', 'Vault ID or slug')
         .argument('<eventId>', 'Calendar event ID')
         .argument('<participantId>', 'Participant ID')
         .requiredOption('--status <status>', 'New status: accepted, declined, tentative'))
@@ -725,6 +771,7 @@ export function registerCalendarCommands(program) {
         const out = createOutput(flags);
         out.startSpinner('Updating participant...');
         try {
+            vaultId = await resolveVaultId(vaultId);
             const client = await getClientAsync();
             const participant = await client.calendar.updateParticipant(vaultId, eventId, participantId, {
                 status: _opts.status,
@@ -744,19 +791,21 @@ export function registerCalendarCommands(program) {
     // calendar participants remove <vaultId> <eventId> <participantId>
     addGlobalFlags(participants.command('remove')
         .description('Remove a participant from a calendar event')
-        .argument('<vaultId>', 'Vault ID')
+        .argument('<vaultId>', 'Vault ID or slug')
         .argument('<eventId>', 'Calendar event ID')
         .argument('<participantId>', 'Participant ID')
-        .option('--confirm', 'Skip confirmation prompt'))
+        .option('-y, --yes', 'Skip confirmation prompt')
+        .option('--confirm', 'Alias for --yes (deprecated)'))
         .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}.`));
+        if (!_opts.yes && !_opts.confirm) {
+            out.status(chalk.yellow(`Pass -y/--yes to remove participant ${participantId}.`));
             return;
         }
         out.startSpinner('Removing participant...');
         try {
+            vaultId = await resolveVaultId(vaultId);
             const client = await getClientAsync();
             await client.calendar.removeParticipant(vaultId, eventId, participantId);
             out.stopSpinner();
@@ -773,12 +822,13 @@ export function registerCalendarCommands(program) {
     // calendar templates list
     addGlobalFlags(templates.command('list')
         .description('List event templates for a vault')
-        .argument('<vaultId>', 'Vault ID'))
+        .argument('<vaultId>', 'Vault ID or slug'))
         .action(async (vaultId, _opts) => {
         const flags = resolveFlags(_opts);
         const out = createOutput(flags);
         out.startSpinner('Loading templates...');
         try {
+            vaultId = await resolveVaultId(vaultId);
             const client = await getClientAsync();
             const items = await client.calendar.listTemplates(vaultId);
             out.stopSpinner();
@@ -805,7 +855,7 @@ export function registerCalendarCommands(program) {
     // calendar templates create
     addGlobalFlags(templates.command('create')
         .description('Create a new event template for a vault')
-        .argument('<vaultId>', 'Vault ID')
+        .argument('<vaultId>', 'Vault ID or slug')
         .requiredOption('--name <name>', 'Template name')
         .requiredOption('--duration <minutes>', 'Duration in minutes')
         .option('--description <description>', 'Template description')
@@ -816,13 +866,14 @@ export function registerCalendarCommands(program) {
         const out = createOutput(flags);
         out.startSpinner('Creating template...');
         try {
+            vaultId = await resolveVaultId(vaultId);
             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,
+                color: resolveColor(_opts.color),
             });
             out.stopSpinner();
             if (flags.output === 'json') {
@@ -839,13 +890,14 @@ export function registerCalendarCommands(program) {
     // calendar templates get
     addGlobalFlags(templates.command('get')
         .description('Get a single event template by ID')
-        .argument('<vaultId>', 'Vault ID')
+        .argument('<vaultId>', 'Vault ID or slug')
         .argument('<templateId>', 'Template ID'))
         .action(async (vaultId, templateId, _opts) => {
         const flags = resolveFlags(_opts);
         const out = createOutput(flags);
         out.startSpinner('Loading template...');
         try {
+            vaultId = await resolveVaultId(vaultId);
             const client = await getClientAsync();
             const t = await client.calendar.getTemplate(vaultId, templateId);
             out.stopSpinner();
@@ -865,7 +917,7 @@ export function registerCalendarCommands(program) {
     // calendar templates update
     addGlobalFlags(templates.command('update')
         .description('Update an event template')
-        .argument('<vaultId>', 'Vault ID')
+        .argument('<vaultId>', 'Vault ID or slug')
         .argument('<templateId>', 'Template ID')
         .option('--name <name>', 'New template name')
         .option('--duration <minutes>', 'New duration in minutes')
@@ -877,6 +929,7 @@ export function registerCalendarCommands(program) {
         const out = createOutput(flags);
         out.startSpinner('Updating template...');
         try {
+            vaultId = await resolveVaultId(vaultId);
             const client = await getClientAsync();
             const data = {};
             if (_opts.name)
@@ -888,7 +941,7 @@ export function registerCalendarCommands(program) {
             if (_opts.location)
                 data.location = _opts.location;
             if (_opts.color)
-                data.color = _opts.color;
+                data.color = resolveColor(_opts.color);
             const updated = await client.calendar.updateTemplate(vaultId, templateId, data);
             out.stopSpinner();
             if (flags.output === 'json') {
@@ -905,18 +958,20 @@ export function registerCalendarCommands(program) {
     // calendar templates delete
     addGlobalFlags(templates.command('delete')
         .description('Delete an event template')
-        .argument('<vaultId>', 'Vault ID')
+        .argument('<vaultId>', 'Vault ID or slug')
         .argument('<templateId>', 'Template ID')
-        .option('--confirm', 'Skip confirmation prompt'))
+        .option('-y, --yes', 'Skip confirmation prompt')
+        .option('--confirm', 'Alias for --yes (deprecated)'))
         .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}`));
+        if (!_opts.yes && !_opts.confirm) {
+            out.status(chalk.yellow(`Pass -y/--yes or --confirm to delete template ${templateId}`));
             return;
         }
         out.startSpinner('Deleting template...');
         try {
+            vaultId = await resolveVaultId(vaultId);
             const client = await getClientAsync();
             await client.calendar.deleteTemplate(vaultId, templateId);
             out.stopSpinner();

package/dist/commands/connectors.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 { resolveVaultId } from '../utils/resolve-vault.js';
 const VALID_PROVIDERS = ['google_drive', 'dropbox', 'onedrive'];
 export function registerConnectorCommands(program) {
     const connectors = program.command('connectors').description('Manage external service connectors (e.g., Google Drive)');
@@ -13,6 +14,8 @@ export function registerConnectorCommands(program) {
         const out = createOutput(flags);
         out.startSpinner('Fetching connectors...');
         try {
+            if (_opts.vault)
+                _opts.vault = await resolveVaultId(String(_opts.vault));
             const client = await getClientAsync();
             const connectorList = await client.connectors.list(_opts.vault);
             out.stopSpinner();
@@ -76,7 +79,12 @@ export function registerConnectorCommands(program) {
         .argument('<name>', 'Connector name')
         .requiredOption('--vault <vaultId>', 'Vault ID')
         .requiredOption('-d, --direction <direction>', 'Sync direction (pull, push, bidirectional)')
-        .option('-p, --sync-path <path>', 'Sync path prefix'))
+        .option('-p, --sync-path <path>', 'Sync path prefix')
+        .addHelpText('after', `
+VALID PROVIDERS
+  google_drive    Google Drive
+  dropbox         Dropbox
+  onedrive        Microsoft OneDrive`))
         .action(async (provider, name, _opts) => {
         const flags = resolveFlags(_opts);
         const out = createOutput(flags);
@@ -85,8 +93,20 @@ export function registerConnectorCommands(program) {
             process.exitCode = 1;
             return;
         }
+        if (flags.dryRun) {
+            out.success(`[dry-run] Would create ${provider} connector "${name}" in vault ${String(_opts.vault)}`, {
+                dryRun: true,
+                provider,
+                name,
+                vaultId: String(_opts.vault),
+                syncDirection: String(_opts.direction),
+            });
+            return;
+        }
         out.startSpinner('Creating connector...');
         try {
+            if (_opts.vault)
+                _opts.vault = await resolveVaultId(String(_opts.vault));
             const client = await getClientAsync();
             const connector = await client.connectors.create({
                 provider: provider,