@vibe-db/cli 1.3.0 → 1.4.0

package/CHANGELOG.md

@@ -0,0 +1,63 @@
+# Changelog
+
+All notable changes to the VibeDB CLI will be documented in this file.
+
+## [1.4.0] - 2026-01-12
+
+### Added
+- **Usage Command**: New `vibedb usage` command to view storage usage and estimated costs
+  - Shows database storage and backup storage breakdown
+  - Displays estimated charges for current billing period
+  - Shows pricing information
+- **Backup Management Commands**: Complete CLI support for backup operations
+  - `vibedb backup list <database_id>` - List all backups for a database
+  - `vibedb backup create <database_id>` - Create a manual backup
+  - `vibedb backup restore <database_id> <backup_id>` - Restore from backup (with confirmation)
+  - `vibedb backup delete <database_id> <backup_id>` - Delete a backup (with confirmation)
+- Added safety confirmations for destructive operations (restore, delete)
+- Improved error messages for missing authentication
+
+### Changed
+- Enhanced API module with backup-related functions
+- Updated README with comprehensive documentation for new commands
+
+### Fixed
+- Fixed handling of undefined estimated charges in usage display
+
+## [1.3.0] - 2026-01-11
+
+### Added
+- **Team Support**: Multi-team functionality
+  - `vibedb teams list` - List all teams
+  - `vibedb teams switch <team_id>` - Switch between teams
+  - `vibedb teams current` - Show current team
+  - Auto-selects personal team on login
+- **Billing Commands**: Stripe billing integration
+  - `vibedb billing info` - View billing information
+  - `vibedb billing subscribe` - Subscribe to VibeDB
+  - `vibedb billing cancel` - Cancel subscription
+  - `vibedb billing invoices` - View invoices
+
+### Changed
+- Database operations now scoped to current team
+- Config file now stores current team ID
+
+## [1.2.0] - Earlier
+
+### Added
+- Basic database operations
+  - `vibedb list` - List databases
+  - `vibedb init` - Download VIBEDB.md prompt file
+- Authentication commands
+  - `vibedb signup` - Create account
+  - `vibedb login` - Login to existing account
+  - `vibedb logout` - Logout and clear credentials
+- Configuration management in `~/.vibedb`
+
+## Future Plans
+
+- Database creation directly from CLI
+- Database deletion with recovery options
+- Connection testing
+- Query execution from CLI
+- Import/export utilities

package/README.md

@@ -136,6 +136,141 @@ Show currently selected team.
 **Output:**
 - Current team details (ID, name, role, type)
 
