@zoobbe/cli 1.2.0 → 1.2.2

package/src/commands/page.js

@@ -98,4 +98,257 @@ page
     }
   });
 
+// ── Extended commands ──
+
+const { confirmAction } = require('../utils/prompts');
+
+page
+  .command('update <pageId>')
+  .description('Update a page')
+  .option('-t, --title <title>', 'New title')
+  .option('--icon <icon>', 'Page icon/emoji')
+  .action(async (pageId, options) => {
+    try {
+      const body = {};
+      if (options.title) body.title = options.title;
+      if (options.icon) body.icon = options.icon;
+      if (Object.keys(body).length === 0) return error('Provide -t or --icon.');
+
+      await withSpinner('Updating page...', () =>
+        client.put(`/pages/${pageId}`, body)
+      );
+      success(`Updated page ${pageId}`);
+    } catch (err) {
+      error(`Failed to update page: ${err.message}`);
+    }
+  });
+
+page
+  .command('delete <pageId>')
+  .description('Delete a page')
+  .option('--permanent', 'Permanently delete (cannot be restored)')
+  .option('--force', 'Skip confirmation')
+  .action(async (pageId, options) => {
+    try {
+      if (!options.force) {
+        const msg = options.permanent
+          ? 'Permanently delete this page? This cannot be undone.'
+          : 'Delete this page?';
+        const confirmed = await confirmAction(msg);
+        if (!confirmed) return;
+      }
+
+      const url = options.permanent ? `/pages/${pageId}/permanent` : `/pages/${pageId}`;
+      await withSpinner('Deleting page...', () =>
+        client.delete(url)
+      );
+      success(`Deleted page ${pageId}`);
+    } catch (err) {
+      error(`Failed to delete page: ${err.message}`);
+    }
+  });
+
+page
+  .command('archive <pageId>')
+  .description('Archive a page')
+  .action(async (pageId) => {
+    try {
+      await withSpinner('Archiving page...', () =>
+        client.post(`/pages/${pageId}/archive`)
+      );
+      success(`Archived page ${pageId}`);
+    } catch (err) {
+      error(`Failed to archive page: ${err.message}`);
+    }
+  });
+
+page
+  .command('restore <pageId>')
+  .description('Restore an archived page')
+  .action(async (pageId) => {
+    try {
+      await withSpinner('Restoring page...', () =>
+        client.post(`/pages/${pageId}/restore`)
+      );
+      success(`Restored page ${pageId}`);
+    } catch (err) {
+      error(`Failed to restore page: ${err.message}`);
+    }
+  });
+
+page
+  .command('share <pageId>')
+  .description('Manage page sharing')
+  .option('--public', 'Make page publicly accessible')
+  .option('--revoke', 'Revoke public access')
+  .option('-u, --user <userId>', 'Share with a specific user')
+  .option('--role <role>', 'Role for shared user (editor|viewer)', 'viewer')
+  .action(async (pageId, options) => {
+    try {
+      if (options.revoke) {
+        await withSpinner('Revoking share...', () =>
+          client.post(`/pages/${pageId}/share/revoke`)
+        );
+        success('Public sharing revoked');
+      } else if (options.public) {
+        const data = await withSpinner('Enabling public share...', () =>
+          client.post(`/pages/${pageId}/share/public`)
+        );
+        const link = data.shareLink || data.link || data.data;
+        success(`Page shared publicly${link ? `: ${chalk.bold(link)}` : ''}`);
+      } else if (options.user) {
+        await withSpinner('Sharing with user...', () =>
+          client.post(`/pages/${pageId}/share/user`, {
+            userId: options.user,
+            role: options.role,
+          })
+        );
+        success(`Shared page with user (${options.role})`);
+      } else {
+        return error('Provide --public, --revoke, or -u <userId>.');
+      }
+    } catch (err) {
+      error(`Failed to share page: ${err.message}`);
+    }
+  });
+
+page
+  .command('members <pageId>')
+  .description('List page members')
+  .option('-f, --format <format>', 'Output format')
+  .action(async (pageId, options) => {
+    try {
+      const data = await withSpinner('Fetching members...', () =>
+        client.get(`/pages/${pageId}/members`)
+      );
+
+      const members = data.members || data.data || data;
+      const rows = (Array.isArray(members) ? members : []).map(m => {
+        const user = m.user || m;
+        return {
+          name: user.userName || user.username || user.name || 'N/A',
+          email: user.email || 'N/A',
+          role: m.role || 'viewer',
+          id: user._id || user.id || '',
+        };
+      });
+
+      output(rows, {
+        headers: ['Name', 'Email', 'Role', 'ID'],
+        format: options.format,
+      });
+    } catch (err) {
+      error(`Failed to list members: ${err.message}`);
+    }
+  });
+
+page
+  .command('add-member <pageId>')
+  .description('Add a member to a page')
+  .option('-u, --user <userId>', 'User ID (required)')
+  .option('--role <role>', 'Role (editor|viewer)', 'viewer')
+  .action(async (pageId, options) => {
+    try {
+      if (!options.user) return error('User ID is required. Use -u <userId>.');
+
+      await withSpinner('Adding member...', () =>
+        client.post(`/pages/${pageId}/members`, {
+          userId: options.user,
+          role: options.role,
+        })
+      );
+      success(`Added member to page ${pageId}`);
+    } catch (err) {
+      error(`Failed to add member: ${err.message}`);
+    }
+  });
+
+page
+  .command('remove-member <pageId>')
+  .description('Remove a member from a page')
+  .option('-u, --user <userId>', 'User/member ID (required)')
+  .action(async (pageId, options) => {
+    try {
+      if (!options.user) return error('User ID is required. Use -u <userId>.');
+
+      await withSpinner('Removing member...', () =>
+        client.delete(`/pages/${pageId}/members/${options.user}`)
+      );
+      success('Removed member from page');
+    } catch (err) {
+      error(`Failed to remove member: ${err.message}`);
+    }
+  });
+
+page
+  .command('comments <pageId>')
+  .description('List comments on a page')
+  .option('-f, --format <format>', 'Output format')
+  .action(async (pageId, options) => {
+    try {
+      const data = await withSpinner('Fetching comments...', () =>
+        client.get(`/pages/${pageId}/comments`)
+      );
+
+      const { formatRelativeTime } = require('../utils/format');
+      const comments = data.comments || data.data || data;
+      const rows = (Array.isArray(comments) ? comments : []).map(c => ({
+        user: c.user?.userName || c.member?.userName || 'N/A',
+        comment: (c.comment || c.text || '').substring(0, 80),
+        time: formatRelativeTime(c.createdAt),
+        id: c._id,
+      }));
+
+      output(rows, {
+        headers: ['User', 'Comment', 'Time', 'ID'],
+        format: options.format,
+      });
+    } catch (err) {
+      error(`Failed to list comments: ${err.message}`);
+    }
+  });
+
+page
+  .command('comment <pageId> <text>')
+  .description('Add a comment to a page')
+  .action(async (pageId, text) => {
+    try {
+      await withSpinner('Adding comment...', () =>
+        client.post(`/pages/${pageId}/comments`, { comment: text })
+      );
+      success('Comment added');
+    } catch (err) {
+      error(`Failed to add comment: ${err.message}`);
+    }
+  });
+
+page
+  .command('duplicate <pageId>')
+  .description('Duplicate a page')
+  .action(async (pageId) => {
+    try {
+      const data = await withSpinner('Duplicating page...', () =>
+        client.post(`/pages/${pageId}/duplicate`)
+      );
+      const p = data.page || data.data || data;
+      success(`Duplicated page: ${chalk.bold(p.title || 'Copy')} (${p.shortId || p._id})`);
+    } catch (err) {
+      error(`Failed to duplicate page: ${err.message}`);
+    }
+  });
+
+page
+  .command('favorite <pageId>')
+  .description('Toggle favorite on a page')
+  .action(async (pageId) => {
+    try {
+      const data = await withSpinner('Toggling favorite...', () =>
+        client.post(`/pages/${pageId}/favorite`)
+      );
+      success(data.message || 'Favorite toggled');
+    } catch (err) {
+      error(`Failed to toggle favorite: ${err.message}`);
+    }
+  });
+
 module.exports = page;

