cliclaw 1.0.26 → 1.0.34

package/index.ts

@@ -9,27 +9,59 @@ const config = loadConfig()
 const storage = new Storage(config.DATA_DIR)
 const bot = new Bot(config.TELEGRAM_BOT_TOKEN)
 
+// ── debug: log every incoming update type ──────────────────────────────────
+bot.use(async (ctx, next) => {
+  const type = ctx.updateType ?? 'unknown'
+  const extra = type === 'callback_query'
+    ? ` data="${(ctx.callbackQuery?.data ?? '').slice(0, 40)}"`
+    : type === 'message'
+    ? ` text="${(ctx.message?.text ?? '').slice(0, 30)}"`
+    : ''
+  console.log(`[update] ${type}${extra}`)
+  return next()
+})
+
 registerCommands(bot, storage, config)
 registerMessageHandler(bot, storage, config)
 
 // ── Codex exec approval callbacks ──────────────────────────────────────────
 bot.on('callback_query:data', async (ctx) => {
   const data = ctx.callbackQuery.data
+  console.log(`[callback] recebido: ${data.slice(0, 60)}`)
+
   if (!data.startsWith('capprove:') && !data.startsWith('cdeny:')) return
-  const [prefix, approvalId] = data.split(':')
-  const approved = prefix === 'capprove'
+
+  const colonIdx = data.indexOf(':')
+  const prefix     = data.slice(0, colonIdx)
+  const approvalId = data.slice(colonIdx + 1)
+  const approved   = prefix === 'capprove'
+
+  console.log(`[callback] clicou ${approved ? 'APROVAR' : 'NEGAR'} id=${approvalId.slice(0, 8)}...`)
+
   const found = respondApproval(approvalId, approved)
+  console.log(`[callback] respondApproval found=${found}`)
+
   const label = approved ? '✅ Aprovado' : '❌ Negado'
+  try {
+    await ctx.answerCallbackQuery({ text: label })
+  } catch (e: any) {
+    console.error(`[callback] answerCallbackQuery falhou: ${e.message}`)
+  }
   try {
     if (found) {
-      await ctx.editMessageReplyMarkup({ reply_markup: { inline_keyboard: [] } })
+      // Get the command text from the original message caption (plain text)
+      const origText = ctx.callbackQuery.message?.text ?? ''
+      // Replace keyboard with result label — rebuild safe HTML
+      const cmdLine = origText.split('\n').slice(1).join('\n').trim()
+      const escaped = cmdLine.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
       await ctx.editMessageText(
-        (ctx.callbackQuery.message?.text ?? '') + `\n\n${label}`,
+        `🔧 <b>Codex quer executar:</b>\n<code>${escaped}</code>\n\n${label}`,
         { parse_mode: 'HTML' }
       )
     }
-    await ctx.answerCallbackQuery({ text: label })
-  } catch {}
+  } catch (e: any) {
+    console.error(`[callback] editMessageText falhou: ${e.message}`)
+  }
 })
 
 bot.catch((err) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cliclaw",
-  "version": "1.0.26",
+  "version": "1.0.34",
   "description": "Telegram bot bridging AI CLIs (Claude Code, Codex) to Forum Topics",
   "main": "index.ts",
   "scripts": {

package/src/agents/codex.ts

@@ -128,20 +128,30 @@ function handleProtoEvent(ps: ProtoSession, obj: any) {
   if (msg?.type === 'exec_approval_request') {
     const callId     = msg.call_id ?? msgId
     const commandStr = formatApprovalCommand(msg.command ?? msg.cmd)
+    console.log(`[Codex approval] request recebido call_id=${callId} cmd="${commandStr.slice(0, 80)}"`)
     const respond = (approved: boolean) => {
+      console.log(`[Codex approval] enviando exec_approval call_id=${callId} approved=${approved}`)
       try {
         ps.proc.stdin!.write(JSON.stringify({
           id:  randomUUID(),
-          op:  { type: 'exec_approval', call_id: callId, approved },
+          op:  { type: 'exec_approval', id: callId, decision: approved ? 'approved' : 'denied' },
         }) + '\n')
-      } catch {}
+        console.log(`[Codex approval] enviado ok`)
+      } catch (e: any) {
+        console.error(`[Codex approval] erro ao enviar: ${e.message}`)
+      }
     }
     if (ps.approvalHandler) {
+      console.log(`[Codex approval] aguardando usuário via Telegram...`)
       ps.approvalHandler(callId, commandStr)
         .then(respond)
-        .catch(() => respond(false))
+        .catch((e: any) => {
+          console.error(`[Codex approval] handler error: ${e?.message} — negando`)
+          respond(false)
+        })
     } else {
-      respond(true)  // no handler → auto-approve
+      console.log(`[Codex approval] sem handler — auto-aprovando`)
+      respond(true)
     }
     return
   }

package/src/handlers/approvals.ts

@@ -17,12 +17,18 @@ export function registerApproval(
   resolve: (approved: boolean) => void,
   ttlMs    = 5 * 60 * 1000   // auto-deny after 5 min
 ): void {
-  const timeout = setTimeout(() => respondApproval(id, false), ttlMs)
+  console.log(`[approvals] registrado id=${id.slice(0, 8)}... total pendentes=${pending.size + 1}`)
+  const timeout = setTimeout(() => {
+    console.log(`[approvals] timeout id=${id.slice(0, 8)}... auto-negando`)
+    respondApproval(id, false)
+  }, ttlMs)
   pending.set(id, { resolve, timeout })
 }
 
 /** Called by the callback-query handler when the user clicks Approve/Deny. */
 export function respondApproval(id: string, approved: boolean): boolean {
+  const found = pending.has(id)
+  console.log(`[approvals] respondApproval id=${id.slice(0, 8)}... approved=${approved} found=${found} total=${pending.size}`)
   const p = pending.get(id)
   if (!p) return false
   clearTimeout(p.timeout)

package/src/handlers/messages.ts

@@ -58,95 +58,106 @@ async function tryRenameThread(
   } catch {}
 }
 
-export function registerMessageHandler(bot: Bot<Context>, storage: Storage, config: Config) {
-  bot.on('message:text', async (ctx) => {
-    const chatId   = String(ctx.chat.id)
-    const text     = ctx.message.text
-    const threadId = ctx.message.message_thread_id ?? 0
-    const lang     = getLang(ctx)
-
-    if (text.startsWith('/')) return
-
-    let session: Session | null = null
-    if (threadId > 0) {
-      session = storage.getSessionByThreadId(chatId, threadId)
-      if (!session) return
-    } else {
-      session = storage.getActiveSession(chatId)
-      if (!session) {
-        await ctx.reply(t(lang, 'noActiveSessionReply'))
-        return
-      }
-    }
-
-    if (activeLocks.has(session.id)) {
-      const opts: any = threadId > 0 ? { message_thread_id: threadId } : {}
-      await ctx.reply(t(lang, 'stillProcessing'), opts)
+// ── long-running message logic (runs concurrently — does NOT block grammY) ──
+async function processMessage(ctx: Context, storage: Storage, config: Config) {
+  const chatId   = String(ctx.chat!.id)
+  const text     = ctx.message!.text!
+  const threadId = ctx.message!.message_thread_id ?? 0
+  const lang     = getLang(ctx)
+
+  if (text.startsWith('/')) return
+
+  let session: Session | null = null
+  if (threadId > 0) {
+    session = storage.getSessionByThreadId(chatId, threadId)
+    if (!session) return
+  } else {
+    session = storage.getActiveSession(chatId)
+    if (!session) {
+      await ctx.reply(t(lang, 'noActiveSessionReply'))
       return
     }
+  }
 
-    const isFirstMessage = session.history.length === 0
-
-    activeLocks.add(session.id)
-    const replyOpts: any = threadId > 0 ? { message_thread_id: threadId } : {}
-    const emoji = session.model === 'claude' ? '🟣' : '🟢'
+  console.log(`[msg] chat=${chatId} thread=${threadId} model=${session.model} sid=${session.id.slice(0, 8)}... "${text.slice(0, 50).replace(/\n/g, '↵')}"`)
 
-    const workingMsg = await ctx.reply(
-      `${emoji} <i>${t(lang, 'processing')}</i>`,
-      { ...replyOpts, parse_mode: 'HTML' }
-    )
+  if (activeLocks.has(session.id)) {
+    // Session already processing — silently ignore (user sees "Processando..." in topic)
+    console.log(`[msg] ignorando — já processando sid=${session.id.slice(0, 8)}...`)
+    return
+  }
 
-    const typingLoop = setInterval(async () => {
-      try { await ctx.replyWithChatAction('typing', replyOpts) } catch {}
-    }, 4000)
-
-    storage.addMessage(chatId, session.id, 'user', text)
-
-    // ── build codex approval handler (only if PERMISSION_MODE=ask) ─────────
-    const codexApprovalHandler = (session.model === 'codex' && config.PERMISSION_MODE === 'ask')
-      ? (callId: string, cmdStr: string) => {
-          const approvalId = randomUUID()
-          ctx.api.sendMessage(chatId,
-            `🔧 <b>Codex quer executar:</b>\n<code>${escapeHtml(cmdStr)}</code>`,
-            {
-              ...replyOpts,
-              parse_mode: 'HTML',
-              reply_markup: { inline_keyboard: [[
-                { text: '✅ Aprovar', callback_data: `capprove:${approvalId}` },
-                { text: '❌ Negar',   callback_data: `cdeny:${approvalId}` },
-              ]] },
-            }
-          ).catch(() => {})
-          return new Promise<boolean>((resolve) => registerApproval(approvalId, resolve))
-        }
-      : undefined
-
-    let response: string
-    try {
-      let result: { text: string; usage?: TokenUsage }
-      if (session.model === 'claude') {
-        result = await askClaude(session, text,
-          (id) => storage.setClaudeSessionId(chatId, session!.id, id))
-      } else {
-        result = await askCodex(session, text,
-          (id) => storage.setCodexThreadId(chatId, session!.id, id),
-          codexApprovalHandler)
+  const isFirstMessage = session.history.length === 0
+
+  activeLocks.add(session.id)
+  const replyOpts: any = threadId > 0 ? { message_thread_id: threadId } : {}
+  const emoji = session.model === 'claude' ? '🟣' : '🟢'
+
+  const workingMsg = await ctx.reply(
+    `${emoji} <i>${t(lang, 'processing')}</i>`,
+    { ...replyOpts, parse_mode: 'HTML' }
+  )
+
+  const typingLoop = setInterval(async () => {
+    try { await ctx.replyWithChatAction('typing', replyOpts) } catch {}
+  }, 4000)
+
+  storage.addMessage(chatId, session.id, 'user', text)
+
+  // ── build codex approval handler (only if PERMISSION_MODE=ask) ─────────
+  const codexApprovalHandler = (session.model === 'codex' && config.PERMISSION_MODE === 'ask')
+    ? (callId: string, cmdStr: string) => {
+        const approvalId = randomUUID()
+        ctx.api.sendMessage(chatId,
+          `🔧 <b>Codex quer executar:</b>\n<code>${escapeHtml(cmdStr)}</code>`,
+          {
+            ...replyOpts,
+            parse_mode: 'HTML',
+            reply_markup: { inline_keyboard: [[
+              { text: '✅ Aprovar', callback_data: `capprove:${approvalId}` },
+              { text: '❌ Negar',   callback_data: `cdeny:${approvalId}` },
+            ]] },
+          }
+        ).catch(() => {})
+        return new Promise<boolean>((resolve) => registerApproval(approvalId, resolve))
       }
-      response = (isFirstMessage && result.usage) ? result.text + formatUsage(result.usage) : result.text
-    } catch (err: any) {
-      response = `\u274c ${lang === 'pt' ? 'Erro' : 'Error'}: ${err.message}`
-    } finally {
-      clearInterval(typingLoop)
-      activeLocks.delete(session.id)
+    : undefined
+
+  let response: string
+  try {
+    let result: { text: string; usage?: TokenUsage }
+    if (session.model === 'claude') {
+      result = await askClaude(session, text,
+        (id) => storage.setClaudeSessionId(chatId, session!.id, id))
+    } else {
+      result = await askCodex(session, text,
+        (id) => storage.setCodexThreadId(chatId, session!.id, id),
+        codexApprovalHandler)
     }
+    response = (isFirstMessage && result.usage) ? result.text + formatUsage(result.usage) : result.text
+  } catch (err: any) {
+    response = `\u274c ${lang === 'pt' ? 'Erro' : 'Error'}: ${err.message}`
+  } finally {
+    clearInterval(typingLoop)
+    activeLocks.delete(session.id)
+  }
 
-    storage.addMessage(chatId, session.id, 'assistant', response)
+  storage.addMessage(chatId, session.id, 'assistant', response)
 
-    if (isFirstMessage && config.FORUM_GROUP_ID && threadId > 0) {
-      await tryRenameThread(ctx.api, Number(config.FORUM_GROUP_ID), threadId, text, session.model)
-    }
+  if (isFirstMessage && config.FORUM_GROUP_ID && threadId > 0) {
+    await tryRenameThread(ctx.api, Number(config.FORUM_GROUP_ID), threadId, text, session.model)
+  }
+
+  try { await ctx.api.deleteMessage(ctx.chat!.id, workingMsg.message_id) } catch {}
+  await sendLong(ctx.api, chatId, `${emoji} ${response}`, replyOpts)
+}
 
-    try { await ctx.api.deleteMessage(ctx.chat.id, workingMsg.message_id) } catch {}
-    await sendLong(ctx.api, chatId, `${emoji} ${response}`, replyOpts)
+export function registerMessageHandler(bot: Bot<Context>, storage: Storage, config: Config) {
+  bot.on('message:text', (ctx) => {
+    // Fire-and-forget: return immediately so grammY can process other updates
+    // (e.g. callback_query for approval buttons) while waiting for AI response
+    void processMessage(ctx, storage, config).catch(err =>
+      console.error('[msg] erro não tratado:', err.message)
+    )
   })
 }