+### `vibedb usage`
+Show current usage and costs.
+
+**Requirements:**
+- Must be logged in
+
+**Output:**
+- Storage breakdown (database + backup storage)
+- Estimated charges for current period
+- Pricing information
+
+**Example:**
+```bash
+vibedb usage
+
+📊 Usage & Costs
+
+Storage Usage:
+  Database Storage: 45.23 MB
+  Backup Storage: 12.67 MB
+  ─────────────────
+  Total Storage: 57.90 MB
+
+Estimated Charges:
+  Current Period: $0.0823 USD
+
+Pricing:
+  Storage: $0.00014 per GB-hour
+  Compute: $0.000167 per minute
+```
+
+### `vibedb backup list <database_id>`
+List all backups for a database.
+
+**Requirements:**
+- Must be logged in
+- Valid database ID
+
+**Output:**
+- List of backups with ID, type (auto/manual), size, and creation date
+
+**Example:**
+```bash
+vibedb backup list db_abc123
+
+💾 Backups
+
+Found 3 backup(s):
+
+1. d4339369-a3bb-492c-afe3-2124265e9b56
+   Type: [Manual]
+   Size: 12.34 MB
+   Created: 1/12/2026, 8:30:06 PM
+
+2. a1234567-b8cd-9012-efgh-345678901234
+   Type: [Auto]
+   Size: 11.98 MB
+   Created: 1/12/2026, 2:00:00 AM
+```
+
+### `vibedb backup create <database_id>`
+Create a manual backup.
+
+**Requirements:**
+- Must be logged in
+- Valid database ID
+
+**Output:**
+- Backup ID and creation timestamp
+
+**Example:**
+```bash
+vibedb backup create db_abc123
+
+✓ Backup created successfully!
+
+Backup ID: d4339369-a3bb-492c-afe3-2124265e9b56
+Type: [Manual]
+Created: 1/12/2026, 8:30:06 PM
+Size: 12.34 MB
+
+Restore this backup with:
+vibedb backup restore db_abc123 d4339369-a3bb-492c-afe3-2124265e9b56
+```
+
+### `vibedb backup restore <database_id> <backup_id>`
+Restore a database from a backup.
+
+**Requirements:**
+- Must be logged in
+- Valid database ID and backup ID
+- Confirmation required (interactive)
+
+**Warning:** This will replace ALL current data in the database!
+
+**Example:**
+```bash
+vibedb backup restore db_abc123 d4339369-a3bb-492c-afe3-2124265e9b56
+
+🔄 Restore Backup
+
+⚠️  WARNING:
+This will replace ALL current data in the database with the backup.
+This action cannot be undone.
+
+Database ID: db_abc123
+Backup ID: d4339369-a3bb-492c-afe3-2124265e9b56
+
+Are you sure you want to restore this backup? (y/N): y
+
+✓ Backup restored successfully!
+```
+
+### `vibedb backup delete <database_id> <backup_id>`
+Delete a backup.
+
+**Requirements:**
+- Must be logged in
+- Valid database ID and backup ID
+- Confirmation required (interactive)
+
+**Example:**
+```bash
+vibedb backup delete db_abc123 d4339369-a3bb-492c-afe3-2124265e9b56
+
+🗑️  Delete Backup
+
+Database ID: db_abc123
+Backup ID: d4339369-a3bb-492c-afe3-2124265e9b56
+
+Are you sure you want to delete this backup? (y/N): y
+
+✓ Backup deleted successfully!
+```
+
 ## Configuration
 
 The CLI stores your credentials in `~/.vibedb`:
@@ -274,7 +409,12 @@ The CLI interacts with these VibeDB API endpoints:
 - `POST /v1/auth/login` - Authenticate
 - `GET /v1/databases` - List databases
 - `GET /v1/prompt-file` - Download prompt file
-- `GET /v1/account` - Get account info
+- `GET /v1/account` - Get account info and usage
+- `GET /v1/teams` - List teams
+- `GET /v1/databases/{id}/backups` - List backups
+- `POST /v1/databases/{id}/backups` - Create backup
+- `POST /v1/databases/{id}/backups/{backup_id}/restore` - Restore backup
+- `DELETE /v1/databases/{id}/backups/{backup_id}` - Delete backup
 
 Full API docs: https://api.vibedb.dev/docs
 

package/bin/vibedb.js

@@ -15,6 +15,11 @@ const billingInvoicesCommand = require('../src/commands/billing-invoices');
 const teamsListCommand = require('../src/commands/teams-list');
 const teamsSwitchCommand = require('../src/commands/teams-switch');
 const teamsCurrentCommand = require('../src/commands/teams-current');
+const usageCommand = require('../src/commands/usage');
+const backupListCommand = require('../src/commands/backup-list');
+const backupCreateCommand = require('../src/commands/backup-create');
+const backupRestoreCommand = require('../src/commands/backup-restore');
+const backupDeleteCommand = require('../src/commands/backup-delete');
 
 const program = new Command();
 
@@ -179,6 +184,72 @@ teams
     }
   });
 
