@zoobbe/cli 1.1.1 → 1.2.1

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;

package/src/commands/workspace.js

@@ -41,9 +41,10 @@ workspace
   });
 
 workspace
-  .command('switch <nameOrId>')
+  .command('switch <nameOrId...>')
   .description('Set the active workspace')
-  .action(async (nameOrId) => {
+  .action(async (nameOrIdParts) => {
+    const nameOrId = nameOrIdParts.join(' ');
     try {
       const data = await withSpinner('Fetching workspaces...', () =>
         client.get('/workspaces/me')
@@ -148,4 +149,178 @@ workspace
     }
   });
 
+// ── Extended commands ──
+
+const { confirmAction } = require('../utils/prompts');
+const { resolveWorkspaceObjectId } = require('../utils/resolve');
+
+workspace
+  .command('update')
+  .description('Update active workspace name')
+  .option('--name <name>', 'New workspace name (required)')
+  .action(async (options) => {
+    try {
+      if (!options.name) return error('Workspace name is required. Use --name <name>.');
+
+      const workspaceId = config.get('activeWorkspace');
+      if (!workspaceId) return error('No active workspace.');
+
+      const wsId = await resolveWorkspaceObjectId(workspaceId);
+      await withSpinner('Updating workspace...', () =>
+        client.put(`/workspaces/${wsId}`, { name: options.name })
+      );
+      config.set('activeWorkspaceName', options.name);
+      success(`Workspace renamed to: ${chalk.bold(options.name)}`);
+    } catch (err) {
+      error(`Failed to update workspace: ${err.message}`);
+    }
+  });
+
+workspace
+  .command('delete')
+  .description('Delete the active workspace')
+  .option('--force', 'Skip confirmation')
+  .action(async (options) => {
+    try {
+      const workspaceId = config.get('activeWorkspace');
+      const workspaceName = config.get('activeWorkspaceName');
+      if (!workspaceId) return error('No active workspace.');
+
+      if (!options.force) {
+        const confirmed = await confirmAction(`Permanently delete workspace "${workspaceName}" and all its data?`);
+        if (!confirmed) return;
+      }
+
+      const wsId = await resolveWorkspaceObjectId(workspaceId);
+      await withSpinner('Deleting workspace...', () =>
+        client.post(`/workspaces/${wsId}`)
+      );
+      config.set('activeWorkspace', '');
+      config.set('activeWorkspaceName', '');
+      success(`Deleted workspace: ${chalk.bold(workspaceName)}`);
+    } catch (err) {
+      error(`Failed to delete workspace: ${err.message}`);
+    }
+  });
+
+workspace
+  .command('invite')
+  .description('Invite a user to the active workspace by email')
+  .option('-e, --email <email>', 'Email address (required)')
+  .option('--role <role>', 'Role (admin|member)', 'member')
+  .action(async (options) => {
+    try {
+      if (!options.email) return error('Email is required. Use -e <email>.');
+
+      const workspaceId = config.get('activeWorkspace');
+      if (!workspaceId) return error('No active workspace.');
+
+      const wsId = await resolveWorkspaceObjectId(workspaceId);
+      await withSpinner('Sending invitation...', () =>
+        client.post(`/workspace/${wsId}/invite`, {
+          email: options.email,
+          role: options.role,
+        })
+      );
+      success(`Invitation sent to ${chalk.bold(options.email)}`);
+    } catch (err) {
+      error(`Failed to invite: ${err.message}`);
+    }
+  });
+
+workspace
+  .command('join-link')
+  .description('Generate or delete workspace join link')
+  .option('--delete', 'Delete the existing join link')
+  .action(async (options) => {
+    try {
+      const workspaceId = config.get('activeWorkspace');
+      if (!workspaceId) return error('No active workspace.');
+
+      const wsId = await resolveWorkspaceObjectId(workspaceId);
+
+      if (options.delete) {
+        await withSpinner('Deleting join link...', () =>
+          client.delete(`/workspace/${wsId}/delete-join-link`)
+        );
+        success('Join link deleted');
+      } else {
+        const data = await withSpinner('Generating join link...', () =>
+          client.post(`/workspace/${wsId}/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}`);
+    }
+  });
+
+workspace
+  .command('add-member')
+  .description('Add a member to the active workspace')
+  .option('-u, --user <userId>', 'User ID (required)')
+  .action(async (options) => {
+    try {
+      if (!options.user) return error('User ID is required. Use -u <userId>.');
+
+      const workspaceId = config.get('activeWorkspace');
+      if (!workspaceId) return error('No active workspace.');
+
+      const wsId = await resolveWorkspaceObjectId(workspaceId);
+      await withSpinner('Adding member...', () =>
+        client.post(`/workspace/${wsId}/member`, { userId: options.user })
+      );
+      success('Member added to workspace');
+    } catch (err) {
+      error(`Failed to add member: ${err.message}`);
+    }
+  });
+
+workspace
+  .command('remove-member')
+  .description('Remove a member from the active workspace')
+  .option('-u, --user <userId>', 'User ID (required)')
+  .action(async (options) => {
+    try {
+      if (!options.user) return error('User ID is required. Use -u <userId>.');
+
+      const workspaceId = config.get('activeWorkspace');
+      if (!workspaceId) return error('No active workspace.');
+
+      const wsId = await resolveWorkspaceObjectId(workspaceId);
+      await withSpinner('Removing member...', () =>
+        client.delete(`/workspace/${wsId}/member`, { userId: options.user })
+      );
+      success('Member removed from workspace');
+    } catch (err) {
+      error(`Failed to remove member: ${err.message}`);
+    }
+  });
+
+workspace
+  .command('member-role')
+  .description('Change a member\'s role in the active workspace')
+  .option('-u, --user <userId>', 'User ID (required)')
+  .option('--role <role>', 'New role (admin|member)', 'member')
+  .action(async (options) => {
+    try {
+      if (!options.user) return error('User ID is required. Use -u <userId>.');
+
+      const workspaceId = config.get('activeWorkspace');
+      if (!workspaceId) return error('No active workspace.');
+
+      const wsId = await resolveWorkspaceObjectId(workspaceId);
+      await withSpinner('Updating role...', () =>
+        client.put(`/workspace/${wsId}/member`, {
+          userId: options.user,
+          role: options.role,
+        })
+      );
+      success(`Member role updated to ${chalk.bold(options.role)}`);
+    } catch (err) {
+      error(`Failed to update role: ${err.message}`);
+    }
+  });
+
 module.exports = workspace;

package/src/index.js

@@ -16,7 +16,17 @@ program.addCommand(require('./commands/auth'));
 program.addCommand(require('./commands/workspace'));
 program.addCommand(require('./commands/board'));
 program.addCommand(require('./commands/card'));
+program.addCommand(require('./commands/list'));
+program.addCommand(require('./commands/checklist'));
 program.addCommand(require('./commands/page'));
+program.addCommand(require('./commands/timer'));
+program.addCommand(require('./commands/notification'));
+program.addCommand(require('./commands/activity'));
+program.addCommand(require('./commands/analytics'));
+program.addCommand(require('./commands/automation'));
+program.addCommand(require('./commands/webhook'));
+program.addCommand(require('./commands/api-key'));
+program.addCommand(require('./commands/import'));
 program.addCommand(require('./commands/search'));
 program.addCommand(require('./commands/ai'));
 program.addCommand(require('./commands/status'));

package/src/lib/client.js

@@ -26,8 +26,9 @@ class ZoobbeClient {
   async request(method, path, body = null) {
     this.ensureAuth();
 
-    // Reject path traversal attempts
-    if (path.includes('..') || path.includes('//')) {
+    // Reject path traversal attempts (check decoded form too)
+    const decoded = decodeURIComponent(path);
+    if (decoded.includes('..') || decoded.includes('//') || /\x00/.test(decoded)) {
       throw new Error('Invalid request path');
     }
 
@@ -71,8 +72,48 @@ class ZoobbeClient {
     return this.request('PATCH', path, body);
   }
 
-  async delete(path) {
-    return this.request('DELETE', path);
+  async delete(path, body) {
+    return this.request('DELETE', path, body);
+  }
+
+  async upload(path, filePath, fieldName = 'file') {
+    this.ensureAuth();
+    const fs = require('fs');
+    const nodePath = require('path');
+
+    const decoded = decodeURIComponent(path);
+    if (decoded.includes('..') || decoded.includes('//') || /\x00/.test(decoded)) {
+      throw new Error('Invalid request path');
+    }
+
+    const url = `${this.baseUrl}/v1${path}`;
+    const boundary = `----ZoobbeUpload${Date.now()}`;
+    const fileName = nodePath.basename(filePath).replace(/["\r\n\\]/g, '_');
+    const fileBuffer = fs.readFileSync(filePath);
+
+    const header = `--${boundary}\r\nContent-Disposition: form-data; name="${fieldName}"; filename="${fileName}"\r\nContent-Type: application/octet-stream\r\n\r\n`;
+    const footer = `\r\n--${boundary}--\r\n`;
+
+    const body = Buffer.concat([Buffer.from(header), fileBuffer, Buffer.from(footer)]);
+
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${this.apiKey}`,
+        'User-Agent': 'Zoobbe-CLI/1.0',
+        'Content-Type': `multipart/form-data; boundary=${boundary}`,
+      },
+      body,
+    });
+
+    const data = await response.json();
+    if (!response.ok) {
+      const msg = data.error || data.message || `Upload failed with status ${response.status}`;
+      const error = new Error(msg);
+      error.status = response.status;
+      throw error;
+    }
+    return data;
   }
 }
 

package/src/lib/config.js

@@ -16,6 +16,7 @@ const config = new Conf({
   schema: {
     apiKey: { type: 'string', default: '' },
     apiUrl: { type: 'string', default: 'https://api.zoobbe.com' },
+    webUrl: { type: 'string', default: '' },
     activeWorkspace: { type: 'string', default: '' },
     activeWorkspaceName: { type: 'string', default: '' },
     format: { type: 'string', enum: ['table', 'json', 'plain'], default: 'table' },
@@ -32,4 +33,24 @@ try {
   // Ignore if chmod fails (e.g., Windows)
 }
 
+/**
+ * Get the frontend web URL. Uses webUrl config if set,
+ * otherwise derives from apiUrl (api.zoobbe.com → zoobbe.com).
+ */
+config.getWebUrl = function () {
+  const explicit = this.get('webUrl');
+  if (explicit) return explicit.replace(/\/$/, '');
+  const apiUrl = this.get('apiUrl').replace(/\/$/, '');
+  try {
+    const url = new URL(apiUrl);
+    // For production: api.zoobbe.com → zoobbe.com
+    if (url.hostname.startsWith('api.')) {
+      url.hostname = url.hostname.slice(4);
+      return url.toString().replace(/\/$/, '');
+    }
+  } catch { /* ignore */ }
+  // Fallback: return apiUrl as-is (backend /cli/auth redirect handles it)
+  return apiUrl;
+};
+
 module.exports = config;