@zoobbe/cli 1.1.1 → 1.2.1

package/src/commands/list.js

@@ -0,0 +1,213 @@
+const { Command } = require('commander');
+const chalk = require('chalk');
+const config = require('../lib/config');
+const client = require('../lib/client');
+const { output, success, error } = require('../lib/output');
+const { withSpinner } = require('../utils/spinner');
+const { confirmAction } = require('../utils/prompts');
+
+const list = new Command('list')
+  .alias('l')
+  .description('Action list (column) management commands');
+
+list
+  .command('ls')
+  .description('List all lists on a board')
+  .option('-b, --board <boardId>', 'Board ID (required)')
+  .option('-a, --all', 'Include archived lists')
+  .option('-f, --format <format>', 'Output format')
+  .action(async (options) => {
+    try {
+      if (!options.board) return error('Board ID is required. Use -b <boardId>.');
+
+      const data = await withSpinner('Fetching lists...', () =>
+        client.get(`/${options.board}/actionLists/`)
+      );
+
+      let lists = data.lists || data.data || data;
+      lists = Array.isArray(lists) ? lists : Object.values(lists);
+      if (!options.all) {
+        lists = lists.filter(l => !l.archived);
+      }
+
+      const rows = lists.map(l => ({
+        title: l.title || 'Untitled',
+        id: l._id,
+        cards: String(l.cards?.length || 0),
+        color: l.color || '-',
+        status: l.archived ? chalk.yellow('archived') : chalk.green('active'),
+      }));
+
+      output(rows, {
+        headers: ['Title', 'ID', 'Cards', 'Color', 'Status'],
+        format: options.format,
+      });
+    } catch (err) {
+      error(`Failed to list lists: ${err.message}`);
+    }
+  });
+
+list
+  .command('create <title>')
+  .description('Create a new list on a board')
+  .option('-b, --board <boardId>', 'Board ID (required)')
+  .action(async (title, options) => {
+    try {
+      if (!options.board) return error('Board ID is required. Use -b <boardId>.');
+
+      const data = await withSpinner('Creating list...', () =>
+        client.post('/actionLists', { title, boardId: options.board })
+      );
+
+      const l = data.actionList || data.data || data;
+      success(`Created list: ${chalk.bold(title)} (${l._id})`);
+    } catch (err) {
+      error(`Failed to create list: ${err.message}`);
+    }
+  });
+
+list
+  .command('update <listId>')
+  .description('Update a list')
+  .option('-t, --title <title>', 'New title')
+  .option('--color <color>', 'List color (hex)')
+  .option('--text-color <color>', 'Text color (hex)')
+  .action(async (listId, options) => {
+    try {
+      const body = {};
+      if (options.title) body.title = options.title;
+      if (options.color) body.color = options.color;
+      if (options.textColor) body.textColor = options.textColor;
+
+      if (Object.keys(body).length === 0) {
+        return error('Provide at least one option: -t, --color, or --text-color.');
+      }
+
+      await withSpinner('Updating list...', () =>
+        client.put(`/actionLists/${listId}`, body)
+      );
+      success(`Updated list ${listId}`);
+    } catch (err) {
+      error(`Failed to update list: ${err.message}`);
+    }
+  });
+
+list
+  .command('delete <listId>')
+  .description('Delete a list and all its cards')
+  .option('--force', 'Skip confirmation')
+  .action(async (listId, options) => {
+    try {
+      if (!options.force) {
+        const confirmed = await confirmAction('This will delete the list and all its cards. Continue?');
+        if (!confirmed) return;
+      }
+
+      await withSpinner('Deleting list...', () =>
+        client.delete(`/actionLists/${listId}`)
+      );
+      success(`Deleted list ${listId}`);
+    } catch (err) {
+      error(`Failed to delete list: ${err.message}`);
+    }
+  });
+
+list
+  .command('archive <listId>')
+  .description('Archive or unarchive a list')
+  .option('--unarchive', 'Unarchive the list')
+  .action(async (listId, options) => {
+    try {
+      const archived = !options.unarchive;
+      await withSpinner(archived ? 'Archiving list...' : 'Unarchiving list...', () =>
+        client.put(`/actionLists/archive/${listId}`, { archivedStatus: archived })
+      );
+      success(archived ? `Archived list ${listId}` : `Unarchived list ${listId}`);
+    } catch (err) {
+      error(`Failed to archive list: ${err.message}`);
+    }
+  });
+
+list
+  .command('archive-cards <listId>')
+  .description('Archive all cards in a list')
+  .option('--force', 'Skip confirmation')
+  .action(async (listId, options) => {
+    try {
+      if (!options.force) {
+        const confirmed = await confirmAction('Archive all cards in this list?');
+        if (!confirmed) return;
+      }
+
+      await withSpinner('Archiving cards...', () =>
+        client.post(`/actionLists/${listId}/cards/archived`)
+      );
+      success(`Archived all cards in list ${listId}`);
+    } catch (err) {
+      error(`Failed to archive cards: ${err.message}`);
+    }
+  });
+
+list
+  .command('copy <listId>')
+  .description('Copy a list with all its cards')
+  .option('-t, --title <title>', 'Title for the copy')
+  .action(async (listId, options) => {
+    try {
+      const body = {};
+      if (options.title) body.newTitle = options.title;
+
+      const data = await withSpinner('Copying list...', () =>
+        client.post(`/actionLists/${listId}/copy`, body)
+      );
+      const copied = data.copiedList || data.data || data;
+      success(`Copied list to: ${chalk.bold(copied.title || 'Copy')}`);
+    } catch (err) {
+      error(`Failed to copy list: ${err.message}`);
+    }
+  });
+
+list
+  .command('watch <listId>')
+  .description('Toggle watch on a list')
+  .action(async (listId) => {
+    try {
+      const data = await withSpinner('Toggling watch...', () =>
+        client.post(`/actionLists/${listId}/watch`)
+      );
+      success(data.message || 'Watch toggled');
+    } catch (err) {
+      error(`Failed to toggle watch: ${err.message}`);
+    }
+  });
+
+list
+  .command('archived')
+  .description('Show archived lists for a board')
+  .option('-b, --board <boardId>', 'Board ID (required)')
+  .option('-f, --format <format>', 'Output format')
+  .action(async (options) => {
+    try {
+      if (!options.board) return error('Board ID is required. Use -b <boardId>.');
+
+      const data = await withSpinner('Fetching archived lists...', () =>
+        client.get(`/${options.board}/lists/archived/`)
+      );
+
+      const lists = data.lists || data.data || data;
+      const rows = (Array.isArray(lists) ? lists : []).map(l => ({
+        title: l.title || 'Untitled',
+        id: l._id,
+        cards: String(l.cards?.length || 0),
+      }));
+
+      output(rows, {
+        headers: ['Title', 'ID', 'Cards'],
+        format: options.format,
+      });
+    } catch (err) {
+      error(`Failed to fetch archived lists: ${err.message}`);
+    }
+  });
+
+module.exports = list;