+// Usage command
+program
+  .command('usage')
+  .description('Show current usage and costs')
+  .action(async () => {
+    try {
+      await usageCommand();
+    } catch (error) {
+      console.error(chalk.red('Unexpected error:'), error.message);
+      process.exit(1);
+    }
+  });
+
+// Backup commands
+const backup = program
+  .command('backup')
+  .description('Manage database backups');
+
+backup
+  .command('list <database_id>')
+  .description('List all backups for a database')
+  .action(async (databaseId) => {
+    try {
+      await backupListCommand(databaseId);
+    } catch (error) {
+      console.error(chalk.red('Unexpected error:'), error.message);
+      process.exit(1);
+    }
+  });
+
+backup
+  .command('create <database_id>')
+  .description('Create a manual backup')
+  .action(async (databaseId) => {
+    try {
+      await backupCreateCommand(databaseId);
+    } catch (error) {
+      console.error(chalk.red('Unexpected error:'), error.message);
+      process.exit(1);
+    }
+  });
+
+backup
+  .command('restore <database_id> <backup_id>')
+  .description('Restore a database from a backup')
+  .action(async (databaseId, backupId) => {
+    try {
+      await backupRestoreCommand(databaseId, backupId);
+    } catch (error) {
+      console.error(chalk.red('Unexpected error:'), error.message);
+      process.exit(1);
+    }
+  });
+
+backup
+  .command('delete <database_id> <backup_id>')
+  .description('Delete a backup')
+  .action(async (databaseId, backupId) => {
+    try {
+      await backupDeleteCommand(databaseId, backupId);
+    } catch (error) {
+      console.error(chalk.red('Unexpected error:'), error.message);
+      process.exit(1);
+    }
+  });
+
 // Global error handler
 process.on('unhandledRejection', (error) => {
   console.error(chalk.red.bold('\n✗ Unhandled error:'), error.message);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibe-db/cli",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "Command-line interface for VibeDB - instant database provisioning for AI-assisted development",
   "main": "bin/vibedb.js",
   "bin": {

package/src/api.js

@@ -263,6 +263,97 @@ async function getTeam(apiKey, teamId) {
   }
 }
 
+/**
+ * List backups for a database
+ */
+async function listBackups(apiKey, databaseId) {
+  try {
+    const response = await axios.get(`${API_BASE_URL}/v1/databases/${databaseId}/backups`, {
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+      },
+    });
+    return response.data.backups || [];
+  } catch (error) {
+    if (error.response) {
+      const { error: errorCode, message } = error.response.data;
+      throw new Error(message || errorCode || 'Failed to list backups');
+    }
+    throw new Error(`Network error: ${error.message}`);
+  }
+}
+
+/**
+ * Create a backup for a database
+ */
+async function createBackup(apiKey, databaseId) {
+  try {
+    const response = await axios.post(
+      `${API_BASE_URL}/v1/databases/${databaseId}/backups`,
+      {},
+      {
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+        },
+      }
+    );
+    return response.data;
+  } catch (error) {
+    if (error.response) {
+      const { error: errorCode, message } = error.response.data;
+      throw new Error(message || errorCode || 'Failed to create backup');
+    }
+    throw new Error(`Network error: ${error.message}`);
+  }
+}
+
+/**
+ * Restore a database from a backup
+ */
+async function restoreBackup(apiKey, databaseId, backupId) {
+  try {
+    const response = await axios.post(
+      `${API_BASE_URL}/v1/databases/${databaseId}/backups/${backupId}/restore`,
+      {},
+      {
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+        },
+      }
+    );
+    return response.data;
+  } catch (error) {
+    if (error.response) {
+      const { error: errorCode, message } = error.response.data;
+      throw new Error(message || errorCode || 'Failed to restore backup');
+    }
+    throw new Error(`Network error: ${error.message}`);
+  }
+}
+
+/**
+ * Delete a backup
+ */
+async function deleteBackup(apiKey, databaseId, backupId) {
+  try {
+    const response = await axios.delete(
+      `${API_BASE_URL}/v1/databases/${databaseId}/backups/${backupId}`,
+      {
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+        },
+      }
+    );
+    return response.data;
+  } catch (error) {
+    if (error.response) {
+      const { error: errorCode, message } = error.response.data;
+      throw new Error(message || errorCode || 'Failed to delete backup');
+    }
+    throw new Error(`Network error: ${error.message}`);
+  }
+}
+
 module.exports = {
   signup,
   login,
@@ -277,4 +368,8 @@ module.exports = {
   pollDeviceAuth,
   listTeams,
   getTeam,
+  listBackups,
+  createBackup,
+  restoreBackup,
+  deleteBackup,
 };

package/src/commands/backup-create.js

@@ -0,0 +1,48 @@
+const chalk = require('chalk');
+const api = require('../api');
+const config = require('../config');
+
+async function backupCreateCommand(databaseId) {
+  console.log(chalk.blue.bold('\n💾 Create Backup\n'));
+
+  try {
+    // Check if logged in
+    if (!config.isLoggedIn()) {
+      console.error(chalk.red.bold('✗ Not logged in'));
+      console.log(chalk.gray('\nPlease run'), chalk.cyan('vibedb login'), chalk.gray('or'), chalk.cyan('vibedb signup'), chalk.gray('first.'));
+      process.exit(1);
+    }
+
+    if (!databaseId) {
+      console.error(chalk.red.bold('✗ Database ID is required'));
+      console.log(chalk.gray('\nUsage:'), chalk.cyan('vibedb backup create <database-id>'));
+      process.exit(1);
+    }
+
+    const apiKey = config.getAPIKey();
+
+    console.log(chalk.gray(`Creating backup for database ${databaseId}...`));
+
+    const backup = await api.createBackup(apiKey, databaseId);
+
+    console.log(chalk.green.bold('\n✓ Backup created successfully!\n'));
+    console.log(chalk.gray('Backup ID:'), chalk.cyan(backup.id));
+    console.log(chalk.gray('Type:'), chalk.green('[Manual]'));
+    console.log(chalk.gray('Created:'), chalk.white(new Date(backup.created_at).toLocaleString()));
+    
+    if (backup.size_mb) {
+      console.log(chalk.gray('Size:'), chalk.cyan(`${backup.size_mb.toFixed(2)} MB`));
+    }
+    
+    console.log();
+    console.log(chalk.gray('Restore this backup with:'));
+    console.log(chalk.cyan(`vibedb backup restore ${databaseId} ${backup.id}`));
+    console.log();
+
+  } catch (error) {
+    console.error(chalk.red.bold('\n✗ Failed to create backup:'), chalk.red(error.message));
+    process.exit(1);
+  }
+}
+
+module.exports = backupCreateCommand;

package/src/commands/backup-delete.js

@@ -0,0 +1,64 @@
+const chalk = require('chalk');
+const readline = require('readline');
+const api = require('../api');
+const config = require('../config');
+
+async function askConfirmation(question) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
+    });
+  });
+}
+
+async function backupDeleteCommand(databaseId, backupId) {
+  console.log(chalk.blue.bold('\n🗑️  Delete Backup\n'));
+
+  try {
+    // Check if logged in
+    if (!config.isLoggedIn()) {
+      console.error(chalk.red.bold('✗ Not logged in'));
+      console.log(chalk.gray('\nPlease run'), chalk.cyan('vibedb login'), chalk.gray('or'), chalk.cyan('vibedb signup'), chalk.gray('first.'));
+      process.exit(1);
+    }
+
+    if (!databaseId || !backupId) {
+      console.error(chalk.red.bold('✗ Database ID and Backup ID are required'));
+      console.log(chalk.gray('\nUsage:'), chalk.cyan('vibedb backup delete <database-id> <backup-id>'));
+      process.exit(1);
+    }
+
+    const apiKey = config.getAPIKey();
+
+    console.log(chalk.gray('Database ID:'), chalk.cyan(databaseId));
+    console.log(chalk.gray('Backup ID:'), chalk.cyan(backupId));
+    console.log();
+
+    const confirmed = await askConfirmation(chalk.white('Are you sure you want to delete this backup? (y/N): '));
+
+    if (!confirmed) {
+      console.log(chalk.gray('\nDeletion cancelled.'));
+      return;
+    }
+
+    console.log(chalk.gray('\nDeleting backup...'));
+
+    await api.deleteBackup(apiKey, databaseId, backupId);
+
+    console.log(chalk.green.bold('\n✓ Backup deleted successfully!\n'));
+    console.log(chalk.gray('Backup ID:'), chalk.cyan(backupId));
+    console.log();
+
+  } catch (error) {
+    console.error(chalk.red.bold('\n✗ Failed to delete backup:'), chalk.red(error.message));
+    process.exit(1);
+  }
+}
+
+module.exports = backupDeleteCommand;

