create-bunspace 0.2.5 → 0.3.1

package/dist/templates/telegram-bot/core/src/handlers/info.ts

@@ -0,0 +1,189 @@
+import type { Context } from 'telegraf'
+import { infoLogger, badge, kv, colors, colorText } from '../middleware/logging.js'
+import { TelegramMessageBuilder } from '@mks2508/telegram-message-builder'
+
+export async function handleGetInfo(ctx: Context): Promise<void> {
+  const userId = ctx.from?.id ?? 'unknown'
+  const botUsername = ctx.me
+
+  infoLogger.info(
+    `${badge('INFO', 'rounded')} ${kv({
+      cmd: '/getinfo',
+      user: colorText(String(userId), colors.user),
+    })}`
+  )
+
+  const msg = ctx.message
+  const from = ctx.from
+  const chat = ctx.chat
+
+  const builder = TelegramMessageBuilder.text()
+    .title('📋 Your Information')
+    .newline()
+
+  // User info
+  if (from) {
+    builder.section('👤 User Info:')
+      .line('User ID', String(from.id), { code: true })
+    if (from.username) builder.line('Username', `@${from.username}`)
+    if (from.first_name) builder.line('First Name', from.first_name)
+    if (from.last_name) builder.line('Last Name', from.last_name)
+    if (from.language_code) builder.line('Language', from.language_code)
+    if (from.is_premium) builder.line('Premium', 'Yes')
+    builder.newline()
+  }
+
+  // Chat info
+  if (chat) {
+    builder.section('💬 Chat Info:')
+      .line('Chat ID', String(chat.id), { code: true })
+      .line('Type', chat.type)
+    if ('title' in chat && chat.title) builder.line('Title', chat.title)
+    if ('username' in chat && chat.username) builder.line('Username', `@${chat.username}`)
+    if (chat.type === 'supergroup' || chat.type === 'group') {
+      builder.line('Chat ID (for config)', String(chat.id), { code: true })
+    }
+    builder.newline()
+  }
+
+  // Bot mention detection
+  if (msg && 'entities' in msg && botUsername) {
+    const botMention = detectBotMention(msg as unknown as MaybeMessage, botUsername)
+    if (botMention.isMentioned) {
+      builder.section('🤖 Bot Mention:')
+        .line('Bot mentioned', 'Yes')
+      if (botMention.type) builder.line('Mention type', botMention.type)
+      if (botMention.replyToBot) builder.text('Replying to bot message')
+      builder.newline()
+      infoLogger.info(`Bot mentioned in chat ${chat?.id} by user ${userId}`)
+    }
+  }
+
+  // Message/Topic info
+  if (msg) {
+    builder.section('📮 Message Info:')
+      .line('Message ID', String(msg.message_id))
+    if ('reply_to_message' in msg && msg.reply_to_message) {
+      const replyTo = msg.reply_to_message
+      builder.line('Reply to message ID', String(replyTo.message_id))
+    }
+  }
+
+  // Thread/Topic info (from forum topics)
+  const threadId = getThreadId(msg as unknown as MaybeMessage)
+  if (threadId) {
+    builder.newline()
+      .section('🧵 Thread/Topic:')
+      .line('Thread ID', String(threadId), { code: true })
+      .text('This message is in a topic')
+      .newline()
+    infoLogger.info(`Message sent in thread ${threadId} by user ${userId}`)
+  }
+
+  // Configuration tips
+  builder.newline()
+    .section('🔧 Configuration:')
+    .line('TG_CONTROL_CHAT_ID', String(chat?.id ?? 'N/A'), { code: true })
+    .line('TG_AUTHORIZED_USER_IDS', String(from?.id ?? 'N/A'))
+  if (threadId) {
+    builder.line('TG_CONTROL_TOPIC_ID', String(threadId), { code: true })
+  }
+
+  builder.newline()
+    .text('💡 Copy these values to your .env file')
+    .newline()
+    .newline()
+    .text('💡 Tip: In groups, you can also mention the bot with @username to get this info')
+
+  const message = builder.build()
+  infoLogger.info(`Replying to user ${userId} with info`)
+  await ctx.reply(message.text || '', { parse_mode: (message.parse_mode || 'HTML') as any })
+  infoLogger.success(`Info sent to user ${userId}`)
+}
+
+interface BotMentionResult {
+  isMentioned: boolean
+  type?: 'mention' | 'text_mention' | 'reply'
+  replyToBot?: boolean
+}
+
+function detectBotMention(msg: MaybeMessage, botUsername: string): BotMentionResult {
+  const result: BotMentionResult = {
+    isMentioned: false,
+  }
+
+  // Check if replying to a bot message
+  if ('reply_to_message' in msg && msg.reply_to_message) {
+    const replyTo = msg.reply_to_message
+    if ('from' in replyTo && replyTo.from?.id) {
+      result.replyToBot = true
+      result.isMentioned = true
+      result.type = 'reply'
+      return result
+    }
+  }
+
+  // Check for @mention entities
+  if ('entities' in msg && msg.entities && 'text' in msg && msg.text) {
+    const text = msg.text
+    for (const entity of msg.entities) {
+      if ('type' in entity && entity.type === 'mention') {
+        const mention = text.substring(entity.offset, entity.offset + entity.length)
+        if (mention === `@${botUsername}`) {
+          result.isMentioned = true
+          result.type = 'mention'
+          return result
+        }
+      }
+      if ('type' in entity && entity.type === 'text_mention') {
+        result.isMentioned = true
+        result.type = 'text_mention'
+        return result
+      }
+    }
+  }
+
+  return result
+}
+
+/**
+ * Get thread ID from a message
+ * Checks multiple possible locations where thread_id can be stored
+ */
+function getThreadId(msg: MaybeMessage): number | undefined {
+  if (!msg) return undefined
+
+  // Direct thread_id property (forum topics)
+  if ('thread_id' in msg && typeof msg.thread_id === 'number') {
+    return msg.thread_id
+  }
+
+  // message_thread_id (alternative property)
+  if ('message_thread_id' in msg && typeof msg.message_thread_id === 'number') {
+    return msg.message_thread_id
+  }
+
+  // Check in reply_to_message
+  if ('reply_to_message' in msg && msg.reply_to_message) {
+    const replyTo = msg.reply_to_message
+
+    if ('thread_id' in replyTo && typeof replyTo.thread_id === 'number') {
+      return replyTo.thread_id
+    }
+
+    if ('message_thread_id' in replyTo && typeof replyTo.message_thread_id === 'number') {
+      return replyTo.message_thread_id
+    }
+  }
+
+  return undefined
+}
+
+// Type for message objects that might have various properties
+type MaybeMessage = Record<string, unknown> & {
+  reply_to_message?: MaybeMessage & { from?: { id?: number } }
+  entities?: Array<{ type?: string; offset: number; length: number }>
+  text?: string
+  thread_id?: number
+  message_thread_id?: number
+}