package/src/commands/timer.js

@@ -0,0 +1,234 @@
+const { Command } = require('commander');
+const chalk = require('chalk');
+const client = require('../lib/client');
+const { output, success, error } = require('../lib/output');
+const { withSpinner } = require('../utils/spinner');
+const { formatDuration, formatRelativeTime } = require('../utils/format');
+
+const timer = new Command('timer')
+  .alias('t')
+  .description('Card timer management commands');
+
+timer
+  .command('start <cardId>')
+  .description('Start a timer on a card')
+  .option('--mode <mode>', 'Timer mode (stopwatch|pomodoro)', 'stopwatch')
+  .action(async (cardId, options) => {
+    try {
+      await withSpinner('Starting timer...', () =>
+        client.post(`/timers/cards/${cardId}/timer/start`, { mode: options.mode })
+      );
+      success(`Timer started on card ${cardId} (${options.mode} mode)`);
+    } catch (err) {
+      error(`Failed to start timer: ${err.message}`);
+    }
+  });
+
+timer
+  .command('pause <cardId>')
+  .description('Pause a running timer')
+  .action(async (cardId) => {
+    try {
+      await withSpinner('Pausing timer...', () =>
+        client.post(`/timers/cards/${cardId}/timer/pause`)
+      );
+      success('Timer paused');
+    } catch (err) {
+      error(`Failed to pause timer: ${err.message}`);
+    }
+  });
+
+timer
+  .command('resume <cardId>')
+  .description('Resume a paused timer')
+  .action(async (cardId) => {
+    try {
+      await withSpinner('Resuming timer...', () =>
+        client.post(`/timers/cards/${cardId}/timer/resume`)
+      );
+      success('Timer resumed');
+    } catch (err) {
+      error(`Failed to resume timer: ${err.message}`);
+    }
+  });
+
+timer
+  .command('stop <cardId>')
+  .description('Stop a timer and save the session')
+  .action(async (cardId) => {
+    try {
+      const data = await withSpinner('Stopping timer...', () =>
+        client.post(`/timers/cards/${cardId}/timer/stop`)
+      );
+      const duration = data.duration || data.elapsed;
+      success(`Timer stopped${duration ? ` — ${formatDuration(duration)}` : ''}`);
+    } catch (err) {
+      error(`Failed to stop timer: ${err.message}`);
+    }
+  });
+
+timer
+  .command('reset <cardId>')
+  .description('Reset a timer')
+  .action(async (cardId) => {
+    try {
+      await withSpinner('Resetting timer...', () =>
+        client.post(`/timers/cards/${cardId}/timer/reset`)
+      );
+      success('Timer reset');
+    } catch (err) {
+      error(`Failed to reset timer: ${err.message}`);
+    }
+  });
+
+timer
+  .command('mode <cardId> <mode>')
+  .description('Switch timer mode (stopwatch|pomodoro)')
+  .action(async (cardId, mode) => {
+    try {
+      await withSpinner('Switching mode...', () =>
+        client.post(`/timers/cards/${cardId}/timer/mode`, { mode })
+      );
+      success(`Timer mode set to ${chalk.bold(mode)}`);
+    } catch (err) {
+      error(`Failed to switch mode: ${err.message}`);
+    }
+  });
+
+timer
+  .command('get <cardId>')
+  .description('Get current timer state for a card')
+  .action(async (cardId) => {
+    try {
+      const data = await withSpinner('Fetching timer...', () =>
+        client.get(`/timers/cards/${cardId}/timer`)
+      );
+
+      const t = data.timer || data.data || data;
+      console.log();
+      console.log(chalk.bold('  Status:   '), t.status || t.state || 'none');
+      console.log(chalk.bold('  Mode:     '), t.mode || 'stopwatch');
+      console.log(chalk.bold('  Elapsed:  '), t.elapsed ? formatDuration(t.elapsed) : '0s');
+      if (t.startedAt) {
+        console.log(chalk.bold('  Started:  '), formatRelativeTime(t.startedAt));
+      }
+      console.log();
+    } catch (err) {
+      error(`Failed to get timer: ${err.message}`);
+    }
+  });
+
+timer
+  .command('sessions <cardId>')
+  .description('List timer sessions for a card')
+  .option('-f, --format <format>', 'Output format')
+  .action(async (cardId, options) => {
+    try {
+      const data = await withSpinner('Fetching sessions...', () =>
+        client.get(`/timers/cards/${cardId}/timer/sessions`)
+      );
+
+      const sessions = data.sessions || data.data || data;
+      const rows = (Array.isArray(sessions) ? sessions : []).map(s => ({
+        date: s.startedAt ? new Date(s.startedAt).toLocaleDateString() : '-',
+        duration: s.duration ? formatDuration(s.duration) : '-',
+        mode: s.mode || 'stopwatch',
+        id: s._id,
+      }));
+
+      output(rows, {
+        headers: ['Date', 'Duration', 'Mode', 'ID'],
+        format: options.format,
+      });
+    } catch (err) {
+      error(`Failed to list sessions: ${err.message}`);
+    }
+  });
+
+timer
+  .command('status')
+  .description('Show overall timer status')
+  .action(async () => {
+    try {
+      const data = await withSpinner('Fetching status...', () =>
+        client.get('/timers/status')
+      );
+
+      const status = data.status || data.data || data;
+      console.log();
+      if (status.activeCard) {
+        console.log(chalk.bold('  Active Card: '), status.activeCard.title || status.activeCard);
+        console.log(chalk.bold('  Elapsed:     '), status.elapsed ? formatDuration(status.elapsed) : '0s');
+        console.log(chalk.bold('  Mode:        '), status.mode || 'stopwatch');
+      } else {
+        console.log('  No active timer');
+      }
+      console.log();
+    } catch (err) {
+      error(`Failed to get status: ${err.message}`);
+    }
+  });
+
+timer
+  .command('running')
+  .description('Show all running timers')
+  .option('-f, --format <format>', 'Output format')
+  .action(async (options) => {
+    try {
+      const data = await withSpinner('Fetching running timers...', () =>
+        client.get('/timers/running')
+      );
+
+      const timers = data.timers || data.data || data;
+      const rows = (Array.isArray(timers) ? timers : []).map(t => ({
+        card: t.card?.title || t.cardId || 'N/A',
+        elapsed: t.elapsed ? formatDuration(t.elapsed) : '-',
+        mode: t.mode || 'stopwatch',
+        started: t.startedAt ? formatRelativeTime(t.startedAt) : '-',
+      }));
+
+      output(rows, {
+        headers: ['Card', 'Elapsed', 'Mode', 'Started'],
+        format: options.format,
+      });
+    } catch (err) {
+      error(`Failed to list running timers: ${err.message}`);
+    }
+  });
+
+timer
+  .command('stats')
+  .description('Show timer statistics')
+  .action(async () => {
+    try {
+      const data = await withSpinner('Fetching stats...', () =>
+        client.get('/timers/sessions/stats')
+      );
+
+      const stats = data.stats || data.data || data;
+      console.log();
+      console.log(chalk.bold('  Total Sessions: '), stats.totalSessions || 0);
+      console.log(chalk.bold('  Total Time:     '), stats.totalTime ? formatDuration(stats.totalTime) : '0s');
+      console.log(chalk.bold('  Avg Session:    '), stats.avgDuration ? formatDuration(stats.avgDuration) : '0s');
+      console.log(chalk.bold('  This Week:      '), stats.thisWeek ? formatDuration(stats.thisWeek) : '0s');
+      console.log();
+    } catch (err) {
+      error(`Failed to get stats: ${err.message}`);
+    }
+  });
+
+timer
+  .command('delete <cardId>')
+  .description('Delete all timer data for a card')
+  .action(async (cardId) => {
+    try {
+      await withSpinner('Deleting timer...', () =>
+        client.delete(`/timers/card/${cardId}`)
+      );
+      success('Timer data deleted');
+    } catch (err) {
+      error(`Failed to delete timer: ${err.message}`);
+    }
+  });
+
+module.exports = timer;