package/src/commands/backup-list.js

@@ -0,0 +1,67 @@
+const chalk = require('chalk');
+const api = require('../api');
+const config = require('../config');
+
+async function backupListCommand(databaseId) {
+  console.log(chalk.blue.bold('\n💾 Backups\n'));
+
+  try {
+    // Check if logged in
+    if (!config.isLoggedIn()) {
+      console.error(chalk.red.bold('✗ Not logged in'));
+      console.log(chalk.gray('\nPlease run'), chalk.cyan('vibedb login'), chalk.gray('or'), chalk.cyan('vibedb signup'), chalk.gray('first.'));
+      process.exit(1);
+    }
+
+    if (!databaseId) {
+      console.error(chalk.red.bold('✗ Database ID is required'));
+      console.log(chalk.gray('\nUsage:'), chalk.cyan('vibedb backup list <database-id>'));
+      process.exit(1);
+    }
+
+    const apiKey = config.getAPIKey();
+
+    console.log(chalk.gray(`Fetching backups for database ${databaseId}...`));
+
+    const backups = await api.listBackups(apiKey, databaseId);
+
+    if (backups.length === 0) {
+      console.log(chalk.yellow('\nNo backups found for this database.'));
+      console.log(chalk.gray('Create one with:'), chalk.cyan(`vibedb backup create ${databaseId}`));
+      return;
+    }
+
+    console.log();
+    console.log(chalk.gray(`Found ${backups.length} backup(s):\n`));
+
+    // Display backups in a table format
+    backups.forEach((backup, index) => {
+      const isAutomatic = backup.type === 'automatic';
+      const typeLabel = isAutomatic ? chalk.blue('[Auto]') : chalk.green('[Manual]');
+      const sizeLabel = backup.size_mb ? `${backup.size_mb.toFixed(2)} MB` : 'N/A';
+      const createdAt = new Date(backup.created_at).toLocaleString();
+      
+      console.log(chalk.white.bold(`${index + 1}. ${backup.id}`));
+      console.log(chalk.gray('   Type:'), typeLabel);
+      console.log(chalk.gray('   Size:'), chalk.cyan(sizeLabel));
+      console.log(chalk.gray('   Created:'), chalk.white(createdAt));
+      
+      if (backup.deleted_at) {
+        console.log(chalk.gray('   Status:'), chalk.red('Deleted'));
+      }
+      
+      console.log();
+    });
+
+    console.log(chalk.gray('Commands:'));
+    console.log(chalk.gray('  Restore:'), chalk.cyan(`vibedb backup restore ${databaseId} <backup-id>`));
+    console.log(chalk.gray('  Delete:'), chalk.cyan(`vibedb backup delete ${databaseId} <backup-id>`));
+    console.log();
+
+  } catch (error) {
+    console.error(chalk.red.bold('\n✗ Failed to list backups:'), chalk.red(error.message));
+    process.exit(1);
+  }
+}
+
+module.exports = backupListCommand;