package/dist/templates/telegram-bot/core/src/handlers/listener.ts

@@ -0,0 +1,168 @@
+import type { Context } from 'telegraf'
+import { success as logSuccess, error as logError } from '@mks2508/better-logger'
+
+/**
+ * Collected IDs from listener mode
+ */
+export interface CollectedIds {
+  authorizedUserIds: Set<number>
+  controlChatId: number | null
+  controlTopicId: number | null
+  logChatId: number | null
+  logTopicId: number | null
+  messagesCount: number
+}
+
+/**
+ * Get thread ID from a message
+ * Checks multiple possible locations where thread_id can be stored
+ */
+function getThreadId(msg: MaybeMessage): number | undefined {
+  if (!msg) return undefined
+
+  // Direct thread_id property (forum topics)
+  if ('thread_id' in msg && typeof msg.thread_id === 'number') {
+    return msg.thread_id
+  }
+
+  // message_thread_id (alternative property)
+  if ('message_thread_id' in msg && typeof msg.message_thread_id === 'number') {
+    return msg.message_thread_id
+  }
+
+  // Check in reply_to_message
+  if ('reply_to_message' in msg && msg.reply_to_message) {
+    const replyTo = msg.reply_to_message
+
+    if ('thread_id' in replyTo && typeof replyTo.thread_id === 'number') {
+      return replyTo.thread_id
+    }
+
+    if ('message_thread_id' in replyTo && typeof replyTo.message_thread_id === 'number') {
+      return replyTo.message_thread_id
+    }
+  }
+
+  return undefined
+}
+
+// Type for message objects that might have various properties
+type MaybeMessage = Record<string, unknown> & {
+  reply_to_message?: MaybeMessage & { from?: { id?: number } }
+  entities?: Array<{ type?: string; offset: number; length: number }>
+  text?: string
+  thread_id?: number
+  message_thread_id?: number
+}
+
+/**
+ * Handle messages in listener mode
+ * Captures User IDs, Chat IDs, and Topic IDs from incoming messages
+ */
+export function handleListenerMessage(
+  ctx: Context,
+  collected: CollectedIds,
+  onStartCallback?: (info: string) => void,
+  onCaptureCallback?: (type: string, value: number | string) => void
+): void {
+  const msg = ctx.message
+  const from = ctx.from
+  const chat = ctx.chat
+
+  if (!msg) {
+    return
+  }
+
+  collected.messagesCount++
+
+  // Capture User ID (from any message)
+  if (from) {
+    const isNew = collected.authorizedUserIds.add(from.id)
+    if (isNew && onCaptureCallback) {
+      onCaptureCallback('User ID', from.id)
+      logSuccess(`Captured User ID: ${from.id}`)
+    }
+  }
+
+  // Capture Chat ID (from group/supergroup/channel messages)
+  if (chat && chat.type !== 'private') {
+    const isNew = collected.controlChatId !== chat.id
+    collected.controlChatId = chat.id
+    if (isNew && onCaptureCallback) {
+      onCaptureCallback('Chat ID', chat.id)
+      logSuccess(`Captured Chat ID: ${chat.id} (${chat.type})`)
+    }
+  }
+
+  // Capture Topic ID (from forum topics)
+  const threadId = getThreadId(msg as unknown as MaybeMessage)
+  if (threadId) {
+    // If we have a control chat but no control topic yet, this is likely the control topic
+    if (collected.controlChatId && !collected.controlTopicId) {
+      collected.controlTopicId = threadId
+      if (onCaptureCallback) {
+        onCaptureCallback('Control Topic ID', threadId)
+        logSuccess(`Captured Control Topic ID: ${threadId}`)
+      }
+    } else if (collected.controlChatId && collected.controlTopicId && threadId !== collected.controlTopicId) {
+      // If we already have a control topic, this might be the log topic
+      collected.logTopicId = threadId
+      collected.logChatId = collected.controlChatId
+      if (onCaptureCallback) {
+        onCaptureCallback('Log Topic ID', threadId)
+        logSuccess(`Captured Log Topic ID: ${threadId}`)
+      }
+    }
+  }
+
+  // Send acknowledgment back to user
+  const summary = buildListenerSummary(collected)
+  ctx.reply(summary, { parse_mode: 'HTML' }).catch((error) => {
+    logError('Failed to send listener summary:', error)
+  })
+}
+
+/**
+ * Build a summary message of captured IDs
+ */
+function buildListenerSummary(collected: CollectedIds): string {
+  const parts: string[] = []
+
+  parts.push('<b>🔧 Auto-Configure Listener</b>')
+  parts.push('')
+
+  if (collected.authorizedUserIds.size > 0) {
+    parts.push(`<b>👤 User IDs:</b> <code>${[...collected.authorizedUserIds].join(', ')}</code>`)
+  }
+
+  if (collected.controlChatId) {
+    parts.push(`<b>💬 Chat ID:</b> <code>${collected.controlChatId}</code>`)
+  }
+
+  if (collected.controlTopicId) {
+    parts.push(`<b>🧵 Control Topic ID:</b> <code>${collected.controlTopicId}</code>`)
+  }
+
+  if (collected.logTopicId) {
+    parts.push(`<b>📋 Log Topic ID:</b> <code>${collected.logTopicId}</code>`)
+  }
+
+  parts.push('')
+  parts.push('<i>Send more messages from different contexts to capture more IDs...</i>')
+
+  return parts.join('\n')
+}
+
+/**
+ * Create initial collected IDs object
+ */
+export function createInitialCollectedIds(): CollectedIds {
+  return {
+    authorizedUserIds: new Set<number>(),
+    controlChatId: null,
+    controlTopicId: null,
+    logChatId: null,
+    logTopicId: null,
+    messagesCount: 0,
+  }
+}

