@zoobbe/cli 1.2.0 → 1.2.2

package/src/commands/board.js

@@ -160,4 +160,299 @@ board
     }
   });
 
+// ── Extended commands ──
+
+const { confirmAction } = require('../utils/prompts');
+const { resolveBoard } = require('../utils/resolve');
+const { formatRelativeTime } = require('../utils/format');
+
+board
+  .command('delete <nameOrId>')
+  .description('Permanently delete a board')
+  .option('--force', 'Skip confirmation')
+  .action(async (nameOrId, options) => {
+    try {
+      const workspaceId = config.get('activeWorkspace');
+      if (!workspaceId) return error('No active workspace.');
+
+      const match = await resolveBoard(nameOrId, workspaceId);
+      if (!match) return error(`Board "${nameOrId}" not found.`);
+
+      if (!options.force) {
+        const confirmed = await confirmAction(`Permanently delete "${match.title || match.name}" and all its data?`);
+        if (!confirmed) return;
+      }
+
+      await withSpinner('Deleting board...', () =>
+        client.post(`/boards/delete/${match.shortId}`)
+      );
+      success(`Deleted board: ${chalk.bold(match.title || match.name)}`);
+    } catch (err) {
+      error(`Failed to delete board: ${err.message}`);
+    }
+  });
+
+board
+  .command('restore <nameOrId>')
+  .description('Restore an archived board')
+  .action(async (nameOrId) => {
+    try {
+      const workspaceId = config.get('activeWorkspace');
+      if (!workspaceId) return error('No active workspace.');
+
+      const match = await resolveBoard(nameOrId, workspaceId);
+      if (!match) return error(`Board "${nameOrId}" not found.`);
+
+      await withSpinner('Restoring board...', () =>
+        client.post(`/boards/archive/${match.shortId}`)
+      );
+      success(`Restored board: ${chalk.bold(match.title || match.name)}`);
+    } catch (err) {
+      error(`Failed to restore board: ${err.message}`);
+    }
+  });
+
+board
+  .command('update <nameOrId>')
+  .description('Update board title or description')
+  .option('-t, --title <title>', 'New title')
+  .option('-d, --description <desc>', 'New description')
+  .action(async (nameOrId, options) => {
+    try {
+      const body = {};
+      if (options.title) body.title = options.title;
+      if (options.description) body.description = options.description;
+      if (Object.keys(body).length === 0) return error('Provide -t or -d.');
+
+      await withSpinner('Updating board...', () =>
+        client.put(`/boards/${nameOrId}`, body)
+      );
+      success(`Updated board ${nameOrId}`);
+    } catch (err) {
+      error(`Failed to update board: ${err.message}`);
+    }
+  });
+
+board
+  .command('members <nameOrId>')
+  .description('List board members')
+  .option('-f, --format <format>', 'Output format')
+  .action(async (nameOrId, options) => {
+    try {
+      const data = await withSpinner('Fetching members...', () =>
+        client.get(`/boards/${nameOrId}/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 || 'member',
+          id: user._id || user.id || '',
+        };
+      });
+
+      output(rows, {
+        headers: ['Name', 'Email', 'Role', 'ID'],
+        format: options.format,
+      });
+    } catch (err) {
+      error(`Failed to list members: ${err.message}`);
+    }
+  });
+
+board
+  .command('add-member <nameOrId>')
+  .description('Add a member to a board')
+  .option('-u, --user <userId>', 'User ID (required)')
+  .option('--role <role>', 'Role (admin|member|viewer)', 'member')
+  .action(async (nameOrId, options) => {
+    try {
+      if (!options.user) return error('User ID is required. Use -u <userId>.');
+
+      await withSpinner('Adding member...', () =>
+        client.post(`/boards/${nameOrId}/member`, {
+          userId: options.user,
+          role: options.role,
+        })
+      );
+      success(`Added member to board ${nameOrId}`);
+    } catch (err) {
+      error(`Failed to add member: ${err.message}`);
+    }
+  });
+
+board
+  .command('remove-member <nameOrId>')
+  .description('Remove a member from a board')
+  .option('-u, --user <userId>', 'User ID (required)')
+  .action(async (nameOrId, options) => {
+    try {
+      if (!options.user) return error('User ID is required. Use -u <userId>.');
+
+      await withSpinner('Removing member...', () =>
+        client.delete(`/boards/${nameOrId}/member`, { userId: options.user })
+      );
+      success(`Removed member from board ${nameOrId}`);
+    } catch (err) {
+      error(`Failed to remove member: ${err.message}`);
+    }
+  });
+
+board
+  .command('invite <nameOrId>')
+  .description('Invite a user to a board by email')
+  .option('-e, --email <email>', 'Email address (required)')
+  .option('--role <role>', 'Role (admin|member|viewer)', 'member')
+  .action(async (nameOrId, options) => {
+    try {
+      if (!options.email) return error('Email is required. Use -e <email>.');
+
+      await withSpinner('Sending invitation...', () =>
+        client.post(`/boards/${nameOrId}/invite`, {
+          email: options.email,
+          role: options.role,
+        })
+      );
+      success(`Invitation sent to ${chalk.bold(options.email)}`);
+    } catch (err) {
+      error(`Failed to invite: ${err.message}`);
+    }
+  });
+
+board
+  .command('join-link <nameOrId>')
+  .description('Generate or manage a board join link')
+  .option('--delete', 'Delete the existing join link')
+  .action(async (nameOrId, options) => {
+    try {
+      if (options.delete) {
+        await withSpinner('Deleting join link...', () =>
+          client.delete(`/boards/${nameOrId}/delete-join-link`)
+        );
+        success('Join link deleted');
+      } else {
+        const data = await withSpinner('Generating join link...', () =>
+          client.post(`/boards/${nameOrId}/generate-join-link`)
+        );
+        const link = data.joinLink || data.link || data.data;
+        success(`Join link: ${chalk.bold(link)}`);
+      }
+    } catch (err) {
+      error(`Failed to manage join link: ${err.message}`);
+    }
+  });
+
+board
+  .command('labels <nameOrId>')
+  .description('List labels on a board')
+  .option('-f, --format <format>', 'Output format')
+  .action(async (nameOrId, options) => {
+    try {
+      const data = await withSpinner('Fetching labels...', () =>
+        client.get(`/boards/${nameOrId}/labels`)
+      );
+
+      const labels = data.labels || data.data || data;
+      const rows = (Array.isArray(labels) ? labels : []).map(l => ({
+        text: l.text || '-',
+        color: l.color || '-',
+        id: l._id,
+      }));
+
+      output(rows, {
+        headers: ['Text', 'Color', 'ID'],
+        format: options.format,
+      });
+    } catch (err) {
+      error(`Failed to list labels: ${err.message}`);
+    }
+  });
+
+board
+  .command('label-create <nameOrId>')
+  .description('Create a label on a board')
+  .option('--text <text>', 'Label text')
+  .option('--color <color>', 'Label color')
+  .action(async (nameOrId, options) => {
+    try {
+      if (!options.text && !options.color) return error('Provide --text or --color.');
+
+      const data = await withSpinner('Creating label...', () =>
+        client.post(`/boards/${nameOrId}/labels`, {
+          text: options.text || '',
+          color: options.color || '',
+        })
+      );
+      const l = data.label || data.data || data;
+      success(`Created label: ${chalk.bold(options.text || options.color)} (${l._id})`);
+    } catch (err) {
+      error(`Failed to create label: ${err.message}`);
+    }
+  });
+
+board
+  .command('label-delete <nameOrId>')
+  .description('Delete a label from a board')
+  .option('--label <labelId>', 'Label ID (required)')
+  .action(async (nameOrId, options) => {
+    try {
+      if (!options.label) return error('Label ID is required. Use --label <labelId>.');
+
+      await withSpinner('Deleting label...', () =>
+        client.delete(`/boards/${nameOrId}/labels/${options.label}`)
+      );
+      success('Deleted label');
+    } catch (err) {
+      error(`Failed to delete label: ${err.message}`);
+    }
+  });
+
+board
+  .command('visibility <nameOrId> <level>')
+  .description('Change board visibility (Private|Public|Workspace)')
+  .action(async (nameOrId, level) => {
+    try {
+      await withSpinner('Updating visibility...', () =>
+        client.put(`/boards/${nameOrId}/visibility`, { visibility: level })
+      );
+      success(`Board visibility set to ${chalk.bold(level)}`);
+    } catch (err) {
+      error(`Failed to update visibility: ${err.message}`);
+    }
+  });
+
+board
+  .command('activities <nameOrId>')
+  .description('Show board activity log')
+  .option('--limit <n>', 'Number of activities', '20')
+  .option('-f, --format <format>', 'Output format')
+  .action(async (nameOrId, options) => {
+    try {
+      const data = await withSpinner('Fetching activities...', () =>
+        client.get(`/boards/${nameOrId}/activities`)
+      );
+
+      const activities = data.activities || data.data || data;
+      const actArr = Array.isArray(activities) ? activities : [];
+      const limited = actArr.slice(0, parseInt(options.limit));
+
+      const rows = limited.map(a => ({
+        action: a.action || a.type || 'unknown',
+        user: a.user?.userName || a.user?.name || 'N/A',
+        target: a.target || a.card?.title || '',
+        time: formatRelativeTime(a.createdAt),
+      }));
+
+      output(rows, {
+        headers: ['Action', 'User', 'Target', 'Time'],
+        format: options.format,
+      });
+    } catch (err) {
+      error(`Failed to fetch activities: ${err.message}`);
+    }
+  });
+
 module.exports = board;

package/src/commands/card.js

@@ -255,6 +255,78 @@ card
     }
   });
 
+card
+  .command('label <cardId>')
+  .description('Add or remove a label on a card')
+  .option('-b, --board <boardId>', 'Board ID (auto-detected from card if not specified)')
+  .option('-r, --remove', 'Remove the label instead of adding it')
+  .action(async (cardId, options) => {
+    try {
+      // Fetch card to get board info
+      const cardData = await withSpinner('Fetching card...', () =>
+        client.get(`/cards/${cardId}`)
+      );
+      const c = cardData.card || cardData.data || cardData;
+      const boardId = options.board || c.boardShortId || c.board;
+
+      if (!boardId) {
+        return error('Could not determine board. Use -b <boardId>.');
+      }
+
+      // Get available labels from the board
+      const labelsData = await client.get(`/boards/${boardId}/labels`);
+      const labels = labelsData.labels || labelsData.data || labelsData;
+      const labelArr = Array.isArray(labels) ? labels : [];
+
+      if (labelArr.length === 0) {
+        return error('No labels found on this board.');
+      }
+
+      // Get current card labels
+      const cardLabelsData = await client.get(`/cards/${cardId}/labels`);
+      const cardLabels = cardLabelsData.labels || cardLabelsData.data || [];
+      const cardLabelIds = new Set(cardLabels.map(l => l._id));
+
+      // Show available labels with status
+      console.log();
+      console.log(chalk.bold('  Available labels:'));
+      labelArr.forEach((l, i) => {
+        const active = cardLabelIds.has(l._id) ? chalk.green(' [active]') : '';
+        const name = l.text || l.color || 'Unnamed';
+        console.log(`  ${i + 1}. ${name}${active}`);
+      });
+      console.log();
+
+      // Prompt user to pick a label
+      const inquirer = require('inquirer');
+      const { labelIndex } = await inquirer.prompt([{
+        type: 'input',
+        name: 'labelIndex',
+        message: options.remove ? 'Label # to remove:' : 'Label # to add:',
+        validate: v => {
+          const n = parseInt(v);
+          return (n >= 1 && n <= labelArr.length) ? true : `Enter 1-${labelArr.length}`;
+        },
+      }]);
+
+      const label = labelArr[parseInt(labelIndex) - 1];
+
+      if (options.remove) {
+        await withSpinner('Removing label...', () =>
+          client.delete(`/cards/${cardId}/labels/${label._id}`)
+        );
+        success(`Removed label "${label.text || label.color}" from card ${cardId}`);
+      } else {
+        await withSpinner('Adding label...', () =>
+          client.put(`/cards/${cardId}/labels/${label._id}`, { boardId })
+        );
+        success(`Added label "${label.text || label.color}" to card ${cardId}`);
+      }
+    } catch (err) {
+      error(`Failed to update label: ${err.message}`);
+    }
+  });
+
 card
   .command('done <cardId>')
   .description('Mark a card as complete')
@@ -299,4 +371,299 @@ card
     }
   });
 
+// ── Extended commands ──
+
+const { confirmAction } = require('../utils/prompts');
+const { formatRelativeTime } = require('../utils/format');
+
+card
+  .command('update <cardId>')
+  .description('Update card title or description')
+  .option('-t, --title <title>', 'New title')
+  .option('-d, --description <desc>', 'New description')
+  .action(async (cardId, options) => {
+    try {
+      const body = {};
+      if (options.title) body.title = options.title;
+      if (options.description) body.description = options.description;
+      if (Object.keys(body).length === 0) return error('Provide -t or -d.');
+
+      await withSpinner('Updating card...', () =>
+        client.post(`/cards/update/${cardId}`, body)
+      );
+      success(`Updated card ${cardId}`);
+    } catch (err) {
+      error(`Failed to update card: ${err.message}`);
+    }
+  });
+
+card
+  .command('archive <cardId>')
+  .description('Archive a card')
+  .action(async (cardId) => {
+    try {
+      await withSpinner('Archiving card...', () =>
+        client.post(`/cards/archive/${cardId}`)
+      );
+      success(`Archived card ${cardId}`);
+    } catch (err) {
+      error(`Failed to archive card: ${err.message}`);
+    }
+  });
+
+card
+  .command('delete <cardId>')
+  .description('Permanently delete a card')
+  .option('--force', 'Skip confirmation')
+  .action(async (cardId, options) => {
+    try {
+      if (!options.force) {
+        const confirmed = await confirmAction('Permanently delete this card and all its data?');
+        if (!confirmed) return;
+      }
+
+      await withSpinner('Deleting card...', () =>
+        client.post(`/cards/delete/${cardId}`)
+      );
+      success(`Deleted card ${cardId}`);
+    } catch (err) {
+      error(`Failed to delete card: ${err.message}`);
+    }
+  });
+
+card
+  .command('copy <cardId>')
+  .description('Copy a card')
+  .option('-l, --list <listId>', 'Target list ID (copies to same list if omitted)')
+  .action(async (cardId, options) => {
+    try {
+      const body = {};
+      if (options.list) body.targetListId = options.list;
+
+      const data = await withSpinner('Copying card...', () =>
+        client.post(`/cards/${cardId}/copy`, body)
+      );
+      const c = data.card || data.data || data;
+      success(`Copied card to: ${chalk.bold(c.title || 'Copy')} (${c.shortId || c._id})`);
+    } catch (err) {
+      error(`Failed to copy card: ${err.message}`);
+    }
+  });
+
+card
+  .command('unassign <cardId>')
+  .description('Remove a user from a card')
+  .option('-u, --user <userId>', 'User ID to remove (required)')
+  .action(async (cardId, options) => {
+    try {
+      if (!options.user) return error('User ID is required. Use -u <userId>.');
+
+      await withSpinner('Removing member...', () =>
+        client.post(`/cards/${cardId}/removeMember`, { memberId: options.user })
+      );
+      success(`Removed user from card ${cardId}`);
+    } catch (err) {
+      error(`Failed to unassign card: ${err.message}`);
+    }
+  });
+
+card
+  .command('members <cardId>')
+  .description('List members assigned to a card')
+  .option('-f, --format <format>', 'Output format')
+  .action(async (cardId, options) => {
+    try {
+      const data = await withSpinner('Fetching members...', () =>
+        client.get(`/cards/${cardId}/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',
+          id: user._id || user.id || '',
+        };
+      });
+
+      output(rows, {
+        headers: ['Name', 'Email', 'ID'],
+        format: options.format,
+      });
+    } catch (err) {
+      error(`Failed to list members: ${err.message}`);
+    }
+  });
+
+card
+  .command('comments <cardId>')
+  .description('List comments on a card')
+  .option('-f, --format <format>', 'Output format')
+  .action(async (cardId, options) => {
+    try {
+      const data = await withSpinner('Fetching comments...', () =>
+        client.get(`/cards/${cardId}/comments`)
+      );
+
+      const comments = data.comments || data.data || data;
+      const rows = (Array.isArray(comments) ? comments : []).map(c => ({
+        user: c.member?.userName || c.user?.userName || 'N/A',
+        comment: (c.comment || '').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}`);
+    }
+  });
+
+card
+  .command('watch <cardId>')
+  .description('Toggle watch on a card')
+  .option('--unwatch', 'Unwatch the card')
+  .action(async (cardId, options) => {
+    try {
+      const data = await withSpinner(options.unwatch ? 'Unwatching...' : 'Watching...', () =>
+        client.post(`/cards/${cardId}/watch`)
+      );
+      success(data.message || 'Watch toggled');
+    } catch (err) {
+      error(`Failed to toggle watch: ${err.message}`);
+    }
+  });
+
+card
+  .command('attachments <cardId>')
+  .description('List attachments on a card')
+  .option('-f, --format <format>', 'Output format')
+  .action(async (cardId, options) => {
+    try {
+      const data = await withSpinner('Fetching attachments...', () =>
+        client.get(`/cards/attachments/${cardId}`)
+      );
+
+      const attachments = data.attachments || data.data || data;
+      const rows = (Array.isArray(attachments) ? attachments : []).map(a => ({
+        name: a.name || a.filename || 'N/A',
+        type: a.type || a.mimetype || '-',
+        size: a.size ? `${Math.round(a.size / 1024)}KB` : '-',
+        id: a._id,
+      }));
+
+      output(rows, {
+        headers: ['Name', 'Type', 'Size', 'ID'],
+        format: options.format,
+      });
+    } catch (err) {
+      error(`Failed to list attachments: ${err.message}`);
+    }
+  });
+
+card
+  .command('attach <cardId> <filePath>')
+  .description('Upload an attachment to a card')
+  .action(async (cardId, filePath) => {
+    try {
+      const fs = require('fs');
+      if (!fs.existsSync(filePath)) {
+        return error(`File not found: ${filePath}`);
+      }
+
+      const data = await withSpinner('Uploading attachment...', () =>
+        client.upload(`/cards/attachments/${cardId}`, filePath)
+      );
+      const a = data.attachment || data.data || data;
+      success(`Uploaded: ${chalk.bold(a.name || a.filename || filePath)}`);
+    } catch (err) {
+      error(`Failed to upload attachment: ${err.message}`);
+    }
+  });
+
+card
+  .command('activities <cardId>')
+  .description('Show card activity log')
+  .option('--limit <n>', 'Number of activities', '20')
+  .option('-f, --format <format>', 'Output format')
+  .action(async (cardId, options) => {
+    try {
+      const data = await withSpinner('Fetching activities...', () =>
+        client.get(`/cards/${cardId}/activities`)
+      );
+
+      const activities = data.activities || data.data || data;
+      const actArr = Array.isArray(activities) ? activities : [];
+      const limited = actArr.slice(0, parseInt(options.limit));
+
+      const rows = limited.map(a => ({
+        action: a.action || a.type || 'unknown',
+        user: a.user?.userName || a.user?.name || 'N/A',
+        detail: (a.detail || a.description || '').substring(0, 60),
+        time: formatRelativeTime(a.createdAt),
+      }));
+
+      output(rows, {
+        headers: ['Action', 'User', 'Detail', 'Time'],
+        format: options.format,
+      });
+    } catch (err) {
+      error(`Failed to fetch activities: ${err.message}`);
+    }
+  });
+
+card
+  .command('due <cardId> <date>')
+  .description('Set or remove a due date on a card')
+  .option('--remove', 'Remove the due date')
+  .action(async (cardId, date, options) => {
+    try {
+      if (options.remove) {
+        await withSpinner('Removing due date...', () =>
+          client.delete(`/cards/${cardId}/duedate`)
+        );
+        success(`Removed due date from card ${cardId}`);
+      } else {
+        await withSpinner('Setting due date...', () =>
+          client.post(`/cards/${cardId}/duedate`, { dueDate: date })
+        );
+        success(`Set due date to ${chalk.bold(date)} on card ${cardId}`);
+      }
+    } catch (err) {
+      error(`Failed to update due date: ${err.message}`);
+    }
+  });
+
+card
+  .command('priority <cardId> <level>')
+  .description('Set card priority (low|medium|high|critical)')
+  .action(async (cardId, level) => {
+    try {
+      await withSpinner('Setting priority...', () =>
+        client.post(`/cards/${cardId}/priority`, { priority: level })
+      );
+      success(`Set priority to ${chalk.bold(level)} on card ${cardId}`);
+    } catch (err) {
+      error(`Failed to set priority: ${err.message}`);
+    }
+  });
+
+card
+  .command('undone <cardId>')
+  .description('Mark a card as incomplete')
+  .action(async (cardId) => {
+    try {
+      await withSpinner('Updating card...', () =>
+        client.post(`/cards/update/${cardId}`, { isComplete: false })
+      );
+      success(`Card ${cardId} marked as incomplete`);
+    } catch (err) {
+      error(`Failed to update card: ${err.message}`);
+    }
+  });
+
 module.exports = card;