create-bunspace 0.1.0

package/templates/telegram-bot/core/src/utils/bot-manager.ts

@@ -0,0 +1,201 @@
+import type { Telegraf } from 'telegraf'
+import type { BotStatus, BotStats } from '../types/bot.js'
+import { ok, type Result, err, type BotError } from './result.js'
+import { botError } from '../types/result.js'
+import { botLogger, badge, kv, colors, colorText } from '../middleware/logging.js'
+import { getConfig } from '../config/index.js'
+
+class BotManager {
+  private bot: Telegraf | null = null
+  private startTime: number | null = null
+  private stats: BotStats = {
+    messagesProcessed: 0,
+    commandsExecuted: 0,
+    errorsEncountered: 0,
+    uptimeStart: 0,
+    lastActivity: 0,
+  }
+
+  constructor() {
+    this.stats.uptimeStart = Date.now()
+  }
+
+  setBot(bot: Telegraf): void {
+    this.bot = bot
+    this.startTime = Date.now()
+
+    botLogger.info(
+      `${badge('BOT', 'pill')} ${kv({
+        status: colorText('set', colors.success),
+      })}`
+    )
+  }
+
+  getStatus(): Result<BotStatus, BotError> {
+    const config = getConfig()
+    const uptime = this.startTime ? Date.now() - this.startTime : 0
+
+    return ok({
+      status: this.bot ? 'running' : 'stopped',
+      mode: config.mode,
+      startTime: this.startTime,
+      uptime,
+      memoryUsage: process.memoryUsage(),
+    })
+  }
+
+  getStats(): Result<BotStats, BotError> {
+    return ok({ ...this.stats })
+  }
+
+  incrementMessages(): void {
+    this.stats.messagesProcessed++
+    this.stats.lastActivity = Date.now()
+
+    botLogger.debug(
+      `${badge('STATS', 'rounded')} ${kv({
+        messages: this.stats.messagesProcessed,
+      })}`
+    )
+  }
+
+  incrementCommands(): void {
+    this.stats.commandsExecuted++
+    this.stats.lastActivity = Date.now()
+
+    botLogger.debug(
+      `${badge('STATS', 'rounded')} ${kv({
+        commands: this.stats.commandsExecuted,
+      })}`
+    )
+  }
+
+  incrementErrors(): void {
+    this.stats.errorsEncountered++
+    this.stats.lastActivity = Date.now()
+
+    botLogger.debug(
+      `${badge('STATS', 'rounded')} ${kv({
+        errors: this.stats.errorsEncountered,
+      })}`
+    )
+  }
+
+  resetStats(): Result<void, BotError> {
+    const oldStats = { ...this.stats }
+
+    this.stats = {
+      messagesProcessed: 0,
+      commandsExecuted: 0,
+      errorsEncountered: 0,
+      uptimeStart: Date.now(),
+      lastActivity: 0,
+    }
+    this.startTime = Date.now()
+
+    botLogger.info(
+      `${badge('STATS', 'rounded')} ${kv({
+        action: colorText('reset', colors.warning),
+        previous: kv({
+          messages: oldStats.messagesProcessed,
+          commands: oldStats.commandsExecuted,
+          errors: oldStats.errorsEncountered,
+        }),
+      })}`
+    )
+
+    return ok(undefined)
+  }
+
+  authorize(userId: number): Result<void, BotError> {
+    const config = getConfig()
+
+    if (!config.authorizedUserIds.has(userId)) {
+      return err(botError('UNAUTHORIZED', `User ${userId} is not authorized`))
+    }
+
+    return ok(undefined)
+  }
+
+  async start(bot: Telegraf, mode?: 'polling' | 'webhook'): Promise<Result<void, BotError>> {
+    const config = getConfig()
+    const targetMode = mode || config.mode
+
+    if (targetMode === 'webhook' && !config.webhookUrl) {
+      return err(botError('WEBHOOK_NOT_CONFIGURED', 'Webhook URL not configured'))
+    }
+
+    this.bot = bot
+    this.startTime = Date.now()
+
+    if (targetMode === 'webhook') {
+      botLogger.info(
+        `${badge('BOT', 'pill')} ${kv({
+          action: colorText('start', colors.success),
+          mode: colorText('webhook', colors.info),
+          url: config.webhookUrl ?? 'none',
+        })}`
+      )
+    } else {
+      botLogger.info(
+        `${badge('BOT', 'pill')} ${kv({
+          action: colorText('start', colors.success),
+          mode: colorText('polling', colors.info),
+        })}`
+      )
+    }
+
+    return ok(undefined)
+  }
+
+  async stop(reason?: string): Promise<Result<void, BotError>> {
+    if (!this.bot) {
+      return err(botError('BOT_NOT_RUNNING', 'Bot is not running'))
+    }
+
+    botLogger.info(
+      `${badge('BOT', 'pill')} ${kv({
+        action: colorText('stop', colors.warning),
+        reason: colorText(reason || 'manual', colors.dim),
+        uptime: this.startTime ? formatDuration(Date.now() - this.startTime) : 'unknown',
+      })}`
+    )
+
+    this.bot.stop(reason || 'SIGINT')
+    this.bot = null
+    this.startTime = null
+
+    return ok(undefined)
+  }
+
+  async restart(): Promise<Result<void, BotError>> {
+    if (!this.bot) {
+      return err(botError('BOT_NOT_RUNNING', 'Cannot restart: bot is not running'))
+    }
+
+    botLogger.info(
+      `${badge('BOT', 'pill')} ${kv({
+        action: colorText('restart', colors.info),
+      })}`
+    )
+
+    await this.stop('restart')
+    this.startTime = Date.now()
+
+    return ok(undefined)
+  }
+}
+
+function formatDuration(ms: number): string {
+  const seconds = Math.floor(ms / 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`
+}
+
+export const botManager = new BotManager()

package/templates/telegram-bot/core/src/utils/commands.ts

@@ -0,0 +1,63 @@
+import type { Context, Middleware } from 'telegraf'
+import type { Result, BotError } from './result.js'
+import { commandLogger, badge, kv, colors, colorText } from '../middleware/logging.js'
+import { botManager } from './bot-manager.js'
+
+export interface CommandConfig {
+  name: string
+  description?: string
+  auth?: boolean
+  stats?: boolean
+  handler: CommandHandler
+}
+
+export type CommandHandler = (ctx: Context, args: string[]) => Promise<Result<void, BotError>>
+
+export function createCommandHandler(config: CommandConfig): Middleware<Context> {
+  return async (ctx, next) => {
+    const userId = ctx.from?.id ?? 'unknown'
+    const username = ctx.from?.username ?? 'no-username'
+
+    commandLogger.info(
+      `${badge('CMD', 'rounded')} ${kv({
+        cmd: colorText(`/${config.name}`, colors.command),
+        user: colorText(String(userId), colors.user),
+        username: colorText(`@${username}`, colors.dim),
+      })}`
+    )
+
+    const args = extractArgs(ctx)
+
+    const result = await config.handler(ctx, args)
+
+    if (!result.ok) {
+      commandLogger.error(
+        `${badge('FAIL', 'rounded')} ${kv({
+          cmd: `/${config.name}`,
+          user: userId,
+          error: result.error.message,
+        })}`
+      )
+      await ctx.reply(`❌ ${result.error.message}`)
+      return
+    }
+
+    commandLogger.success(
+      `${badge('OK', 'rounded')} ${kv({
+        cmd: `/${config.name}`,
+        user: userId,
+      })}`
+    )
+
+    if (config.stats) {
+      botManager.incrementCommands()
+    }
+
+    return next()
+  }
+}
+
+function extractArgs(ctx: Context): string[] {
+  const text = ctx.message && 'text' in ctx.message ? ctx.message.text : ''
+  return text.split(' ').filter(Boolean)
+}

package/templates/telegram-bot/core/src/utils/formatters.ts

@@ -0,0 +1,82 @@
+import { TimeConstants } from '../types/constants.js'
+import type { BotStatus } from '../types/bot.js'
+
+export function formatUptime(uptimeMs: number): string {
+  const seconds = Math.floor(uptimeMs / TimeConstants.SECOND)
+  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 ${minutes % 60}m ${seconds % 60}s`
+  } else if (hours > 0) {
+    return `${hours}h ${minutes % 60}m ${seconds % 60}s`
+  } else if (minutes > 0) {
+    return `${minutes}m ${seconds % 60}s`
+  } else {
+    return `${seconds}s`
+  }
+}
+
+export function formatMemory(memoryUsage: {
+  rss: number
+  heapTotal: number
+  heapUsed: number
+  external: number
+  arrayBuffers: number
+}): string {
+  const mb = (bytes: number) => (bytes / 1024 / 1024).toFixed(2)
+
+  return `RSS: ${mb(memoryUsage.rss)}MB\nHeap: ${mb(memoryUsage.heapUsed)}/${mb(memoryUsage.heapTotal)}MB`
+}
+
+export function formatHealthMessage(status: BotStatus): string {
+  const uptime = formatUptime(status.uptime)
+  const memory = formatMemory(status.memoryUsage)
+
+  return `🏥 *Bot Health Status*
+  *Status:* ${status.status.toUpperCase()}
+  *Mode:* ${status.mode.toUpperCase()}
+  *Uptime:* ${uptime}
+  *Memory Usage:*
+  ${memory}`
+}
+
+export function formatStats(stats: {
+  messagesProcessed: number
+  commandsExecuted: number
+  errorsEncountered: number
+}): string {
+  return `📊 *Bot Statistics*
+
+*Performance:*
+Messages Processed: ${stats.messagesProcessed}
+Commands Executed: ${stats.commandsExecuted}
+Errors Encountered: ${stats.errorsEncountered}
+`
+}
+
+export function formatLogEntry(
+  timestamp: string,
+  level: string,
+  component: string,
+  message: string
+): string {
+  const levelEmoji = {
+    info: 'ℹ️',
+    success: '✅',
+    warn: '⚠️',
+    error: '❌',
+    debug: '🔍',
+  }
+
+  const emoji = levelEmoji[level as keyof typeof levelEmoji] || 'ℹ️'
+
+  return `${emoji} [${component}] ${message}
+_${timestamp}_`
+}
+
+export function formatError(error: Error | string): string {
+  const message = error instanceof Error ? error.message : String(error)
+  return `❌ *Error:* ${message}`
+}

