create-bunspace 0.1.0

package/templates/telegram-bot/tools/commands/ngrok.ts

@@ -0,0 +1,207 @@
+import { Command } from 'commander'
+import { config as loadEnv } from 'dotenv'
+import { readFile, writeFile } from 'fs/promises'
+import { resolve } from 'path'
+import { existsSync } from 'fs'
+import chalk from 'chalk'
+import type { BotCommand } from './index.js'
+
+// Simple logger for CLI (independent of bot's logger)
+const cliLogger = {
+  info: (msg: string) => console.log(chalk.blue('ℹ'), msg),
+  success: (msg: string) => console.log(chalk.green('✓'), msg),
+  error: (msg: string) => console.error(chalk.red('✗'), msg),
+  warn: (msg: string) => console.log(chalk.yellow('⚠'), msg),
+}
+
+interface NgrokCommand extends BotCommand {
+  name: 'ngrok'
+  description: string
+  register: (program: Command) => void
+}
+
+const command: NgrokCommand = {
+  name: 'ngrok',
+  description: 'Start ngrok tunnel for webhook testing',
+
+  register(program: Command) {
+    program
+      .command('ngrok')
+      .description('Start ngrok tunnel for webhook testing')
+      .option('-p, --port <port>', 'Port to forward (default: 3000)', '3000')
+      .option('-e, --environment <env>', 'Environment (local|staging|production)', 'local')
+      .option('-w, --webhook-url', 'Auto-update webhook URL in .env', false)
+      .option('-s, --start-bot', 'Auto-start bot after ngrok', false)
+      .option('-f, --force', 'Force start even if conflict detected', false)
+      .action(async (options) => {
+        await handleNgrok(options)
+      })
+  },
+}
+
+export default command
+
+async function handleNgrok(options: {
+  port: string
+  environment: string
+  webhookUrl: boolean
+  startBot: boolean
+  force: boolean
+}): Promise<void> {
+  const env = options.environment || 'local'
+
+  // Determine environment file path
+  const envPath = resolve(`./core/.env.${env}`)
+
+  // Check if environment file exists
+  if (!existsSync(envPath)) {
+    cliLogger.error(`Environment file not found: ${chalk.cyan(envPath)}`)
+    cliLogger.info(`Create it first or use ${chalk.yellow('--environment local')}`)
+    process.exit(1)
+  }
+
+  // Load environment file
+  loadEnv({ path: envPath })
+
+  cliLogger.info(`Starting ngrok for ${chalk.cyan(env)}`)
+
+  // Check instance conflicts if not forced
+  if (!options.force) {
+    const lockFiles = await discoverLockFiles()
+    const conflictingInstance = lockFiles.find((lockFile) => {
+      const instanceEnv = lockFile.split('/').pop()?.replace('.lock', '').replace('mks-bot-', '') || ''
+      return instanceEnv === env
+    })
+
+    if (conflictingInstance) {
+      cliLogger.warn(`Possible instance conflict detected for ${chalk.cyan(env)}`)
+      cliLogger.info(`Use ${chalk.yellow('--force')} to start anyway`)
+    }
+  }
+
+  // Check ngrok installation
+  const ngrokCheck = Bun.spawn(['ngrok', 'version'], {
+    stdout: 'pipe',
+    stderr: 'pipe',
+  })
+
+  const ngrokVersion = await ngrokCheck.exited
+  if (ngrokVersion !== 0) {
+    cliLogger.error('ngrok not found. Install from https://ngrok.com/download')
+    process.exit(1)
+  }
+
+  cliLogger.info(`Starting ngrok tunnel for port ${options.port}`)
+
+  const ngrokProcess = Bun.spawn(['ngrok', 'http', options.port], {
+    stdout: 'inherit',
+    stderr: 'inherit',
+  })
+
+  // Wait a bit for ngrok to start and get the URL
+  await new Promise((resolve) => setTimeout(resolve, 2000))
+
+  // Try to get the tunnel URL from ngrok API
+  const tunnelUrl = await getNgrokTunnelUrl()
+
+  if (tunnelUrl) {
+    cliLogger.success(`Tunnel: ${chalk.underline(tunnelUrl)}`)
+
+    // Auto-update webhook URL if requested
+    if (options.webhookUrl) {
+      await updateEnvFile(envPath, {
+        TG_WEBHOOK_URL: tunnelUrl,
+        TG_MODE: 'webhook',
+        TG_NGROK_ENABLED: 'true',
+      })
+      cliLogger.success(`Updated ${chalk.cyan(envPath)}`)
+    }
+  } else {
+    cliLogger.warn('Could not detect tunnel URL. Check ngrok output above.')
+  }
+
+  if (options.startBot) {
+    cliLogger.info('Starting bot...')
+
+    const botProcess = Bun.spawn(['bun', 'run', 'start'], {
+      cwd: resolve('.'),
+      stdout: 'inherit',
+      stderr: 'inherit',
+      env: {
+        ...process.env,
+        TG_ENV: env,
+      },
+    })
+
+    process.on('SIGINT', () => {
+      cliLogger.warn('Shutting down...')
+      ngrokProcess.kill()
+      botProcess.kill()
+      process.exit(0)
+    })
+  } else {
+    process.on('SIGINT', () => {
+      cliLogger.warn('Stopping ngrok...')
+      ngrokProcess.kill()
+      process.exit(0)
+    })
+  }
+
+  await ngrokProcess.exited
+}
+
+async function discoverLockFiles(): Promise<string[]> {
+  const { glob } = await import('glob')
+  try {
+    return await glob('core/tmp/*.lock', { absolute: true })
+  } catch {
+    return []
+  }
+}
+
+interface NgrokApiTunnel {
+  public_url: string
+  proto: string
+  name: string
+}
+
+interface NgrokApiResponse {
+  tunnels: NgrokApiTunnel[]
+  uri: string
+}
+
+async function getNgrokTunnelUrl(): Promise<string | null> {
+  try {
+    const response = await fetch('http://127.0.0.1:4040/api/tunnels')
+    if (!response.ok) {
+      return null
+    }
+    const data = (await response.json()) as NgrokApiResponse
+    // eslint-disable-next-line ts/no-unnecessary-condition -- Runtime check
+    if (data.tunnels && data.tunnels.length > 0) {
+      return data.tunnels[0]?.public_url ?? null
+    }
+  } catch {
+    return null
+  }
+  return null
+}
+
+async function updateEnvFile(
+  path: string,
+  updates: Record<string, string>
+): Promise<void> {
+  const content = await readFile(path, 'utf-8')
+  const lines = content.split('\n')
+
+  const updated = lines.map((line) => {
+    for (const [key, value] of Object.entries(updates)) {
+      if (line.startsWith(`${key}=`)) {
+        return `${key}=${value}`
+      }
+    }
+    return line
+  })
+
+  await writeFile(path, updated.join('\n'))
+}

