sendcraft-cli 1.0.0 → 1.2.0

package/lib/commands/keys.js

@@ -1,8 +1,8 @@
 const { Command } = require('commander');
-const ora = require('ora');
 const chalk = require('chalk');
+const _grad = require('gradient-string'); const gradient = _grad.default || _grad;
 const client = require('../client');
-const { table, json, info, success, error } = require('../output');
+const { table, json, info, success, error, spinner } = require('../output');
 
 const cmd = new Command('keys').description('Manage API keys');
 
@@ -11,26 +11,26 @@ cmd
   .description('List all API keys')
   .option('--json', 'Output raw JSON')
   .action(async (opts) => {
-    const spinner = ora('Fetching…').start();
+    const sp = spinner('Fetching API keys…').start();
     try {
       const data = await client.get('/user/keys');
-      spinner.stop();
+      sp.succeed(chalk.dim('Loaded'));
       if (opts.json) return json(data);
       const keys = data.keys || [];
-      if (!keys.length) return info('No API keys found.');
+      if (!keys.length) return info('No API keys. Run: ' + chalk.cyan('sendcraft keys create <name>'));
       table(
-        ['ID', 'Name', 'Key (masked)', 'Permissions', 'Last Used', 'Created'],
+        ['ID', 'Name', 'Key', 'Permissions', 'Last Used', 'Created'],
         keys.map(k => [
-          String(k._id).slice(-8),
-          k.name,
-          k.maskedKey || '***',
-          k.permissions || 'full_access',
-          k.lastUsedAt ? new Date(k.lastUsedAt).toLocaleDateString() : 'Never',
-          k.createdAt ? new Date(k.createdAt).toLocaleDateString() : '—',
+          chalk.dim(String(k._id).slice(-8)),
+          chalk.bold(k.name),
+          chalk.dim(k.maskedKey || '***'),
+          k.permissions === 'full_access' ? chalk.green('full_access') : chalk.yellow('sending_access'),
+          k.lastUsedAt ? chalk.dim(new Date(k.lastUsedAt).toLocaleDateString()) : chalk.dim('Never'),
+          k.createdAt  ? chalk.dim(new Date(k.createdAt).toLocaleDateString())  : '—',
         ])
       );
     } catch (err) {
-      spinner.stop();
+      sp.fail(chalk.red('Failed'));
       error(err.message);
       process.exit(1);
     }
@@ -39,11 +39,11 @@ cmd
 cmd
   .command('create <name>')
   .description('Create a new API key')
-  .option('--permissions <type>', 'full_access or sending_access', 'full_access')
-  .option('--domains <domains>', 'Comma-separated allowed sender domains')
+  .option('--permissions <type>', 'full_access (default) or sending_access', 'full_access')
+  .option('--domains <list>', 'Comma-separated allowed sender domains')
   .option('--json', 'Output raw JSON')
   .action(async (name, opts) => {
-    const spinner = ora('Creating…').start();
+    const sp = spinner(`Creating key "${chalk.cyan(name)}"…`).start();
     try {
       const body = {
         name,
@@ -51,18 +51,22 @@ cmd
         allowedDomains: opts.domains ? opts.domains.split(',').map(d => d.trim()) : undefined,
       };
       const data = await client.post('/user/keys', body);
-      spinner.stop();
+      sp.succeed(chalk.dim('Created'));
       if (opts.json) return json(data);
+
       const key = data.key;
-      success('API key created!');
-      console.log(chalk.bold('\nKey (save this — shown only once):'));
-      console.log(chalk.green(key.key || '—'));
-      console.log(`\nPermissions: ${key.permissions}`);
+      console.log('\n' + gradient(['#6366f1', '#10b981'])('  ─── New API Key ───') + '\n');
+      console.log(`  ${chalk.bold('Name:')}        ${chalk.cyan(key.name)}`);
+      console.log(`  ${chalk.bold('Permissions:')} ${key.permissions === 'full_access' ? chalk.green('full_access') : chalk.yellow('sending_access')}`);
       if (key.allowedDomains?.length) {
-        console.log(`Allowed domains: ${key.allowedDomains.join(', ')}`);
+        console.log(`  ${chalk.bold('Domains:')}     ${key.allowedDomains.join(', ')}`);
       }
+      console.log(`\n  ${chalk.bold.yellow('Key (save this — shown once only):')}`);
+      console.log(`  ${chalk.bgBlack.green.bold(' ' + (key.key || '—') + ' ')}\n`);
+
+      success('Store this key securely. It cannot be retrieved again.');
     } catch (err) {
-      spinner.stop();
+      sp.fail(chalk.red('Failed'));
       error(err.message);
       process.exit(1);
     }
@@ -70,17 +74,17 @@ cmd
 
 cmd
   .command('revoke <keyId>')
-  .description('Revoke an API key permanently')
+  .description('Permanently revoke an API key')
   .option('--json', 'Output raw JSON')
   .action(async (keyId, opts) => {
-    const spinner = ora('Revoking…').start();
+    const sp = spinner(`Revoking key ${chalk.dim(keyId.slice(-8))}…`).start();
     try {
       const data = await client.delete(`/user/keys/${keyId}`);
-      spinner.stop();
+      sp.succeed(chalk.dim('Revoked'));
       if (opts.json) return json(data);
-      success(`Key ${keyId} revoked.`);
+      success(`Key ${chalk.dim(keyId)} permanently revoked.`);
     } catch (err) {
-      spinner.stop();
+      sp.fail(chalk.red('Failed'));
       error(err.message);
       process.exit(1);
     }

package/lib/commands/login.js

@@ -0,0 +1,206 @@
+/**
+ * sendcraft login
+ *
+ * Two flows:
+ *   1. Browser — opens the dashboard settings page so the user can copy their API key
+ *   2. Email + Password — calls /auth/login, then auto-creates a "CLI" API key
+ *
+ * URLs are derived from the configured base URL — no domains hardcoded.
+ */
+const { Command } = require('commander');
+const prompts = require('prompts');
+const chalk = require('chalk');
+const { load, save, getWebUrl, CONFIG_FILE } = require('../config');
+const client = require('../client');
+const { success, error, info, warn, spinner } = require('../output');
+const { sendcraftGradient } = require('../banner');
+
+// ─── helpers ──────────────────────────────────────────────────────────────────
+
+/** Open a URL in the system's default browser (cross-platform). */
+function openBrowser(url) {
+  const { execSync } = require('child_process');
+  try {
+    const cmd =
+      process.platform === 'darwin' ? `open "${url}"` :
+      process.platform === 'win32'  ? `start "" "${url}"` :
+      `xdg-open "${url}"`;
+    execSync(cmd, { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// ─── browser flow ─────────────────────────────────────────────────────────────
+
+async function browserFlow() {
+  const webUrl = getWebUrl();
+  const settingsUrl = `${webUrl}/dashboard/settings`;
+
+  console.log('\n' + sendcraftGradient('  ✦ Browser Login\n'));
+  info(`Opening dashboard: ${chalk.cyan(settingsUrl)}`);
+  console.log(chalk.dim('  1. Open the API Keys tab'));
+  console.log(chalk.dim('  2. Create or copy an existing key'));
+  console.log(chalk.dim('  3. Paste it below\n'));
+
+  const opened = openBrowser(settingsUrl);
+  if (!opened) {
+    warn('Could not open browser automatically.');
+    console.log(`  Open manually: ${chalk.cyan(settingsUrl)}\n`);
+  }
+
+  const { apiKey } = await prompts(
+    {
+      type: 'password',
+      name: 'apiKey',
+      message: 'Paste your API key here',
+      validate: (v) => (v && v.length > 10) ? true : 'Enter a valid API key',
+    },
+    { onCancel: () => { error('Cancelled.'); process.exit(0); } }
+  );
+
+  if (!apiKey) return;
+
+  // Quick verify the key works
+  const sp = spinner('Verifying key…').start();
+  try {
+    // Store temporarily to use the authenticated client
+    const cfg = load();
+    cfg.api_key = apiKey;
+    save(cfg);
+
+    await client.get('/auth/me');
+    sp.succeed(chalk.dim('Verified'));
+    success(`Logged in! Key stored at ${chalk.dim(CONFIG_FILE)}`);
+  } catch (e) {
+    // Restore old key if verification fails
+    const cfg = load();
+    if (cfg.api_key === apiKey) delete cfg.api_key;
+    save(cfg);
+    sp.fail(chalk.red('Invalid key'));
+    error(e.message);
+  }
+}
+
+// ─── email+password flow ───────────────────────────────────────────────────────
+
+async function apiFlow() {
+  console.log('\n' + sendcraftGradient('  ✦ Sign In\n'));
+
+  const answers = await prompts(
+    [
+      {
+        type: 'text',
+        name: 'email',
+        message: 'Email address',
+        validate: (v) => v && v.includes('@') ? true : 'Enter a valid email',
+      },
+      {
+        type: 'password',
+        name: 'password',
+        message: 'Password',
+        validate: (v) => v && v.length >= 4 ? true : 'Enter your password',
+      },
+    ],
+    { onCancel: () => { error('Cancelled.'); process.exit(0); } }
+  );
+
+  if (!answers.email || !answers.password) return;
+
+  const sp = spinner('Signing in…').start();
+  let token, userName;
+  try {
+    const result = await client.postNoAuth('/auth/login', {
+      email: answers.email,
+      password: answers.password,
+    });
+    token = result.token;
+    userName = result.user?.name || answers.email;
+    sp.succeed(chalk.dim('Authenticated'));
+  } catch (e) {
+    sp.fail(chalk.red('Login failed'));
+    error(e.message === 'Invalid credentials'
+      ? 'Wrong email or password. Try again.'
+      : e.message);
+    return;
+  }
+
+  // Auto-create a CLI API key using the JWT
+  const sp2 = spinner('Creating CLI API key…').start();
+  try {
+    const result = await client.postWithToken('/user/keys', {
+      name: 'CLI',
+      permissions: 'full_access',
+    }, token);
+
+    const apiKey = result.key?.key;
+    if (!apiKey) throw new Error('No key returned from server');
+
+    sp2.succeed(chalk.dim('API key created'));
+
+    const cfg = load();
+    cfg.api_key = apiKey;
+    save(cfg);
+
+    console.log('\n  ' + chalk.bold.green(`Welcome, ${userName}!`));
+    success(`Logged in! Key stored at ${chalk.dim(CONFIG_FILE)}`);
+    console.log(
+      '\n  ' + chalk.dim('Tip: run ') + chalk.cyan('sendcraft config show') +
+      chalk.dim(' to confirm your setup.\n')
+    );
+  } catch (e) {
+    sp2.fail(chalk.red('Could not create API key'));
+    error(e.message);
+    info(`You can create a key manually at ${chalk.cyan(getWebUrl() + '/dashboard/settings')}`);
+  }
+}
+
+// ─── command ──────────────────────────────────────────────────────────────────
+
+const cmd = new Command('login')
+  .description('Log in to SendCraft and save your API key')
+  .option('--browser', 'Open dashboard in browser to copy an API key')
+  .option('--api',     'Log in with email and password via the API')
+  .action(async (opts) => {
+    if (opts.browser) return browserFlow();
+    if (opts.api)     return apiFlow();
+    return runInteractive();
+  });
+
+/** Exported so the interactive TUI can call it directly */
+async function runInteractive() {
+  console.log('\n' + sendcraftGradient('  ✦ SendCraft Login\n'));
+
+  const { method } = await prompts(
+    {
+      type: 'select',
+      name: 'method',
+      message: 'How would you like to log in?',
+      choices: [
+        {
+          title: '🌐  ' + chalk.bold('Browser') +
+                 chalk.dim(' — open dashboard, copy your API key'),
+          value: 'browser',
+        },
+        {
+          title: '🔐  ' + chalk.bold('Email & Password') +
+                 chalk.dim(' — sign in and auto-generate a CLI key'),
+          value: 'api',
+        },
+        {
+          title: chalk.dim('✕   Back'),
+          value: 'cancel',
+        },
+      ],
+    },
+    { onCancel: () => null }
+  );
+
+  if (!method || method === 'cancel') return;
+  if (method === 'browser') return browserFlow();
+  if (method === 'api')     return apiFlow();
+}
+
+cmd.runInteractive = runInteractive;
+module.exports = cmd;

package/lib/commands/mcp.js

@@ -0,0 +1,77 @@
+const { Command } = require('commander');
+const chalk = require('chalk');
+const _grad2 = require('gradient-string'); const gradient = _grad2.default || _grad2;
+const _boxen = require('boxen'); const boxen = _boxen.default || _boxen;
+const { success, info } = require('../output');
+
+const cmd = new Command('mcp').description('MCP (Model Context Protocol) server setup for AI agents');
+
+cmd
+  .command('info')
+  .description('Show how to configure the SendCraft MCP server in Claude / Cursor / etc.')
+  .action(() => {
+    console.log('\n' + gradient(['#6366f1', '#8b5cf6', '#ec4899'])('  ✦ SendCraft MCP Server') + '\n');
+
+    const apiKey = process.env.SENDCRAFT_API_KEY || '<your-api-key>';
+
+    const claudeConfig = JSON.stringify({
+      mcpServers: {
+        sendcraft: {
+          command: 'npx',
+          args: ['sendcraft-mcp'],
+          env: {
+            SENDCRAFT_API_KEY: apiKey,
+          },
+        },
+      },
+    }, null, 2);
+
+    console.log(chalk.bold('  1. Install the MCP server:'));
+    console.log(`     ${chalk.cyan('npm install -g sendcraft-mcp')}\n`);
+
+    console.log(chalk.bold('  2. Add to Claude Desktop config') + chalk.dim(' (~/Library/Application Support/Claude/claude_desktop_config.json):'));
+    console.log(boxen(claudeConfig, {
+      padding: 1,
+      margin: { left: 4 },
+      borderStyle: 'round',
+      borderColor: 'cyan',
+    }));
+
+    console.log(chalk.bold('  3. Available MCP tools:'));
+    const tools = [
+      ['sendcraft_send_email',      'Send a transactional email'],
+      ['sendcraft_batch_send',      'Send up to 100 emails at once'],
+      ['sendcraft_list_emails',     'List sent emails'],
+      ['sendcraft_get_stats',       'Get email statistics'],
+      ['sendcraft_list_campaigns',  'List campaigns'],
+      ['sendcraft_list_subscribers','List subscribers'],
+      ['sendcraft_add_subscriber',  'Add a new subscriber'],
+      ['sendcraft_list_domains',    'List verified sender domains'],
+      ['sendcraft_list_api_keys',   'List API keys'],
+    ];
+    tools.forEach(([name, desc]) => {
+      console.log(`     ${chalk.green('•')} ${chalk.cyan(name)} ${chalk.dim('— ' + desc)}`);
+    });
+    console.log();
+    info(`Docs: ${chalk.underline('https://sendcraft.online/docs/mcp')}`);
+  });
+
+cmd
+  .command('install')
+  .description('Install the sendcraft-mcp package globally')
+  .action(() => {
+    const { execSync } = require('child_process');
+    const ora = require('ora');
+    const sp = ora({ text: 'Installing sendcraft-mcp…', spinner: 'dots', color: 'cyan' }).start();
+    try {
+      execSync('npm install -g sendcraft-mcp', { stdio: 'pipe' });
+      sp.succeed(chalk.dim('Installed'));
+      success('sendcraft-mcp installed! Run ' + chalk.cyan('sendcraft mcp info') + ' for config instructions.');
+    } catch (e) {
+      sp.fail(chalk.red('Install failed'));
+      console.error(e.stderr?.toString() || e.message);
+      process.exit(1);
+    }
+  });
+
+module.exports = cmd;

package/lib/commands/send.js

@@ -1,7 +1,7 @@
 const { Command } = require('commander');
-const ora = require('ora');
+const chalk = require('chalk');
 const client = require('../client');
-const { success, error, json } = require('../output');
+const { success, error, spinner } = require('../output');
 
 const cmd = new Command('send')
   .description('Send a single transactional email')
@@ -17,7 +17,8 @@ const cmd = new Command('send')
       error('Provide at least --html or --text');
       process.exit(1);
     }
-    const spinner = ora('Sending…').start();
+
+    const sp = spinner(`Sending to ${chalk.cyan(opts.to)}…`).start();
     try {
       const result = await client.post('/emails/send', {
         toEmail: opts.to,
@@ -27,11 +28,11 @@ const cmd = new Command('send')
         fromEmail: opts.from,
         replyTo: opts.replyTo,
       });
-      spinner.stop();
-      if (opts.json) return json(result);
-      success(`Email sent! ID: ${result.emailId || result._id || '—'}`);
+      sp.succeed(chalk.dim('Request complete'));
+      if (opts.json) return require('../output').json(result);
+      success(`Email sent!  ${chalk.dim('ID: ' + (result.emailId || result._id || '—'))}`);
     } catch (err) {
-      spinner.stop();
+      sp.fail(chalk.red('Send failed'));
       error(err.message);
       process.exit(1);
     }

package/lib/commands/subscribers.js

@@ -1,7 +1,7 @@
 const { Command } = require('commander');
-const ora = require('ora');
+const chalk = require('chalk');
 const client = require('../client');
-const { table, json, colorStatus, info, success, error } = require('../output');
+const { table, json, colorStatus, info, success, error, spinner } = require('../output');
 
 const cmd = new Command('subscribers').description('Manage subscribers');
 
@@ -13,28 +13,28 @@ cmd
   .option('--status <s>', 'Filter: active, pending, unsubscribed')
   .option('--json', 'Output raw JSON')
   .action(async (opts) => {
-    const spinner = ora('Fetching…').start();
+    const sp = spinner('Fetching subscribers…').start();
     try {
       const params = new URLSearchParams({ page: opts.page, limit: opts.limit });
       if (opts.status) params.set('status', opts.status);
       const data = await client.get(`/subscribers?${params}`);
-      spinner.stop();
+      sp.succeed(chalk.dim('Loaded'));
       if (opts.json) return json(data);
       const subs = data.subscribers || [];
       if (!subs.length) return info('No subscribers found.');
       table(
         ['Email', 'Name', 'Status', 'Tags', 'Joined'],
         subs.map(s => [
-          s.email,
-          [s.firstName, s.lastName].filter(Boolean).join(' ') || '—',
+          chalk.cyan(s.email),
+          [s.firstName, s.lastName].filter(Boolean).join(' ') || chalk.dim('—'),
           colorStatus(s.status),
-          (s.tags || []).join(', ') || '—',
-          s.createdAt ? new Date(s.createdAt).toLocaleDateString() : '—',
+          (s.tags || []).length ? s.tags.map(t => chalk.magenta(t)).join(', ') : chalk.dim('—'),
+          s.createdAt ? chalk.dim(new Date(s.createdAt).toLocaleDateString()) : '—',
         ])
       );
-      info(`Page ${opts.page} · ${subs.length} of ${data.total || '?'}`);
+      info(`Page ${opts.page} · ${subs.length} of ${chalk.bold(data.total ?? '?')}`);
     } catch (err) {
-      spinner.stop();
+      sp.fail(chalk.red('Failed'));
       error(err.message);
       process.exit(1);
     }
@@ -42,15 +42,14 @@ cmd
 
 cmd
   .command('add <email>')
-  .description('Add a subscriber')
-  .option('--list <listId>', 'Email list ID')
+  .description('Add a subscriber to a list')
+  .requiredOption('--list <listId>', 'Email list ID')
   .option('--first-name <name>', 'First name')
   .option('--last-name <name>', 'Last name')
   .option('--tags <tags>', 'Comma-separated tags')
   .option('--json', 'Output raw JSON')
   .action(async (email, opts) => {
-    if (!opts.list) { error('--list <listId> is required'); process.exit(1); }
-    const spinner = ora('Adding…').start();
+    const sp = spinner(`Adding ${chalk.cyan(email)}…`).start();
     try {
       const data = await client.post('/subscribers/add', {
         email,
@@ -59,11 +58,11 @@ cmd
         lastName: opts.lastName,
         tags: opts.tags ? opts.tags.split(',').map(t => t.trim()) : undefined,
       });
-      spinner.stop();
+      sp.succeed(chalk.dim('Done'));
       if (opts.json) return json(data);
-      success(`Subscriber ${email} added.`);
+      success(`${chalk.cyan(email)} added to list.`);
     } catch (err) {
-      spinner.stop();
+      sp.fail(chalk.red('Failed'));
       error(err.message);
       process.exit(1);
     }
@@ -74,14 +73,14 @@ cmd
   .description('Remove a subscriber by ID')
   .option('--json', 'Output raw JSON')
   .action(async (id, opts) => {
-    const spinner = ora('Removing…').start();
+    const sp = spinner(`Removing ${chalk.dim(id.slice(-8))}…`).start();
     try {
       const data = await client.delete(`/subscribers/${id}`);
-      spinner.stop();
+      sp.succeed(chalk.dim('Done'));
       if (opts.json) return json(data);
-      success(`Subscriber ${id} removed.`);
+      success(`Subscriber removed.`);
     } catch (err) {
-      spinner.stop();
+      sp.fail(chalk.red('Failed'));
       error(err.message);
       process.exit(1);
     }

package/lib/commands/warmup.js

@@ -1,52 +1,73 @@
 const { Command } = require('commander');
-const ora = require('ora');
 const chalk = require('chalk');
+const _grad = require('gradient-string'); const gradient = _grad.default || _grad;
 const client = require('../client');
-const { table, json, error } = require('../output');
+const { table, json, error, spinner } = require('../output');
 
 const cmd = new Command('warmup').description('View SMTP IP warmup status');
 
 cmd
   .option('--json', 'Output raw JSON')
   .action(async (opts) => {
-    const spinner = ora('Loading warmup status…').start();
+    const sp = spinner('Checking warmup status…').start();
     try {
       const data = await client.get('/smtp/warmup');
-      spinner.stop();
+      sp.succeed(chalk.dim('Done'));
+
       if (opts.json) return json(data);
 
-      const bar = buildBar(data.todayCount, data.dailyLimit);
+      console.log();
 
       if (data.isWarmedUp) {
-        console.log(chalk.green.bold('✓ IP is fully warmed up — no daily limits'));
+        const g = gradient(['#10b981', '#3b82f6']);
+        console.log(g.multiline(
+          '  ██╗    ██╗ █████╗ ██████╗ ███╗   ███╗███████╗██████╗ \n' +
+          '  ██║    ██║██╔══██╗██╔══██╗████╗ ████║██╔════╝██╔══██╗\n' +
+          '  ██║ █╗ ██║███████║██████╔╝██╔████╔██║█████╗  ██║  ██║\n' +
+          '  ██║███╗██║██╔══██║██╔══██╗██║╚██╔╝██║██╔══╝  ██║  ██║\n' +
+          '  ╚███╔███╔╝██║  ██║██║  ██║██║ ╚═╝ ██║███████╗██████╔╝\n' +
+          '   ╚══╝╚══╝ ╚═╝  ╚═╝╚═╝  ╚═╝╚═╝     ╚═╝╚══════╝╚═════╝ '
+        ));
+        console.log('  ' + chalk.green.bold('✓ IP fully warmed up — no daily limits!\n'));
       } else {
-        console.log(chalk.yellow.bold(`Warmup Day ${data.warmupDay}`));
-        console.log(`Progress: ${bar} ${data.todayCount}/${data.dailyLimit}`);
+        const pct = data.percentComplete || 0;
+        const bar = buildAnimatedBar(data.todayCount, data.dailyLimit, 30);
+        console.log(`  ${chalk.bold.magenta('Warmup Day ' + data.warmupDay)}`);
+        console.log(`  ${bar}  ${chalk.cyan(data.todayCount)}${chalk.dim('/' + data.dailyLimit)} sent today`);
+        console.log(`  ${chalk.dim(pct + '% of warmup complete')}\n`);
       }
 
       table(
         ['Field', 'Value'],
         [
-          ['Warmup Day', data.warmupDay],
-          ['Daily Limit', data.isWarmedUp ? 'Unlimited' : data.dailyLimit],
-          ['Sent Today', data.todayCount],
-          ['Remaining Today', data.isWarmedUp ? '∞' : data.remainingToday],
-          ['Warmed Up', data.isWarmedUp ? chalk.green('Yes') : chalk.yellow('No')],
-          ['% Complete', data.percentComplete != null ? `${data.percentComplete}%` : '—'],
+          ['Warmup Day',      chalk.bold(data.warmupDay)],
+          ['Daily Limit',     data.isWarmedUp ? chalk.green('∞ Unlimited') : chalk.yellow(String(data.dailyLimit))],
+          ['Sent Today',      chalk.cyan(String(data.todayCount))],
+          ['Remaining Today', data.isWarmedUp ? '∞' : chalk.green(String(data.remainingToday))],
+          ['Fully Warmed Up', data.isWarmedUp ? chalk.green('Yes ✓') : chalk.yellow('No')],
+          ['Progress',        (data.percentComplete ?? 0) + '%'],
         ]
       );
     } catch (err) {
-      spinner.stop();
+      sp.fail(chalk.red('Failed to fetch warmup status'));
       error(err.message);
       process.exit(1);
     }
   });
 
-function buildBar(count, limit) {
+function buildAnimatedBar(count, limit, width) {
   if (!limit) return '';
-  const width = 20;
-  const filled = Math.round((count / limit) * width);
-  return '[' + chalk.green('█'.repeat(filled)) + '░'.repeat(width - filled) + ']';
+  const ratio = Math.min(count / limit, 1);
+  const filled = Math.round(ratio * width);
+  const empty  = width - filled;
+
+  // Gradient bar: green→yellow→red based on fill level
+  let barColor;
+  if (ratio < 0.5)       barColor = chalk.green;
+  else if (ratio < 0.85) barColor = chalk.yellow;
+  else                   barColor = chalk.red;
+
+  return chalk.dim('[') + barColor('█'.repeat(filled)) + chalk.dim('░'.repeat(empty)) + chalk.dim(']');
 }
 
 module.exports = cmd;

package/lib/config.js

@@ -30,4 +30,24 @@ function getBaseUrl() {
   return process.env.SENDCRAFT_BASE_URL || load().base_url || 'https://api.sendcraft.online/api';
 }
 
-module.exports = { load, save, getApiKey, getBaseUrl, CONFIG_FILE };
+/**
+ * Derives the web dashboard URL from the API base URL.
+ * e.g. "https://api.sendcraft.online/api" → "https://sendcraft.online"
+ *      "http://localhost:3000/api"         → "http://localhost:3000"
+ *      "https://myinstance.com/api"        → "https://myinstance.com"
+ */
+function getWebUrl() {
+  const stored = load().web_url;
+  if (stored) return stored;
+  try {
+    const { URL } = require('url');
+    const parsed = new URL(getBaseUrl());
+    // Strip leading "api." subdomain if present
+    const host = parsed.hostname.replace(/^api\./, '');
+    return `${parsed.protocol}//${host}`;
+  } catch {
+    return 'https://sendcraft.online';
+  }
+}
+
+module.exports = { load, save, getApiKey, getBaseUrl, getWebUrl, CONFIG_FILE };