package/dist/templates/telegram-bot/core/src/handlers/logs.ts

@@ -2,6 +2,7 @@ import type { Context, Telegraf } from 'telegraf'
 import { getConfig, hasLoggingConfigured } from '../config/index.js'
 import { streamLogger, botLogger, badge, kv, colors, colorText } from '../middleware/logging.js'
 import { formatLogEntry } from '../utils/formatters.js'
+import { TelegramMessageBuilder } from '@mks2508/telegram-message-builder'
 
 const LOG_BUFFER_SIZE = 10
 const LOG_BUFFER_TIMEOUT = 5000
@@ -102,7 +103,10 @@ export async function handleLogsCommand(ctx: Context): Promise<void> {
   const config = getConfig()
 
   if (!hasLoggingConfigured()) {
-    await ctx.reply('❌ Logging is not configured. Set TG_LOG_CHAT_ID environment variable.')
+    const message = TelegramMessageBuilder.text()
+      .text('❌ Logging is not configured. Set TG_LOG_CHAT_ID environment variable.')
+      .build()
+    ctx.reply(message.text || '', { parse_mode: (message.parse_mode || 'HTML') as any })
     return
   }
 
@@ -117,10 +121,15 @@ export async function handleLogsCommand(ctx: Context): Promise<void> {
     })}`
   )
 
-  await ctx.reply(
-    `📝 *Log Streaming Status:* \`${status}\`\n\nChat ID: \`${config.logChatId}\`${
-      config.logTopicId ? `\nTopic ID: \`${config.logTopicId}\`` : ''
-    }`,
-    { parse_mode: 'Markdown' }
-  )
+  const builder = TelegramMessageBuilder.text()
+    .title('📝 Log Streaming Status')
+    .newline()
+    .line('Status', status, { code: true })
+    .line('Chat ID', String(config.logChatId), { code: true })
+  if (config.logTopicId) {
+    builder.line('Topic ID', String(config.logTopicId), { code: true })
+  }
+
+  const message = builder.build()
+  ctx.reply(message.text || '', { parse_mode: (message.parse_mode || 'HTML') as any })
 }

package/dist/templates/telegram-bot/core/src/index.ts

@@ -6,8 +6,14 @@ import { botLogger, kv, badge, colorText, colors } from './middleware/logging.js
 import { botManager } from './utils/bot-manager.js'
 import { getInstanceManager } from './utils/instance-manager.js'
 import { handleHealth, handleUptime, handleStats } from './handlers/health.js'
+import { handleGetInfo } from './handlers/info.js'
 import { handleStop, handleRestart, handleMode, handleWebhook } from './handlers/control.js'
 import { handleLogsCommand, initializeLogStreamer } from './handlers/logs.js'
+import { handleExportConfig } from './handlers/config-export.js'
+import { handleTextDemo } from './handlers/demo-text.js'
+import { handleKeyboardDemo, handleKeyboardCallback } from './handlers/demo-keyboard.js'
+import { handleMediaDemo, handleMediaCallback } from './handlers/demo-media.js'
+import { handleFullDemo, handleFullDemoCallback } from './handlers/demo-full.js'
 import { auth } from './middleware/auth.js'
 import { initializeFileLogging } from './config/logging.js'
 
@@ -72,12 +78,44 @@ async function main(): Promise<void> {
         '/uptime - Show bot uptime\n' +
         '/stats - Show statistics\n' +
         '/logs - Check log streaming status\n' +
-        '/mode - Check or change bot mode',
+        '/getinfo - Get your user/chat info for configuration\n' +
+        '/mode - Check or change bot mode\n\n' +
+        '*🎨 Demo Commands (telegram-message-builder):*\n' +
+        '/textdemo - Text formatting showcase\n' +
+        '/keybdemo - Keyboard builder showcase\n' +
+        '/mediademo - Media types showcase\n' +
+        '/fulldemo - Complete feature demo',
       { parse_mode: 'Markdown' }
     )
     botManager.incrementMessages()
   })
 
+  bot.command('getinfo', handleGetInfo)
+  bot.command('exportconfig', handleExportConfig)
+
+  // Listen for bot mentions in groups
+  bot.use(async (ctx, next) => {
+    const botUsername = ctx.me
+    if (!botUsername) return next()
+
+    const msg = ctx.message
+    if (!msg || !('text' in msg) || !msg.text) return next()
+
+    // Check if bot is mentioned
+    const mention = `@${botUsername}`
+    if (msg.text.includes(mention)) {
+      botLogger.info(
+        `${badge('MENTION', 'rounded')} ${kv({
+          user: colorText(String(ctx.from?.id), colors.user),
+          chat: ctx.chat?.id,
+        })}`
+      )
+      await handleGetInfo(ctx)
+    } else {
+      return next()
+    }
+  })
+
   bot.command('health', handleHealth)
   bot.command('uptime', handleUptime)
   bot.command('stats', handleStats)
@@ -108,6 +146,16 @@ async function main(): Promise<void> {
 
   bot.command('logs', handleLogsCommand)
 
+  // Demo commands for telegram-message-builder showcase
+  bot.command('textdemo', handleTextDemo)
+  bot.command('keybdemo', handleKeyboardDemo)
+  bot.command('mediademo', handleMediaDemo)
+  bot.command('fulldemo', handleFullDemo)
+
+  // Callback handlers for demo keyboards
+  bot.action(/^(demo_yes|demo_no|demo_refresh|demo_search|full_demo_keyboard)$/, handleKeyboardCallback)
+  bot.action(/^(media_photo|media_video|media_document|media_audio|media_voice|full_demo_media)$/, handleMediaCallback)
+
   process.once('SIGINT', async () => {
     botLogger.info(`${badge('SHUTDOWN', 'pill')} ${colorText('SIGINT received', colors.warning)}`)
     await instanceManager.releaseLock()

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

@@ -1,6 +1,13 @@
 import { TimeConstants } from '../types/constants.js'
 import type { BotStatus } from '../types/bot.js'
+import { TelegramMessageBuilder, fmt } from '@mks2508/telegram-message-builder'
 
+// Re-export fmt from telegram-message-builder for convenience
+export { fmt }
+
+/**
+ * Format uptime in human-readable format
+ */
 export function formatUptime(uptimeMs: number): string {
   const seconds = Math.floor(uptimeMs / TimeConstants.SECOND)
   const minutes = Math.floor(seconds / 60)
@@ -18,6 +25,9 @@ export function formatUptime(uptimeMs: number): string {
   }
 }
 
+/**
+ * Format memory usage in MB
+ */
 export function formatMemory(memoryUsage: {
   rss: number
   heapTotal: number
@@ -30,32 +40,9 @@ export function formatMemory(memoryUsage: {
   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}
-`
-}
-
+/**
+ * Format a log entry message for Telegram
+ */
 export function formatLogEntry(
   timestamp: string,
   level: string,
@@ -72,11 +59,5 @@ export function formatLogEntry(
 
   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}`
+  return `${emoji} [${component}] ${message}\n${fmt.italic(timestamp)}`
 }

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

@@ -1,6 +1,9 @@
 import { writeFile, readFile, unlink } from 'fs/promises'
 import { existsSync as existsSyncSync } from 'fs'
-import { resolve } from 'path'
+import { resolve, dirname } from 'path'
+import { fileURLToPath } from 'url'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
 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'
@@ -31,7 +34,8 @@ export class InstanceManager {
     this.instanceId = config.instanceId || this.generateInstanceId()
     this.lockBackend = config.lockBackend || 'pid'
 
-    const tmpDir = resolve('./core/tmp')
+    // tmp is at core/tmp relative to this file (core/src/utils)
+    const tmpDir = resolve(__dirname, '../../tmp')
     this.pidFile = resolve(tmpDir, `${config.instanceName}.pid`)
     this.lockFile = resolve(tmpDir, `${config.instanceName}.lock`)
   }