@zoobbe/cli 1.2.0 → 1.2.1

package/src/commands/api-key.js

@@ -0,0 +1,140 @@
+const { Command } = require('commander');
+const chalk = require('chalk');
+const client = require('../lib/client');
+const { output, success, error, warn } = require('../lib/output');
+const { withSpinner } = require('../utils/spinner');
+const { confirmAction } = require('../utils/prompts');
+
+const apiKey = new Command('api-key')
+  .alias('ak')
+  .description('API key management commands (some operations require session auth)');
+
+const AUTH_NOTE = 'Note: API key management may be restricted when authenticated via API key. Use browser session if this fails.';
+
+apiKey
+  .command('list')
+  .alias('ls')
+  .description('List your API keys')
+  .option('-f, --format <format>', 'Output format')
+  .action(async (options) => {
+    try {
+      const data = await withSpinner('Fetching API keys...', () =>
+        client.get('/api-keys')
+      );
+
+      const keys = data.apiKeys || data.data || data;
+      const rows = (Array.isArray(keys) ? keys : []).map(k => ({
+        name: k.name || 'Unnamed',
+        prefix: k.prefix || k.key?.substring(0, 8) || 'N/A',
+        created: new Date(k.createdAt).toLocaleDateString(),
+        lastUsed: k.lastUsedAt ? new Date(k.lastUsedAt).toLocaleDateString() : 'Never',
+        id: k._id,
+      }));
+
+      output(rows, {
+        headers: ['Name', 'Prefix', 'Created', 'Last Used', 'ID'],
+        format: options.format,
+      });
+    } catch (err) {
+      warn(AUTH_NOTE);
+      error(`Failed to list API keys: ${err.message}`);
+    }
+  });
+
+apiKey
+  .command('create')
+  .description('Create a new API key')
+  .option('--name <name>', 'Key name (required)')
+  .action(async (options) => {
+    try {
+      if (!options.name) return error('Key name is required. Use --name <name>.');
+
+      const data = await withSpinner('Creating API key...', () =>
+        client.post('/api-keys', { name: options.name })
+      );
+
+      const key = data.apiKey || data.key || data.data || data;
+      console.log();
+      success(`Created API key: ${chalk.bold(options.name)}`);
+      if (key.key || key.token) {
+        console.log();
+        console.log(chalk.yellow('  Save this key — it won\'t be shown again:'));
+        console.log(chalk.bold(`  ${key.key || key.token}`));
+        console.log();
+      }
+    } catch (err) {
+      warn(AUTH_NOTE);
+      error(`Failed to create API key: ${err.message}`);
+    }
+  });
+
+apiKey
+  .command('delete <keyId>')
+  .description('Delete an API key')
+  .option('--force', 'Skip confirmation')
+  .action(async (keyId, options) => {
+    try {
+      if (!options.force) {
+        const confirmed = await confirmAction('Delete this API key? Any integrations using it will stop working.');
+        if (!confirmed) return;
+      }
+
+      await withSpinner('Deleting API key...', () =>
+        client.delete(`/api-keys/${keyId}`)
+      );
+      success('Deleted API key');
+    } catch (err) {
+      warn(AUTH_NOTE);
+      error(`Failed to delete API key: ${err.message}`);
+    }
+  });
+
+apiKey
+  .command('rename <keyId>')
+  .description('Rename an API key')
+  .option('--name <name>', 'New name (required)')
+  .action(async (keyId, options) => {
+    try {
+      if (!options.name) return error('Name is required. Use --name <name>.');
+
+      await withSpinner('Renaming API key...', () =>
+        client.put(`/api-keys/${keyId}`, { name: options.name })
+      );
+      success(`Renamed API key to: ${chalk.bold(options.name)}`);
+    } catch (err) {
+      warn(AUTH_NOTE);
+      error(`Failed to rename API key: ${err.message}`);
+    }
+  });
+
+apiKey
+  .command('regenerate <keyId>')
+  .description('Regenerate an API key')
+  .option('--force', 'Skip confirmation')
+  .action(async (keyId, options) => {
+    try {
+      if (!options.force) {
+        const confirmed = await confirmAction('Regenerate this API key? The old key will stop working immediately.');
+        if (!confirmed) return;
+      }
+
+      const data = await withSpinner('Regenerating API key...', () =>
+        client.post(`/api-keys/${keyId}/regenerate`)
+      );
+
+      const key = data.apiKey || data.key || data.data || data;
+      console.log();
+      success('API key regenerated');
+      if (key.key || key.token) {
+        console.log();
+        console.log(chalk.yellow('  Save this key — it won\'t be shown again:'));
+        console.log(chalk.bold(`  ${key.key || key.token}`));
+        console.log();
+      }
+    } catch (err) {
+      warn(AUTH_NOTE);
+      error(`Failed to regenerate API key: ${err.message}`);
+    }
+  });
+
+module.exports = apiKey;

package/src/commands/auth.js

@@ -245,6 +245,8 @@ auth
   .description('Clear stored credentials')
   .action(() => {
     config.set('apiKey', '');
+    config.set('apiUrl', 'https://api.zoobbe.com');
+    config.set('webUrl', '');
     config.set('userId', '');
     config.set('userName', '');
     config.set('email', '');

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

@@ -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;