package/src/commands/notification.js

@@ -0,0 +1,92 @@
+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 { formatRelativeTime } = require('../utils/format');
+
+const notification = new Command('notification')
+  .alias('n')
+  .description('Notification management commands');
+
+notification
+  .command('list')
+  .alias('ls')
+  .description('List notifications')
+  .option('--limit <n>', 'Number of notifications', '20')
+  .option('--unread', 'Show only unread notifications')
+  .option('-f, --format <format>', 'Output format')
+  .action(async (options) => {
+    try {
+      let url = `/notifications?limit=${options.limit}`;
+      if (options.unread) url += '&unread=true';
+
+      const data = await withSpinner('Fetching notifications...', () =>
+        client.get(url)
+      );
+
+      const notifications = data.notifications || data.data || data;
+      const rows = (Array.isArray(notifications) ? notifications : []).map(n => ({
+        type: n.type || n.action || 'notification',
+        message: (n.message || n.text || '').substring(0, 60),
+        read: n.read ? chalk.gray('read') : chalk.blue('unread'),
+        time: formatRelativeTime(n.createdAt),
+        id: n._id,
+      }));
+
+      output(rows, {
+        headers: ['Type', 'Message', 'Status', 'Time', 'ID'],
+        format: options.format,
+      });
+    } catch (err) {
+      error(`Failed to list notifications: ${err.message}`);
+    }
+  });
+
+notification
+  .command('count')
+  .description('Show unread notification count')
+  .action(async () => {
+    try {
+      const data = await withSpinner('Fetching count...', () =>
+        client.get('/notifications/count')
+      );
+
+      const count = data.count ?? data.unread ?? data.data ?? 0;
+      console.log();
+      console.log(`  ${chalk.bold('Unread notifications:')} ${count}`);
+      console.log();
+    } catch (err) {
+      error(`Failed to get notification count: ${err.message}`);
+    }
+  });
+
+notification
+  .command('read <notificationId>')
+  .description('Mark a notification as read')
+  .action(async (notificationId) => {
+    try {
+      await withSpinner('Marking as read...', () =>
+        client.put(`/notifications/${notificationId}`)
+      );
+      success('Notification marked as read');
+    } catch (err) {
+      error(`Failed to mark notification: ${err.message}`);
+    }
+  });
+
+notification
+  .command('read-all')
+  .description('Mark all notifications as read')
+  .action(async () => {
+    try {
+      await withSpinner('Marking all as read...', () =>
+        client.put('/notifications/mark-all-read')
+      );
+      success('All notifications marked as read');
+    } catch (err) {
+      error(`Failed to mark all: ${err.message}`);
+    }
+  });
+
+module.exports = notification;

package/src/commands/page.js

@@ -67,8 +67,7 @@ page
   .action(async (pageId) => {
     try {
       const open = require('open');
-      const apiUrl = config.get('apiUrl');
-      const baseUrl = apiUrl.replace('api.', '');
+      const baseUrl = config.getWebUrl();
       await open(`${baseUrl}/page/${pageId}`);
       success('Opened page in browser');
     } catch (err) {
@@ -99,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;