package/templates/telegram-bot/tools/commands/setup.ts

@@ -0,0 +1,368 @@
+import { Command } from 'commander'
+import { readFile, writeFile, copyFile } from 'fs/promises'
+import { existsSync } from 'fs'
+import { join } from 'path'
+import chalk from 'chalk'
+import { input, select, confirm } from '@inquirer/prompts'
+import type { BotCommand } from './index.js'
+
+const cliLogger = {
+  info: (msg: string) => console.log(chalk.blue('ℹ'), msg),
+  success: (msg: string) => console.log(chalk.green('✓'), msg),
+  error: (msg: string) => console.error(chalk.red('✗'), msg),
+  warn: (msg: string) => console.log(chalk.yellow('⚠'), msg),
+  title: (msg: string) => console.log(chalk.cyan.bold('\n' + msg + '\n')),
+}
+
+interface SetupCommand extends BotCommand {
+  name: 'setup'
+  description: string
+  register: (program: Command) => void
+}
+
+interface SetupOptions {
+  token?: string
+  mode?: 'polling' | 'webhook'
+  environment?: 'local' | 'staging' | 'production'
+}
+
+interface SetupConfig {
+  TG_BOT_TOKEN: string
+  TG_MODE: 'polling' | 'webhook'
+  TG_WEBHOOK_URL?: string
+  TG_WEBHOOK_SECRET?: string
+  TG_ENV: string
+  TG_INSTANCE_NAME: string
+  TG_LOG_CHAT_ID?: string
+  TG_LOG_TOPIC_ID?: number
+  TG_CONTROL_CHAT_ID?: string
+  TG_CONTROL_TOPIC_ID?: number
+  TG_AUTHORIZED_USER_IDS?: string
+  LOG_LEVEL?: string
+}
+
+const command: SetupCommand = {
+  name: 'setup',
+  description: 'Interactive environment setup',
+
+  register(program: Command) {
+    program
+      .command('setup')
+      .description('Configure environment variables interactively')
+      .option('-t, --token <value>', 'Bot token from @BotFather')
+      .option('-m, --mode <polling|webhook>', 'Bot operation mode')
+      .option('-e, --environment <local|staging|production>', 'Target environment', 'local')
+      .action(async (options) => {
+        await handleSetup(options)
+      })
+  },
+}
+
+export default command
+
+async function handleSetup(options: SetupOptions): Promise<void> {
+  cliLogger.title('mks-telegram-bot Setup')
+
+  const environment = options.environment ?? 'local'
+  const envFile = join(process.cwd(), 'core', `.env.${environment}`)
+  const envExample = join(process.cwd(), 'core', '.env.example')
+
+  // Check if .env file already exists
+  if (existsSync(envFile)) {
+    cliLogger.warn(`Environment file already exists: ${envFile}`)
+
+    const shouldContinue = await confirm({
+      message: 'Do you want to overwrite it?',
+      default: false,
+    })
+
+    if (!shouldContinue) {
+      cliLogger.info('Setup cancelled')
+      return
+    }
+  }
+
+  // Copy .env.example to .env.{environment}
+  if (!existsSync(envFile) && existsSync(envExample)) {
+    await copyFile(envExample, envFile)
+    cliLogger.success(`Created ${envFile}`)
+  }
+
+  // Read existing env file to preserve comments
+  let envContent = ''
+  if (existsSync(envFile)) {
+    envContent = await readFile(envFile, 'utf-8')
+  }
+
+  // Interactive prompts (skip if provided via flags)
+  const config: SetupConfig = await gatherConfig(options, envContent)
+
+  // Update env file
+  const updatedContent = updateEnvFile(envContent, config)
+  await writeFile(envFile, updatedContent, 'utf-8')
+
+  cliLogger.success(`Environment configured: ${envFile}`)
+  cliLogger.info('\nNext steps:')
+  cliLogger.info('  1. Review the configuration in the env file')
+  cliLogger.info('  2. Run: bun run dev')
+  cliLogger.info('  3. Send /start to your bot in Telegram')
+
+  // Validate token if provided
+  if (config.TG_BOT_TOKEN) {
+    await validateToken(config.TG_BOT_TOKEN)
+  }
+}
+
+async function gatherConfig(options: SetupOptions, _envContent: string): Promise<SetupConfig> {
+  const config: Partial<SetupConfig> = {}
+
+  // Bot token
+  if (options.token) {
+    config.TG_BOT_TOKEN = options.token
+  } else {
+    cliLogger.info('\nTo get a bot token, open Telegram and talk to @BotFather:')
+    cliLogger.info('  1. Send /newbot')
+    cliLogger.info('  2. Choose a name for your bot')
+    cliLogger.info('  3. Choose a username (must end in "bot")')
+    cliLogger.info('  4. Copy the token provided\n')
+
+    config.TG_BOT_TOKEN = await input({
+      message: 'Enter your bot token:',
+      validate: (value: string) => {
+        if (!value || value.trim().length === 0) {
+          return 'Bot token is required'
+        }
+        if (!value.includes(':')) {
+          return 'Invalid token format (should be like 123456:ABC-DEF1234...)'
+        }
+        return true
+      },
+    })
+  }
+
+  // Mode
+  if (options.mode) {
+    config.TG_MODE = options.mode
+  } else {
+    const modeSelection = await select({
+      message: 'Select bot operation mode:',
+      choices: [
+        { name: 'Polling (recommended for development)', value: 'polling' },
+        { name: 'Webhook (recommended for production)', value: 'webhook' },
+      ],
+    })
+    config.TG_MODE = modeSelection as 'polling' | 'webhook'
+  }
+
+  // Webhook configuration (if webhook mode)
+  if (config.TG_MODE === 'webhook') {
+    cliLogger.warn('\nWebhook mode requires a public HTTPS endpoint')
+
+    config.TG_WEBHOOK_URL = await input({
+      message: 'Enter webhook URL (https://your-domain.com/webhook):',
+      validate: (value: string) => {
+        if (!value || value.trim().length === 0) {
+          return 'Webhook URL is required for webhook mode'
+        }
+        if (!value.startsWith('https://')) {
+          return 'Webhook URL must use HTTPS'
+        }
+        return true
+      },
+    })
+
+    config.TG_WEBHOOK_SECRET = await input({
+      message: 'Enter webhook secret (min 16 chars):',
+      validate: (value: string) => {
+        if (!value || value.length < 16) {
+          return 'Webhook secret must be at least 16 characters'
+        }
+        return true
+      },
+    })
+  }
+
+  // Environment identification
+  const envSelection = await select({
+    message: 'Select environment:',
+    choices: [
+      { name: 'Local (development)', value: 'local' },
+      { name: 'Staging (testing)', value: 'staging' },
+      { name: 'Production', value: 'production' },
+    ],
+    default: options.environment ?? 'local',
+  })
+  config.TG_ENV = envSelection
+
+  // Instance name
+  config.TG_INSTANCE_NAME = await input({
+    message: 'Enter instance name:',
+    default: 'mks-bot',
+    validate: (value: string) => {
+      if (!value || value.trim().length === 0) {
+        return 'Instance name is required'
+      }
+      return true
+    },
+  })
+
+  // Optional: Log streaming
+  const enableLogStreaming = await confirm({
+    message: 'Enable log streaming to Telegram?',
+    default: false,
+  })
+
+  if (enableLogStreaming) {
+    cliLogger.info('\nTo get chat IDs:')
+    cliLogger.info('  1. Add your bot to a group or channel')
+    cliLogger.info('  2. Send a message to the bot')
+    cliLogger.info('  3. Use: bun run cli status --json to see updates')
+    cliLogger.info('  4. Or use @GetTelegraphBot in Telegram\n')
+
+    config.TG_LOG_CHAT_ID = await input({
+      message: 'Enter log chat ID (optional, press Enter to skip):',
+    })
+
+    if (config.TG_LOG_CHAT_ID && config.TG_LOG_CHAT_ID.trim().length > 0) {
+      const useTopic = await confirm({
+        message: 'Use a topic for log messages?',
+        default: false,
+      })
+
+      if (useTopic) {
+        const topicId = await input({
+          message: 'Enter topic ID:',
+          validate: (value: string) => {
+            const num = Number.parseInt(value, 10)
+            if (Number.isNaN(num)) {
+              return 'Topic ID must be a number'
+            }
+            return true
+          },
+        })
+        config.TG_LOG_TOPIC_ID = Number.parseInt(topicId, 10)
+      }
+    }
+  }
+
+  // Optional: Control commands
+  const enableControl = await confirm({
+    message: 'Enable control commands (/stop, /restart, etc.)?',
+    default: false,
+  })
+
+  if (enableControl) {
+    config.TG_CONTROL_CHAT_ID = await input({
+      message: 'Enter control chat ID:',
+    })
+
+    if (config.TG_CONTROL_CHAT_ID && config.TG_CONTROL_CHAT_ID.trim().length > 0) {
+      const useTopic = await confirm({
+        message: 'Use a topic for control messages?',
+        default: false,
+      })
+
+      if (useTopic) {
+        const topicId = await input({
+          message: 'Enter topic ID:',
+          validate: (value: string) => {
+            const num = Number.parseInt(value, 10)
+            if (Number.isNaN(num)) {
+              return 'Topic ID must be a number'
+            }
+            return true
+          },
+        })
+        config.TG_CONTROL_TOPIC_ID = Number.parseInt(topicId, 10)
+      }
+    }
+
+    // Authorized users
+    const authUsers = await input({
+      message: 'Enter authorized user IDs (comma-separated):',
+    })
+
+    if (authUsers && authUsers.trim().length > 0) {
+      config.TG_AUTHORIZED_USER_IDS = authUsers
+    }
+  }
+
+  // Log level
+  const logLevel = await select({
+    message: 'Select log level:',
+    choices: [
+      { name: 'Debug (verbose)', value: 'debug' },
+      { name: 'Info (default)', value: 'info' },
+      { name: 'Warnings only', value: 'warn' },
+      { name: 'Errors only', value: 'error' },
+    ],
+    default: 'info',
+  })
+  config.LOG_LEVEL = logLevel
+
+  return config as SetupConfig
+}
+
+function updateEnvFile(content: string, config: SetupConfig): string {
+  const lines = content.split('\n')
+  const updated: string[] = []
+
+  for (const line of lines) {
+    // Skip empty lines and comments
+    if (line.trim().length === 0 || line.trim().startsWith('#')) {
+      updated.push(line)
+      continue
+    }
+
+    const [key] = line.split('=')
+
+    // Update matching keys
+    if (key === 'TG_BOT_TOKEN' && config.TG_BOT_TOKEN !== undefined) {
+      updated.push(`${key}=${config.TG_BOT_TOKEN}`)
+    } else if (key === 'TG_MODE' && config.TG_MODE !== undefined) {
+      updated.push(`${key}=${config.TG_MODE}`)
+    } else if (key === 'TG_WEBHOOK_URL' && config.TG_WEBHOOK_URL !== undefined) {
+      updated.push(`${key}=${config.TG_WEBHOOK_URL}`)
+    } else if (key === 'TG_WEBHOOK_SECRET' && config.TG_WEBHOOK_SECRET !== undefined) {
+      updated.push(`${key}=${config.TG_WEBHOOK_SECRET}`)
+    } else if (key === 'TG_ENV' && config.TG_ENV !== undefined) {
+      updated.push(`${key}=${config.TG_ENV}`)
+    } else if (key === 'TG_INSTANCE_NAME' && config.TG_INSTANCE_NAME !== undefined) {
+      updated.push(`${key}=${config.TG_INSTANCE_NAME}`)
+    } else if (key === 'TG_LOG_CHAT_ID' && config.TG_LOG_CHAT_ID !== undefined) {
+      updated.push(`${key}=${config.TG_LOG_CHAT_ID}`)
+    } else if (key === 'TG_LOG_TOPIC_ID' && config.TG_LOG_TOPIC_ID !== undefined) {
+      updated.push(`${key}=${config.TG_LOG_TOPIC_ID}`)
+    } else if (key === 'TG_CONTROL_CHAT_ID' && config.TG_CONTROL_CHAT_ID !== undefined) {
+      updated.push(`${key}=${config.TG_CONTROL_CHAT_ID}`)
+    } else if (key === 'TG_CONTROL_TOPIC_ID' && config.TG_CONTROL_TOPIC_ID !== undefined) {
+      updated.push(`${key}=${config.TG_CONTROL_TOPIC_ID}`)
+    } else if (key === 'TG_AUTHORIZED_USER_IDS' && config.TG_AUTHORIZED_USER_IDS !== undefined) {
+      updated.push(`${key}=${config.TG_AUTHORIZED_USER_IDS}`)
+    } else if (key === 'LOG_LEVEL' && config.LOG_LEVEL !== undefined) {
+      updated.push(`${key}=${config.LOG_LEVEL}`)
+    } else {
+      updated.push(line)
+    }
+  }
+
+  return updated.join('\n')
+}
+
+async function validateToken(token: string): Promise<void> {
+  cliLogger.info('\nValidating bot token with Telegram API...')
+
+  try {
+    const response = await fetch(`https://api.telegram.org/bot${token}/getMe`)
+    const data = (await response.json()) as { ok: boolean; result?: { username: string; first_name: string } }
+
+    if (data.ok && data.result) {
+      cliLogger.success(`Bot connected: @${data.result.username} (${data.result.first_name})`)
+    } else {
+      cliLogger.warn('Could not validate token. The bot may not work correctly.')
+      cliLogger.info('Make sure the token is correct and try again.')
+    }
+  } catch {
+    cliLogger.warn('Could not reach Telegram API. Check your internet connection.')
+  }
+}