package/src/commands/backup-restore.js

@@ -0,0 +1,73 @@
+const chalk = require('chalk');
+const readline = require('readline');
+const api = require('../api');
+const config = require('../config');
+
+async function askConfirmation(question) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
+    });
+  });
+}
+
+async function backupRestoreCommand(databaseId, backupId) {
+  console.log(chalk.blue.bold('\n🔄 Restore Backup\n'));
+
+  try {
+    // Check if logged in
+    if (!config.isLoggedIn()) {
+      console.error(chalk.red.bold('✗ Not logged in'));
+      console.log(chalk.gray('\nPlease run'), chalk.cyan('vibedb login'), chalk.gray('or'), chalk.cyan('vibedb signup'), chalk.gray('first.'));
+      process.exit(1);
+    }
+
+    if (!databaseId || !backupId) {
+      console.error(chalk.red.bold('✗ Database ID and Backup ID are required'));
+      console.log(chalk.gray('\nUsage:'), chalk.cyan('vibedb backup restore <database-id> <backup-id>'));
+      process.exit(1);
+    }
+
+    const apiKey = config.getAPIKey();
+
+    // Warning message
+    console.log(chalk.yellow.bold('⚠️  WARNING:'));
+    console.log(chalk.yellow('This will replace ALL current data in the database with the backup.'));
+    console.log(chalk.yellow('This action cannot be undone.\n'));
+    
+    console.log(chalk.gray('Database ID:'), chalk.cyan(databaseId));
+    console.log(chalk.gray('Backup ID:'), chalk.cyan(backupId));
+    console.log();
+
+    const confirmed = await askConfirmation(chalk.white('Are you sure you want to restore this backup? (y/N): '));
+
+    if (!confirmed) {
+      console.log(chalk.gray('\nRestore cancelled.'));
+      return;
+    }
+
+    console.log(chalk.gray('\nRestoring backup...'));
+
+    const result = await api.restoreBackup(apiKey, databaseId, backupId);
+
+    console.log(chalk.green.bold('\n✓ Backup restored successfully!\n'));
+    console.log(chalk.gray('Database ID:'), chalk.cyan(databaseId));
+    console.log(chalk.gray('Backup ID:'), chalk.cyan(backupId));
+    console.log(chalk.gray('Restored at:'), chalk.white(new Date().toLocaleString()));
+    console.log();
+    console.log(chalk.green('Your database has been restored to the backup state.'));
+    console.log();
+
+  } catch (error) {
+    console.error(chalk.red.bold('\n✗ Failed to restore backup:'), chalk.red(error.message));
+    process.exit(1);
+  }
+}
+
+module.exports = backupRestoreCommand;

