@zoobbe/cli 1.1.1 → 1.2.1

package/src/commands/automation.js

@@ -0,0 +1,255 @@
+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 automation = new Command('automation')
+  .alias('auto')
+  .description('Board automation commands');
+
+automation
+  .command('list')
+  .alias('ls')
+  .description('List automations on 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 automations...', () =>
+        client.get(`/boards/${options.board}/automations`)
+      );
+
+      const automations = data.automations || data.data || data;
+      const rows = (Array.isArray(automations) ? automations : []).map(a => ({
+        name: a.name || a.title || 'Unnamed',
+        trigger: a.trigger?.type || a.triggerType || 'N/A',
+        action: a.action?.type || a.actionType || 'N/A',
+        status: a.enabled ? chalk.green('enabled') : chalk.yellow('disabled'),
+        id: a._id,
+      }));
+
+      output(rows, {
+        headers: ['Name', 'Trigger', 'Action', 'Status', 'ID'],
+        format: options.format,
+      });
+    } catch (err) {
+      error(`Failed to list automations: ${err.message}`);
+    }
+  });
+
+automation
+  .command('create')
+  .description('Create a new automation (interactive)')
+  .option('-b, --board <boardId>', 'Board ID (required)')
+  .action(async (options) => {
+    try {
+      if (!options.board) return error('Board ID is required. Use -b <boardId>.');
+
+      const inquirer = require('inquirer');
+
+      // Fetch available options
+      const optionsData = await withSpinner('Fetching automation options...', () =>
+        client.get(`/boards/${options.board}/automations/options`)
+      );
+      const opts = optionsData.options || optionsData.data || optionsData;
+
+      const triggers = opts.triggers || ['card_created', 'card_moved', 'card_completed', 'due_date_reached'];
+      const actions = opts.actions || ['move_card', 'assign_member', 'add_label', 'send_notification'];
+
+      const answers = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'name',
+          message: 'Automation name:',
+          validate: v => v.length > 0 || 'Name is required',
+        },
+        {
+          type: 'list',
+          name: 'triggerType',
+          message: 'Select trigger:',
+          choices: triggers,
+        },
+        {
+          type: 'list',
+          name: 'actionType',
+          message: 'Select action:',
+          choices: actions,
+        },
+      ]);
+
+      const data = await withSpinner('Creating automation...', () =>
+        client.post(`/boards/${options.board}/automations`, {
+          name: answers.name,
+          trigger: { type: answers.triggerType },
+          action: { type: answers.actionType },
+        })
+      );
+
+      const a = data.automation || data.data || data;
+      success(`Created automation: ${chalk.bold(answers.name)} (${a._id})`);
+    } catch (err) {
+      error(`Failed to create automation: ${err.message}`);
+    }
+  });
+
+automation
+  .command('update <automationId>')
+  .description('Update an automation')
+  .option('-b, --board <boardId>', 'Board ID (required)')
+  .option('--name <name>', 'New name')
+  .action(async (automationId, options) => {
+    try {
+      if (!options.board) return error('Board ID is required. Use -b <boardId>.');
+
+      const body = {};
+      if (options.name) body.name = options.name;
+      if (Object.keys(body).length === 0) return error('Provide --name.');
+
+      await withSpinner('Updating automation...', () =>
+        client.put(`/boards/${options.board}/automations/${automationId}`, body)
+      );
+      success(`Updated automation ${automationId}`);
+    } catch (err) {
+      error(`Failed to update automation: ${err.message}`);
+    }
+  });
+
+automation
+  .command('delete <automationId>')
+  .description('Delete an automation')
+  .option('-b, --board <boardId>', 'Board ID (required)')
+  .option('--force', 'Skip confirmation')
+  .action(async (automationId, options) => {
+    try {
+      if (!options.board) return error('Board ID is required. Use -b <boardId>.');
+
+      if (!options.force) {
+        const confirmed = await confirmAction('Delete this automation?');
+        if (!confirmed) return;
+      }
+
+      await withSpinner('Deleting automation...', () =>
+        client.delete(`/boards/${options.board}/automations/${automationId}`)
+      );
+      success('Deleted automation');
+    } catch (err) {
+      error(`Failed to delete automation: ${err.message}`);
+    }
+  });
+
+automation
+  .command('toggle <automationId>')
+  .description('Enable or disable an automation')
+  .option('-b, --board <boardId>', 'Board ID (required)')
+  .action(async (automationId, options) => {
+    try {
+      if (!options.board) return error('Board ID is required. Use -b <boardId>.');
+
+      const data = await withSpinner('Toggling automation...', () =>
+        client.patch(`/boards/${options.board}/automations/${automationId}/toggle`)
+      );
+      const a = data.automation || data.data || data;
+      success(a.enabled ? 'Automation enabled' : 'Automation disabled');
+    } catch (err) {
+      error(`Failed to toggle automation: ${err.message}`);
+    }
+  });
+
+automation
+  .command('logs <automationId>')
+  .description('Show automation execution logs')
+  .option('-b, --board <boardId>', 'Board ID (required)')
+  .option('--limit <n>', 'Number of logs', '20')
+  .option('-f, --format <format>', 'Output format')
+  .action(async (automationId, options) => {
+    try {
+      if (!options.board) return error('Board ID is required. Use -b <boardId>.');
+
+      const data = await withSpinner('Fetching logs...', () =>
+        client.get(`/boards/${options.board}/automations/${automationId}/logs`)
+      );
+
+      const logs = data.logs || data.data || data;
+      const logArr = Array.isArray(logs) ? logs : [];
+      const limited = logArr.slice(0, parseInt(options.limit));
+
+      const rows = limited.map(l => ({
+        status: l.success ? chalk.green('success') : chalk.red('failed'),
+        trigger: l.trigger || 'N/A',
+        time: formatRelativeTime(l.createdAt || l.executedAt),
+        error: l.error || '-',
+      }));
+
+      output(rows, {
+        headers: ['Status', 'Trigger', 'Time', 'Error'],
+        format: options.format,
+      });
+    } catch (err) {
+      error(`Failed to fetch logs: ${err.message}`);
+    }
+  });
+
+automation
+  .command('options')
+  .description('Show available automation triggers and actions')
+  .option('-b, --board <boardId>', 'Board ID (required)')
+  .action(async (options) => {
+    try {
+      if (!options.board) return error('Board ID is required. Use -b <boardId>.');
+
+      const data = await withSpinner('Fetching options...', () =>
+        client.get(`/boards/${options.board}/automations/options`)
+      );
+
+      const opts = data.options || data.data || data;
+      console.log();
+      console.log(chalk.bold('  Available Triggers:'));
+      const triggers = opts.triggers || [];
+      triggers.forEach(t => console.log(`    - ${t.type || t}`));
+      console.log();
+      console.log(chalk.bold('  Available Actions:'));
+      const actions = opts.actions || [];
+      actions.forEach(a => console.log(`    - ${a.type || a}`));
+      console.log();
+    } catch (err) {
+      error(`Failed to fetch options: ${err.message}`);
+    }
+  });
+
+automation
+  .command('info <automationId>')
+  .description('Show automation details')
+  .option('-b, --board <boardId>', 'Board ID (required)')
+  .action(async (automationId, options) => {
+    try {
+      if (!options.board) return error('Board ID is required. Use -b <boardId>.');
+
+      // Fetch all automations and find the one
+      const data = await withSpinner('Fetching automation...', () =>
+        client.get(`/boards/${options.board}/automations`)
+      );
+
+      const automations = data.automations || data.data || data;
+      const match = (Array.isArray(automations) ? automations : []).find(a => a._id === automationId);
+
+      if (!match) return error(`Automation "${automationId}" not found.`);
+
+      console.log();
+      console.log(chalk.bold('  Name:    '), match.name || 'Unnamed');
+      console.log(chalk.bold('  ID:      '), match._id);
+      console.log(chalk.bold('  Trigger: '), match.trigger?.type || 'N/A');
+      console.log(chalk.bold('  Action:  '), match.action?.type || 'N/A');
+      console.log(chalk.bold('  Status:  '), match.enabled ? 'Enabled' : 'Disabled');
+      console.log(chalk.bold('  Runs:    '), match.executionCount ?? 0);
+      console.log();
+    } catch (err) {
+      error(`Failed to get automation info: ${err.message}`);
+    }
+  });
+
+module.exports = automation;

package/src/commands/board.js

@@ -89,8 +89,7 @@ board
   .action(async (nameOrId) => {
     try {
       const open = require('open');
-      const apiUrl = config.get('apiUrl');
-      const baseUrl = apiUrl.replace('api.', '');
+      const baseUrl = config.getWebUrl();
       const workspaceName = config.get('activeWorkspaceName');
 
       // Try to find the board to get its shortId
@@ -161,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;