package/templates/telegram-bot/tools/commands/status.ts

@@ -0,0 +1,140 @@
+import { Command } from 'commander'
+import { readFile } from 'fs/promises'
+import { existsSync } from 'fs'
+import { glob } from 'glob'
+import chalk from 'chalk'
+import type { BotCommand } from './index.js'
+
+const cliLogger = {
+  info: (msg: string) => console.log(chalk.blue('ℹ'), msg),
+  success: (msg: string) => console.log(chalk.green('✓'), msg),
+  error: (msg: string) => console.error(chalk.red('✗'), msg),
+  warn: (msg: string) => console.log(chalk.yellow('⚠'), msg),
+}
+
+interface StatusCommand extends BotCommand {
+  name: 'status'
+  description: string
+  register: (program: Command) => void
+}
+
+interface InstanceInfo {
+  pid: number
+  instanceId: string
+  environment: string
+  instanceName: string
+  startTime: string
+  nodeVersion: string
+  cwd: string
+  running: boolean
+  uptime: string
+}
+
+const command: StatusCommand = {
+  name: 'status',
+  description: 'Show running bot instances',
+
+  register(program: Command) {
+    program
+      .command('status')
+      .description('Show all running bot instances')
+      .option('-j, --json', 'Output as JSON')
+      .action(async (options) => {
+        await handleStatus(options)
+      })
+  },
+}
+
+export default command
+
+async function handleStatus(options: { json?: boolean }): Promise<void> {
+  const instances = await discoverInstances()
+
+  if (instances.length === 0) {
+    cliLogger.warn('No instances found')
+    return
+  }
+
+  if (options.json) {
+    console.log(JSON.stringify(instances, null, 2))
+  } else {
+    displayInstancesTable(instances)
+  }
+}
+
+async function discoverInstances(): Promise<InstanceInfo[]> {
+  const instances: InstanceInfo[] = []
+
+  try {
+    const lockFiles = await glob('core/tmp/*.lock', { absolute: false })
+
+    // Sequential file loading is intentional for error handling
+    /* oxlint-disable no-await-in-loop */
+    for (const lockFile of lockFiles) {
+      try {
+        if (!existsSync(lockFile)) {
+          continue
+        }
+
+        const content = await readFile(lockFile, 'utf-8')
+        const lockData = JSON.parse(content)
+
+        instances.push({
+          ...lockData,
+          running: isProcessRunning(lockData.pid),
+          uptime: calculateUptime(lockData.startTime),
+        })
+      } catch {
+        // Skip invalid lock files
+        // oxlint-disable-next-line no-console -- Intentional logging
+        cliLogger.warn(`Failed to read ${lockFile}`)
+      }
+    }
+    /* oxlint-enable no-await-in-loop */
+  } catch {
+    cliLogger.error('Failed to scan for instances')
+  }
+
+  return instances
+}
+
+function isProcessRunning(pid: number): boolean {
+  try {
+    process.kill(pid, 0)
+    return true
+  } catch {
+    return false
+  }
+}
+
+function calculateUptime(startTime: string): string {
+  const start = new Date(startTime)
+  const now = new Date()
+  const diff = now.getTime() - start.getTime()
+
+  const seconds = Math.floor(diff / 1000)
+  const minutes = Math.floor(seconds / 60)
+  const hours = Math.floor(minutes / 60)
+  const days = Math.floor(hours / 24)
+
+  if (days > 0) return `${days}d ${hours % 24}h`
+  if (hours > 0) return `${hours}h ${minutes % 60}m`
+  if (minutes > 0) return `${minutes}m ${seconds % 60}s`
+  return `${seconds}s`
+}
+
+function displayInstancesTable(instances: InstanceInfo[]): void {
+  const tableData = instances.map((i) => ({
+    PID: i.pid.toString(),
+    Environment: i.environment,
+    Name: i.instanceName,
+    Status: i.running
+      ? chalk.green('✓ Running')
+      : chalk.red('✗ Stopped'),
+    Uptime: i.uptime,
+  }))
+
+  console.log('')
+  console.table(tableData)
+  console.log('')
+}