package/src/commands/usage.js

@@ -0,0 +1,66 @@
+const chalk = require('chalk');
+const api = require('../api');
+const config = require('../config');
+
+async function usageCommand() {
+  console.log(chalk.blue.bold('\n📊 Usage & Costs\n'));
+
+  try {
+    // Check if logged in
+    if (!config.isLoggedIn()) {
+      console.error(chalk.red.bold('✗ Not logged in'));
+      console.log(chalk.gray('\nPlease run'), chalk.cyan('vibedb login'), chalk.gray('or'), chalk.cyan('vibedb signup'), chalk.gray('first.'));
+      process.exit(1);
+    }
+
+    const apiKey = config.getAPIKey();
+    const currentTeamId = config.getCurrentTeamId();
+
+    console.log(chalk.gray('Fetching usage data...'));
+
+    const account = await api.getAccount(apiKey, currentTeamId);
+
+    console.log();
+
+    // Storage breakdown
+    console.log(chalk.white.bold('Storage Usage:'));
+    
+    if (account.storage_breakdown) {
+      const { database_storage_mb, backup_storage_mb, total_storage_mb } = account.storage_breakdown;
+      
+      console.log(chalk.gray('  Database Storage:'), chalk.white(`${database_storage_mb.toFixed(2)} MB`));
+      console.log(chalk.gray('  Backup Storage:'), chalk.white(`${backup_storage_mb.toFixed(2)} MB`));
+      console.log(chalk.gray('  ─────────────────'));
+      console.log(chalk.gray('  Total Storage:'), chalk.cyan.bold(`${total_storage_mb.toFixed(2)} MB`));
+    } else {
+      console.log(chalk.gray('  Total Storage:'), chalk.cyan.bold(`${account.storage_total_mb.toFixed(2)} MB`));
+    }
+    
+    console.log();
+
+    // Cost information
+    console.log(chalk.white.bold('Estimated Charges:'));
+    const charges = account.estimated_charges_usd || 0;
+    console.log(chalk.gray('  Current Period:'), chalk.green.bold(`$${charges.toFixed(4)} USD`));
+    console.log();
+
+    // Pricing info
+    console.log(chalk.gray('Pricing:'));
+    console.log(chalk.gray('  Storage: $0.00014 per GB-hour'));
+    console.log(chalk.gray('  Compute: $0.000167 per minute'));
+    console.log();
+
+    // Show current team if applicable
+    if (currentTeamId) {
+      console.log(chalk.gray('Team:'), chalk.cyan(currentTeamId));
+      console.log(chalk.gray('Run'), chalk.cyan('vibedb teams list'), chalk.gray('to see all your teams.'));
+      console.log();
+    }
+
+  } catch (error) {
+    console.error(chalk.red.bold('\n✗ Failed to fetch usage:'), chalk.red(error.message));
+    process.exit(1);
+  }
+}
+
+module.exports = usageCommand;