package/templates/telegram-bot/core/src/utils/instance-manager.ts

@@ -0,0 +1,189 @@
+import { writeFile, readFile, unlink } from 'fs/promises'
+import { existsSync as existsSyncSync } from 'fs'
+import { resolve } from 'path'
+import type { BotConfig } from '../types/bot.js'
+import { botLogger, badge, kv, colorText, colors } from '../middleware/logging.js'
+import { ok, type Result, err } from './result.js'
+import { botError, type BotError } from '../types/result.js'
+
+export interface LockData {
+  pid: number
+  instanceId: string
+  environment: string
+  instanceName: string
+  startTime: string
+  nodeVersion: string
+  cwd: string
+}
+
+export interface InstanceInfo extends LockData {
+  running: boolean
+  uptime: string
+}
+
+export class InstanceManager {
+  private pidFile: string
+  private lockFile: string
+  private instanceId: string
+  private lockBackend: 'pid' | 'redis'
+
+  constructor(private config: BotConfig) {
+    this.instanceId = config.instanceId || this.generateInstanceId()
+    this.lockBackend = config.lockBackend || 'pid'
+
+    const tmpDir = resolve('./core/tmp')
+    this.pidFile = resolve(tmpDir, `${config.instanceName}.pid`)
+    this.lockFile = resolve(tmpDir, `${config.instanceName}.lock`)
+  }
+
+  async acquireLock(): Promise<Result<void, BotError>> {
+    // Skip if instance check disabled
+    if (!this.config.instanceCheck) {
+      return ok(undefined)
+    }
+
+    botLogger.debug(
+      `${badge('INSTANCE', 'rounded')} ${kv({
+        action: 'check',
+        lockFile: this.lockFile,
+      })}`
+    )
+
+    // Check if lock file exists
+    if (existsSyncSync(this.lockFile)) {
+      const existingInstance = await this.readLockFile()
+
+      // Check if process is still running
+      if (this.isProcessRunning(existingInstance.pid)) {
+        // CONFLICT DETECTED
+        return err(
+          botError(
+            'INSTANCE_CONFLICT',
+            `Another instance is already running:\n` +
+              `  Name: ${existingInstance.instanceName}\n` +
+              `  PID: ${existingInstance.pid}\n` +
+              `  Environment: ${existingInstance.environment}\n` +
+              `  Started: ${existingInstance.startTime}\n` +
+              `  Uptime: ${this.calculateUptime(existingInstance.startTime)}`
+          )
+        )
+      }
+
+      // Stale lock file, remove it
+      botLogger.warn(
+        `${badge('INSTANCE', 'rounded')} ${kv({
+          action: colorText('stale lock', colors.warning),
+          pid: existingInstance.pid,
+        })}`
+      )
+      await this.cleanup()
+    }
+
+    // Write lock files
+    await this.writeLockFile()
+    botLogger.success(
+      `${badge('INSTANCE', 'rounded')} ${kv({
+        action: colorText('locked', colors.success),
+        id: this.instanceId,
+      })}`
+    )
+
+    return ok(undefined)
+  }
+
+  async releaseLock(): Promise<void> {
+    try {
+      await this.cleanup()
+      botLogger.debug(
+        `${badge('INSTANCE', 'rounded')} ${kv({
+          action: colorText('released', colors.dim),
+        })}`
+      )
+    } catch (error) {
+      botLogger.error('Failed to release lock:', error)
+    }
+  }
+
+  async getLockData(): Promise<LockData | null> {
+    try {
+      return await this.readLockFile()
+    } catch {
+      return null
+    }
+  }
+
+  private async writeLockFile(): Promise<void> {
+    const lockData: LockData = {
+      pid: process.pid,
+      instanceId: this.instanceId,
+      environment: this.config.environment,
+      instanceName: this.config.instanceName,
+      startTime: new Date().toISOString(),
+      nodeVersion: process.version,
+      cwd: process.cwd(),
+    }
+
+    await writeFile(this.pidFile, process.pid.toString())
+    await writeFile(this.lockFile, JSON.stringify(lockData, null, 2))
+  }
+
+  private async readLockFile(): Promise<LockData> {
+    const content = await readFile(this.lockFile, 'utf-8')
+    return JSON.parse(content)
+  }
+
+  private isProcessRunning(pid: number): boolean {
+    try {
+      // Signal 0 checks if process exists without killing it
+      process.kill(pid, 0)
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  private 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`
+  }
+
+  private async cleanup(): Promise<void> {
+    if (existsSyncSync(this.pidFile)) {
+      await unlink(this.pidFile)
+    }
+    if (existsSyncSync(this.lockFile)) {
+      await unlink(this.lockFile)
+    }
+  }
+
+  private generateInstanceId(): string {
+    return `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`
+  }
+}
+
+let instanceManagerInstance: InstanceManager | null = null
+
+export function getInstanceManager(config?: BotConfig): InstanceManager {
+  if (!instanceManagerInstance) {
+    if (!config) {
+      throw new Error('InstanceManager requires config on first initialization')
+    }
+    instanceManagerInstance = new InstanceManager(config)
+  }
+  return instanceManagerInstance
+}
+
+export function resetInstanceManager(): void {
+  instanceManagerInstance = null
+}

package/templates/telegram-bot/core/src/utils/memory.ts

@@ -0,0 +1,33 @@
+import { TimeConstants } from '../types/constants.js'
+
+export function formatUptime(ms: number): string {
+  const days = Math.floor(ms / TimeConstants.DAY)
+  const hours = Math.floor((ms % TimeConstants.DAY) / TimeConstants.HOUR)
+  const minutes = Math.floor((ms % TimeConstants.HOUR) / TimeConstants.MINUTE)
+  const seconds = Math.floor((ms % TimeConstants.MINUTE) / TimeConstants.SECOND)
+
+  if (days > 0) return `${days}d ${hours}h ${minutes}m`
+  if (hours > 0) return `${hours}h ${minutes}m ${seconds}s`
+  if (minutes > 0) return `${minutes}m ${seconds}s`
+  return `${seconds}s`
+}
+
+export function formatDuration(ms: number): string {
+  return formatUptime(ms)
+}
+
+export function formatTimestamp(date: Date): string {
+  return date.toISOString()
+}
+
+export function getUptime(): number {
+  if (typeof process.uptime === 'function') {
+    return process.uptime() * 1_000
+  }
+  return Date.now()
+}
+
+export function getProcessUptime(): string {
+  const uptime = getUptime()
+  return formatUptime(uptime)
+}

package/templates/telegram-bot/core/src/utils/result.ts

@@ -0,0 +1,26 @@
+export {
+  ok,
+  err,
+  isOk,
+  isErr,
+  unwrap,
+  unwrapOr,
+  unwrapOrElse,
+  map,
+  mapErr,
+  flatMap,
+  tap,
+  tapErr,
+  match,
+  collect,
+  all,
+  fail,
+  botError,
+  resultError,
+  UNKNOWN_ERROR,
+  type Result,
+  type Ok,
+  type Err,
+  type BotError,
+  type BotErrorCode,
+} from '../types/result.js'

package/templates/telegram-bot/core/src/utils/telegram.ts

@@ -0,0 +1,31 @@
+export function formatBytes(bytes: number): string {
+  const units = ['B', 'KB', 'MB', 'GB', 'TB']
+  const threshold = 1024
+
+  for (const unit of units) {
+    if (bytes < threshold) {
+      return `${bytes} ${unit}`
+    }
+    bytes /= threshold
+  }
+
+  return `${bytes.toFixed(2)} PB`
+}
+
+export function formatMemory(memory: {
+  rss: number
+  heapTotal: number
+  heapUsed: number
+  external: number
+  arrayBuffers: number
+}): string {
+  return `  RSS: ${formatBytes(memory.rss)}
+  Heap Total: ${formatBytes(memory.heapTotal)}
+  Heap Used: ${formatBytes(memory.heapUsed)}
+  External: ${formatBytes(memory.external)}
+  Array Buffers: ${formatBytes(memory.arrayBuffers)}`
+}
+
+export function getMemoryStats() {
+  return process.memoryUsage()
+}

package/templates/telegram-bot/core/src/utils/type-guards.ts

@@ -0,0 +1,71 @@
+import type { Context } from 'telegraf'
+import { ok, err, type Result, botError } from '../types/result.js'
+
+export async function sendMessage(
+  ctx: Context,
+  chatId: string,
+  message: string,
+  options?: Record<string, unknown>
+): Promise<Result<void>> {
+  try {
+    await ctx.telegram.sendMessage(
+      chatId,
+      message,
+      options as Parameters<typeof ctx.telegram.sendMessage>[2]
+    )
+    return ok(undefined)
+  } catch (error) {
+    const errorObj = error instanceof Error ? error : new Error(String(error))
+    return err(botError('MESSAGE_FAILED', 'Failed to send message', errorObj))
+  }
+}
+
+export async function reply(
+  ctx: Context,
+  message: string,
+  options?: Record<string, unknown>
+): Promise<Result<void>> {
+  try {
+    await ctx.reply(message, options as Parameters<typeof ctx.reply>[1])
+    return ok(undefined)
+  } catch (error) {
+    const errorObj = error instanceof Error ? error : new Error(String(error))
+    return err(botError('MESSAGE_FAILED', 'Failed to reply', errorObj))
+  }
+}
+
+export async function editMessage(
+  ctx: Context,
+  chatId: string,
+  messageId: number,
+  message: string,
+  options?: Record<string, unknown>
+): Promise<Result<void>> {
+  try {
+    await ctx.telegram.editMessageText(
+      chatId,
+      messageId,
+      undefined,
+      message,
+      options as Parameters<typeof ctx.telegram.editMessageText>[4]
+    )
+    return ok(undefined)
+  } catch (error) {
+    const errorObj = error instanceof Error ? error : new Error(String(error))
+    return err(botError('MESSAGE_FAILED', 'Failed to edit message', errorObj))
+  }
+}
+
+export async function answerCallbackQuery(
+  ctx: Context,
+  text: string,
+  options?: Record<string, unknown>
+): Promise<Result<void>> {
+  try {
+    await ctx.answerCbQuery(text, options as Parameters<typeof ctx.answerCbQuery>[1])
+    return ok(undefined)
+  } catch (error) {
+    const errorObj = error instanceof Error ? error : new Error(String(error))
+    return err(botError('MESSAGE_FAILED', 'Failed to answer callback query', errorObj))
+  }
+}

package/templates/telegram-bot/core/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../tsconfig.json",
+  "compilerOptions": {
+    "rootDir": ".",
+    "types": ["bun-types", "node"]
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist"]
+}