codebakers 1.0.45 → 2.0.0

package/src/commands/gateway.ts

@@ -0,0 +1,604 @@
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import { Config } from '../utils/config.js';
+import { WhatsAppChannel } from '../channels/whatsapp.js';
+import { TelegramChannel } from '../channels/telegram.js';
+import { DiscordChannel } from '../channels/discord.js';
+import { SlackChannel } from '../channels/slack.js';
+import { SMSChannel } from '../channels/sms.js';
+
+interface GatewayOptions {
+  start?: boolean;
+  stop?: boolean;
+  status?: boolean;
+}
+
+interface ChannelInfo {
+  id: string;
+  name: string;
+  description: string;
+  icon: string;
+  connected: boolean;
+  status: 'running' | 'stopped' | 'error' | 'connecting';
+}
+
+export async function gatewayCommand(options: GatewayOptions = {}): Promise<void> {
+  const config = new Config();
+
+  p.intro(chalk.bgCyan.black(' Channel Gateway '));
+
+  // Quick actions
+  if (options.start) {
+    await startAllChannels(config);
+    return;
+  }
+
+  if (options.stop) {
+    await stopAllChannels(config);
+    return;
+  }
+
+  if (options.status) {
+    await showGatewayStatus(config);
+    return;
+  }
+
+  // Interactive menu
+  const action = await p.select({
+    message: 'What do you want to do?',
+    options: [
+      { value: 'status', label: '📊 View status', hint: 'see all channels' },
+      { value: 'connect', label: '🔗 Connect channel', hint: 'add WhatsApp, Telegram, etc.' },
+      { value: 'start', label: '▶️  Start gateway', hint: 'start receiving messages' },
+      { value: 'stop', label: '⏹️  Stop gateway', hint: 'pause all channels' },
+      { value: 'deploy', label: '🚀 Deploy to cloud', hint: 'always-on hosting' },
+      { value: 'back', label: '← Back' },
+    ],
+  });
+
+  if (p.isCancel(action) || action === 'back') {
+    return;
+  }
+
+  switch (action) {
+    case 'status':
+      await showGatewayStatus(config);
+      break;
+    case 'connect':
+      await connectChannelWizard(config);
+      break;
+    case 'start':
+      await startAllChannels(config);
+      break;
+    case 'stop':
+      await stopAllChannels(config);
+      break;
+    case 'deploy':
+      await deployGatewayWizard(config);
+      break;
+  }
+}
+
+async function showGatewayStatus(config: Config): Promise<void> {
+  const channels = await getChannelStatuses(config);
+
+  console.log(chalk.bold('\n📱 Channel Gateway Status\n'));
+
+  for (const channel of channels) {
+    const statusIcon = {
+      running: chalk.green('●'),
+      stopped: chalk.gray('○'),
+      error: chalk.red('✗'),
+      connecting: chalk.yellow('◐'),
+    }[channel.status];
+
+    const statusText = {
+      running: chalk.green('Running'),
+      stopped: chalk.gray('Stopped'),
+      error: chalk.red('Error'),
+      connecting: chalk.yellow('Connecting...'),
+    }[channel.status];
+
+    console.log(`  ${channel.icon} ${channel.name.padEnd(15)} ${statusIcon} ${statusText}`);
+  }
+
+  console.log('');
+}
+
+async function getChannelStatuses(config: Config): Promise<ChannelInfo[]> {
+  const channels: ChannelInfo[] = [
+    {
+      id: 'whatsapp',
+      name: 'WhatsApp',
+      description: 'WhatsApp via Baileys',
+      icon: '💬',
+      connected: !!config.getChannelConfig('whatsapp')?.enabled,
+      status: config.getChannelConfig('whatsapp')?.enabled ? 'stopped' : 'stopped',
+    },
+    {
+      id: 'telegram',
+      name: 'Telegram',
+      description: 'Telegram Bot API',
+      icon: '✈️',
+      connected: !!config.getChannelConfig('telegram')?.enabled,
+      status: config.getChannelConfig('telegram')?.enabled ? 'stopped' : 'stopped',
+    },
+    {
+      id: 'discord',
+      name: 'Discord',
+      description: 'Discord.js bot',
+      icon: '🎮',
+      connected: !!config.getChannelConfig('discord')?.enabled,
+      status: config.getChannelConfig('discord')?.enabled ? 'stopped' : 'stopped',
+    },
+    {
+      id: 'slack',
+      name: 'Slack',
+      description: 'Slack Bot API',
+      icon: '💼',
+      connected: !!config.getChannelConfig('slack')?.enabled,
+      status: config.getChannelConfig('slack')?.enabled ? 'stopped' : 'stopped',
+    },
+    {
+      id: 'sms',
+      name: 'SMS',
+      description: 'Twilio SMS',
+      icon: '📱',
+      connected: !!config.getCredentials('twilio')?.accountSid,
+      status: config.getCredentials('twilio')?.accountSid ? 'stopped' : 'stopped',
+    },
+  ];
+
+  return channels;
+}
+
+async function connectChannelWizard(config: Config): Promise<void> {
+  const channel = await p.select({
+    message: 'Which channel do you want to connect?',
+    options: [
+      { value: 'whatsapp', label: '💬 WhatsApp', hint: 'Personal or Business' },
+      { value: 'telegram', label: '✈️  Telegram', hint: 'Create a bot' },
+      { value: 'discord', label: '🎮 Discord', hint: 'Server bot' },
+      { value: 'slack', label: '💼 Slack', hint: 'Workspace app' },
+      { value: 'sms', label: '📱 SMS', hint: 'via Twilio' },
+      { value: 'imessage', label: '🍎 iMessage', hint: 'Mac only' },
+    ],
+  });
+
+  if (p.isCancel(channel)) return;
+
+  switch (channel) {
+    case 'whatsapp':
+      await connectWhatsApp(config);
+      break;
+    case 'telegram':
+      await connectTelegram(config);
+      break;
+    case 'discord':
+      await connectDiscord(config);
+      break;
+    case 'slack':
+      await connectSlack(config);
+      break;
+    case 'sms':
+      await connectSMS(config);
+      break;
+    case 'imessage':
+      await connectiMessage(config);
+      break;
+  }
+}
+
+async function connectWhatsApp(config: Config): Promise<void> {
+  p.log.info(chalk.bold('WhatsApp Setup'));
+  p.log.info(chalk.dim(`
+WhatsApp uses QR code authentication via Baileys library.
+Your phone needs to scan a QR code to connect.
+
+Note: This is for personal accounts. For WhatsApp Business API,
+you'll need a Meta Business account.
+`));
+
+  const proceed = await p.confirm({
+    message: 'Ready to scan QR code?',
+    initialValue: true,
+  });
+
+  if (!proceed || p.isCancel(proceed)) return;
+
+  const spinner = p.spinner();
+  spinner.start('Generating QR code...');
+
+  try {
+    // In real implementation, this would:
+    // 1. Initialize Baileys
+    // 2. Generate QR code
+    // 3. Wait for scan
+    // 4. Save session
+
+    // Simulated QR code display
+    spinner.stop('');
+    
+    console.log(chalk.cyan(`
+╔════════════════════════════════════╗
+║                                    ║
+║   ▄▄▄▄▄▄▄ ▄▄▄▄▄ ▄▄▄▄▄▄▄           ║
+║   █ ▄▄▄ █ ▀█▀▄█ █ ▄▄▄ █           ║
+║   █ ███ █ ▄▀ ▀▄ █ ███ █           ║
+║   █▄▄▄▄▄█ █ ▄▀█ █▄▄▄▄▄█           ║
+║   ▄▄▄▄▄ ▄▄▄██▀▀▄ ▄ ▄ ▄            ║
+║   ██▀▀▀▄▄▀▄▀▄▄█▀██▀▄█▄▄           ║
+║   ▄▄▄▄▄▄▄ █▄▀▄▀ ▄██▄█▄            ║
+║   █ ▄▄▄ █  █▀▀▄▄▄▄▀▄               ║
+║   █ ███ █ ▄███▄█▀█▄▄▄█            ║
+║   █▄▄▄▄▄█ ██▀▄▀▀▄█▄▀█             ║
+║                                    ║
+╚════════════════════════════════════╝
+
+Scan this QR code with WhatsApp:
+1. Open WhatsApp on your phone
+2. Go to Settings > Linked Devices
+3. Tap "Link a Device"
+4. Scan the QR code above
+`));
+
+    const connected = await p.confirm({
+      message: 'Did you scan the QR code successfully?',
+      initialValue: false,
+    });
+
+    if (connected && !p.isCancel(connected)) {
+      config.setChannelConfig('whatsapp', { enabled: true });
+      p.log.success('WhatsApp connected!');
+    }
+  } catch (error) {
+    spinner.stop('Error connecting WhatsApp');
+    p.log.error(error instanceof Error ? error.message : 'Unknown error');
+  }
+}
+
+async function connectTelegram(config: Config): Promise<void> {
+  p.log.info(chalk.bold('Telegram Bot Setup'));
+  p.log.info(chalk.dim(`
+To create a Telegram bot:
+1. Open Telegram and search for @BotFather
+2. Send /newbot
+3. Follow the prompts to name your bot
+4. Copy the API token
+`));
+
+  const openBotFather = await p.confirm({
+    message: 'Open BotFather in browser?',
+    initialValue: true,
+  });
+
+  if (openBotFather && !p.isCancel(openBotFather)) {
+    const open = (await import('open')).default;
+    await open('https://t.me/botfather');
+  }
+
+  const token = await p.text({
+    message: 'Paste your bot token:',
+    placeholder: '123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11',
+    validate: (value) => {
+      if (!value) return 'Token is required';
+      if (!value.includes(':')) return 'Invalid token format';
+      return undefined;
+    },
+  });
+
+  if (p.isCancel(token)) return;
+
+  const spinner = p.spinner();
+  spinner.start('Verifying bot token...');
+
+  try {
+    // Verify token by calling getMe
+    const response = await fetch(`https://api.telegram.org/bot${token}/getMe`);
+    const data = await response.json();
+
+    if (!data.ok) {
+      throw new Error(data.description || 'Invalid token');
+    }
+
+    spinner.stop('Bot verified!');
+    
+    config.setChannelConfig('telegram', {
+      enabled: true,
+      botToken: token,
+      botUsername: data.result.username,
+    });
+
+    p.log.success(`Connected to @${data.result.username}`);
+  } catch (error) {
+    spinner.stop('Verification failed');
+    p.log.error(error instanceof Error ? error.message : 'Invalid token');
+  }
+}
+
+async function connectDiscord(config: Config): Promise<void> {
+  p.log.info(chalk.bold('Discord Bot Setup'));
+  p.log.info(chalk.dim(`
+To create a Discord bot:
+1. Go to Discord Developer Portal
+2. Create a new application
+3. Go to Bot section
+4. Create a bot and copy the token
+5. Enable necessary intents (Message Content)
+`));
+
+  const openPortal = await p.confirm({
+    message: 'Open Discord Developer Portal?',
+    initialValue: true,
+  });
+
+  if (openPortal && !p.isCancel(openPortal)) {
+    const open = (await import('open')).default;
+    await open('https://discord.com/developers/applications');
+  }
+
+  const token = await p.text({
+    message: 'Paste your bot token:',
+    placeholder: 'MTIzNDU2Nzg5MDEyMzQ1Njc4.Gg1234.abc...',
+  });
+
+  if (p.isCancel(token) || !token) return;
+
+  const clientId = await p.text({
+    message: 'Paste your application (client) ID:',
+    placeholder: '123456789012345678',
+  });
+
+  if (p.isCancel(clientId) || !clientId) return;
+
+  config.setChannelConfig('discord', {
+    enabled: true,
+    botToken: token,
+    clientId: clientId,
+  });
+
+  // Generate invite URL
+  const inviteUrl = `https://discord.com/api/oauth2/authorize?client_id=${clientId}&permissions=2048&scope=bot`;
+  
+  p.log.success('Discord bot configured!');
+  p.log.info(`Add bot to server: ${inviteUrl}`);
+}
+
+async function connectSlack(config: Config): Promise<void> {
+  p.log.info(chalk.bold('Slack App Setup'));
+  p.log.info(chalk.dim(`
+To create a Slack app:
+1. Go to Slack API portal
+2. Create a new app
+3. Add bot scopes (chat:write, app_mentions:read, etc.)
+4. Install to workspace
+5. Copy the Bot Token
+`));
+
+  const openSlack = await p.confirm({
+    message: 'Open Slack API portal?',
+    initialValue: true,
+  });
+
+  if (openSlack && !p.isCancel(openSlack)) {
+    const open = (await import('open')).default;
+    await open('https://api.slack.com/apps');
+  }
+
+  const token = await p.text({
+    message: 'Paste your Bot User OAuth Token:',
+    placeholder: 'xoxb-...',
+    validate: (value) => {
+      if (!value) return 'Token is required';
+      if (!value.startsWith('xoxb-')) return 'Should start with xoxb-';
+      return undefined;
+    },
+  });
+
+  if (p.isCancel(token)) return;
+
+  config.setChannelConfig('slack', {
+    enabled: true,
+    botToken: token,
+  });
+
+  p.log.success('Slack app configured!');
+}
+
+async function connectSMS(config: Config): Promise<void> {
+  p.log.info(chalk.bold('SMS via Twilio'));
+
+  const twilioConfig = config.getCredentials('twilio');
+  
+  if (twilioConfig?.accountSid) {
+    p.log.info('Twilio is already configured.');
+    
+    const reconfigure = await p.confirm({
+      message: 'Reconfigure Twilio?',
+      initialValue: false,
+    });
+
+    if (!reconfigure || p.isCancel(reconfigure)) {
+      config.setChannelConfig('sms', { enabled: true });
+      p.log.success('SMS channel enabled!');
+      return;
+    }
+  }
+
+  const openTwilio = await p.confirm({
+    message: 'Open Twilio Console?',
+    initialValue: true,
+  });
+
+  if (openTwilio && !p.isCancel(openTwilio)) {
+    const open = (await import('open')).default;
+    await open('https://console.twilio.com/');
+  }
+
+  const accountSid = await p.text({
+    message: 'Account SID:',
+    placeholder: 'AC...',
+  });
+
+  if (p.isCancel(accountSid)) return;
+
+  const authToken = await p.text({
+    message: 'Auth Token:',
+    placeholder: '...',
+  });
+
+  if (p.isCancel(authToken)) return;
+
+  const phoneNumber = await p.text({
+    message: 'Twilio phone number:',
+    placeholder: '+1234567890',
+  });
+
+  if (p.isCancel(phoneNumber)) return;
+
+  config.setCredentials('twilio', {
+    accountSid: accountSid as string,
+    authToken: authToken as string,
+    phoneNumber: phoneNumber as string,
+  });
+
+  config.setChannelConfig('sms', { enabled: true });
+  p.log.success('SMS channel configured!');
+}
+
+async function connectiMessage(config: Config): Promise<void> {
+  p.log.warn('iMessage support requires macOS and additional setup.');
+  p.log.info(chalk.dim(`
+iMessage integration uses AppleScript on macOS.
+This requires:
+1. macOS with Messages app
+2. iCloud signed in
+3. Terminal with accessibility permissions
+`));
+
+  const isMac = process.platform === 'darwin';
+  
+  if (!isMac) {
+    p.log.error('iMessage is only available on macOS.');
+    return;
+  }
+
+  // Would check for accessibility permissions and configure
+  p.log.info('iMessage support coming soon.');
+}
+
+async function startAllChannels(config: Config): Promise<void> {
+  const spinner = p.spinner();
+  spinner.start('Starting channel gateway...');
+
+  // In real implementation, this would start all enabled channels
+  await new Promise(resolve => setTimeout(resolve, 1000));
+
+  spinner.stop('Gateway started');
+  
+  console.log(chalk.green(`
+╔═══════════════════════════════════════╗
+║  Gateway is running!                  ║
+║                                       ║
+║  You can now receive messages from:   ║
+║  • WhatsApp  • Telegram  • Discord    ║
+║  • Slack     • SMS                    ║
+║                                       ║
+║  Press Ctrl+C to stop                 ║
+╚═══════════════════════════════════════╝
+`));
+}
+
+async function stopAllChannels(config: Config): Promise<void> {
+  const spinner = p.spinner();
+  spinner.start('Stopping gateway...');
+
+  await new Promise(resolve => setTimeout(resolve, 500));
+
+  spinner.stop('Gateway stopped');
+}
+
+async function deployGatewayWizard(config: Config): Promise<void> {
+  p.log.info(chalk.bold('Deploy Gateway to Cloud'));
+
+  const platform = await p.select({
+    message: 'Where do you want to deploy?',
+    options: [
+      { value: 'codebakers', label: '☁️  CodeBakers Cloud', hint: '$29/mo - We handle everything' },
+      { value: 'vps', label: '🖥️  VPS', hint: '$5/mo - DigitalOcean, etc.' },
+      { value: 'local', label: '🏠 Home server', hint: 'Raspberry Pi, etc.' },
+    ],
+  });
+
+  if (p.isCancel(platform)) return;
+
+  switch (platform) {
+    case 'codebakers':
+      p.log.info('CodeBakers Cloud coming soon!');
+      p.log.info(chalk.dim('Sign up at https://codebakers.dev/cloud'));
+      break;
+    
+    case 'vps':
+      await deployToVPS(config);
+      break;
+    
+    case 'local':
+      p.log.info('Local deployment guide:');
+      p.log.info(chalk.dim(`
+1. Install Node.js on your server
+2. Clone your project
+3. Run: npm install
+4. Run: pm2 start codebakers -- gateway --start
+5. Configure firewall to allow outbound connections
+`));
+      break;
+  }
+}
+
+async function deployToVPS(config: Config): Promise<void> {
+  const provider = await p.select({
+    message: 'Which VPS provider?',
+    options: [
+      { value: 'digitalocean', label: 'DigitalOcean' },
+      { value: 'vultr', label: 'Vultr' },
+      { value: 'linode', label: 'Linode' },
+      { value: 'hetzner', label: 'Hetzner' },
+      { value: 'other', label: 'Other' },
+    ],
+  });
+
+  if (p.isCancel(provider)) return;
+
+  if (provider === 'digitalocean') {
+    p.log.info('DigitalOcean auto-deploy:');
+    p.log.info(chalk.dim(`
+1. Opening DigitalOcean login...
+2. We'll create a $6/mo droplet
+3. Install CodeBakers gateway
+4. Connect all your channels
+`));
+
+    const proceed = await p.confirm({
+      message: 'Open DigitalOcean?',
+      initialValue: true,
+    });
+
+    if (proceed && !p.isCancel(proceed)) {
+      const open = (await import('open')).default;
+      await open('https://cloud.digitalocean.com/');
+    }
+  } else {
+    p.log.info(chalk.dim(`
+Manual VPS setup:
+
+1. Create a VPS (Ubuntu 22.04 recommended)
+2. SSH into your server
+3. Run these commands:
+
+   curl -fsSL https://codebakers.dev/install.sh | bash
+   codebakers gateway --start
+
+4. Your gateway will start automatically on boot
+`));
+  }
+}