package/src/commands/webhook.js

@@ -0,0 +1,141 @@
+const { Command } = require('commander');
+const chalk = require('chalk');
+const client = require('../lib/client');
+const { output, success, error } = require('../lib/output');
+const { withSpinner } = require('../utils/spinner');
+const { confirmAction } = require('../utils/prompts');
+const { formatRelativeTime } = require('../utils/format');
+
+const webhook = new Command('webhook')
+  .alias('wh')
+  .description('Webhook management commands');
+
+webhook
+  .command('list')
+  .alias('ls')
+  .description('List webhooks')
+  .option('-f, --format <format>', 'Output format')
+  .action(async (options) => {
+    try {
+      const data = await withSpinner('Fetching webhooks...', () =>
+        client.get('/webhooks')
+      );
+
+      const webhooks = data.webhooks || data.data || data;
+      const rows = (Array.isArray(webhooks) ? webhooks : []).map(w => ({
+        name: w.name || w.description || 'Unnamed',
+        url: (w.url || '').substring(0, 50),
+        events: (w.events || []).join(', ') || 'all',
+        status: w.active !== false ? chalk.green('active') : chalk.yellow('inactive'),
+        id: w._id,
+      }));
+
+      output(rows, {
+        headers: ['Name', 'URL', 'Events', 'Status', 'ID'],
+        format: options.format,
+      });
+    } catch (err) {
+      error(`Failed to list webhooks: ${err.message}`);
+    }
+  });
+
+webhook
+  .command('create')
+  .description('Create a webhook')
+  .option('--url <url>', 'Webhook URL (required)')
+  .option('--events <events>', 'Comma-separated event types')
+  .option('--name <name>', 'Webhook name')
+  .action(async (options) => {
+    try {
+      if (!options.url) return error('URL is required. Use --url <url>.');
+
+      const body = { url: options.url };
+      if (options.name) body.name = options.name;
+      if (options.events) body.events = options.events.split(',').map(e => e.trim());
+
+      const data = await withSpinner('Creating webhook...', () =>
+        client.post('/webhooks', body)
+      );
+
+      const w = data.webhook || data.data || data;
+      success(`Created webhook: ${chalk.bold(options.name || options.url)} (${w._id})`);
+    } catch (err) {
+      error(`Failed to create webhook: ${err.message}`);
+    }
+  });
+
+webhook
+  .command('update <webhookId>')
+  .description('Update a webhook')
+  .option('--url <url>', 'New URL')
+  .option('--events <events>', 'Comma-separated event types')
+  .option('--name <name>', 'New name')
+  .action(async (webhookId, options) => {
+    try {
+      const body = {};
+      if (options.url) body.url = options.url;
+      if (options.name) body.name = options.name;
+      if (options.events) body.events = options.events.split(',').map(e => e.trim());
+      if (Object.keys(body).length === 0) return error('Provide --url, --events, or --name.');
+
+      await withSpinner('Updating webhook...', () =>
+        client.put(`/webhooks/${webhookId}`, body)
+      );
+      success(`Updated webhook ${webhookId}`);
+    } catch (err) {
+      error(`Failed to update webhook: ${err.message}`);
+    }
+  });
+
+webhook
+  .command('delete <webhookId>')
+  .description('Delete a webhook')
+  .option('--force', 'Skip confirmation')
+  .action(async (webhookId, options) => {
+    try {
+      if (!options.force) {
+        const confirmed = await confirmAction('Delete this webhook?');
+        if (!confirmed) return;
+      }
+
+      await withSpinner('Deleting webhook...', () =>
+        client.delete(`/webhooks/${webhookId}`)
+      );
+      success('Deleted webhook');
+    } catch (err) {
+      error(`Failed to delete webhook: ${err.message}`);
+    }
+  });
+
+webhook
+  .command('logs <webhookId>')
+  .description('Show webhook delivery logs')
+  .option('--limit <n>', 'Number of logs', '20')
+  .option('-f, --format <format>', 'Output format')
+  .action(async (webhookId, options) => {
+    try {
+      const data = await withSpinner('Fetching delivery logs...', () =>
+        client.get(`/webhooks/${webhookId}/deliveries`)
+      );
+
+      const deliveries = data.deliveries || data.data || data;
+      const delArr = Array.isArray(deliveries) ? deliveries : [];
+      const limited = delArr.slice(0, parseInt(options.limit));
+
+      const rows = limited.map(d => ({
+        event: d.event || d.type || 'N/A',
+        status: d.statusCode ? (d.statusCode < 400 ? chalk.green(d.statusCode) : chalk.red(d.statusCode)) : '-',
+        response: (d.response || d.body || '').substring(0, 40) || '-',
+        time: formatRelativeTime(d.createdAt || d.deliveredAt),
+      }));
+
+      output(rows, {
+        headers: ['Event', 'Status', 'Response', 'Time'],
+        format: options.format,
+      });
+    } catch (err) {
+      error(`Failed to fetch delivery logs: ${err.message}`);
+    }
+  });
+
+module.exports = webhook;