cliclaw 1.0.34 → 1.0.36

package/index.ts

@@ -25,37 +25,40 @@ registerCommands(bot, storage, config)
 registerMessageHandler(bot, storage, config)
 
 // ── Codex exec approval callbacks ──────────────────────────────────────────
+const APPROVAL_PREFIXES: Record<string, { decision: string; label: string }> = {
+  capprove:  { decision: 'approved',             label: '✅ Aprovado'  },
+  csession:  { decision: 'approved_for_session', label: '🔓 Sessão aprovada!' },
+  cdeny:     { decision: 'denied',               label: '❌ Negado'    },
+  cabort:    { decision: 'abort',                label: '🛑 Abortado'  },
+}
+
 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 colonIdx = data.indexOf(':')
-  const prefix     = data.slice(0, colonIdx)
+  const colonIdx  = data.indexOf(':')
+  const prefix    = data.slice(0, colonIdx)
   const approvalId = data.slice(colonIdx + 1)
-  const approved   = prefix === 'capprove'
+  const entry     = APPROVAL_PREFIXES[prefix]
+  if (!entry) return
 
-  console.log(`[callback] clicou ${approved ? 'APROVAR' : 'NEGAR'} id=${approvalId.slice(0, 8)}...`)
+  console.log(`[callback] clicou ${prefix} id=${approvalId.slice(0, 8)}...`)
 
-  const found = respondApproval(approvalId, approved)
-  console.log(`[callback] respondApproval found=${found}`)
+  const found = respondApproval(approvalId, entry.decision)
+  console.log(`[callback] respondApproval found=${found} decision=${entry.decision}`)
 
-  const label = approved ? '✅ Aprovado' : '❌ Negado'
   try {
-    await ctx.answerCallbackQuery({ text: label })
+    await ctx.answerCallbackQuery({ text: entry.label })
   } catch (e: any) {
     console.error(`[callback] answerCallbackQuery falhou: ${e.message}`)
   }
   try {
     if (found) {
-      // 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;')
+      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(
-        `🔧 <b>Codex quer executar:</b>\n<code>${escaped}</code>\n\n${label}`,
+        `🔧 <b>Codex quer executar:</b>\n<code>${escaped}</code>\n\n${entry.label}`,
         { parse_mode: 'HTML' }
       )
     }

package/package.json

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

package/src/agents/codex.ts

@@ -26,12 +26,13 @@ interface PendingReq {
 }
 
 interface ProtoSession {
-  proc:            ChildProcess
-  sessionId:       string
-  lastUsed:        number
-  pending:         Map<string, PendingReq>
-  buf:             string   // incomplete stdout line buffer
-  approvalHandler?: (callId: string, commandStr: string) => Promise<boolean>
+  proc:             ChildProcess
+  sessionId:        string
+  lastUsed:         number
+  pending:          Map<string, PendingReq>
+  buf:              string   // incomplete stdout line buffer
+  approvalHandler?: (callId: string, commandStr: string) => Promise<string>
+  sessionApproved:  boolean  // true after user clicks "Aprovar Sessão"
 }
 
 // Map from cliclaw session.id → ProtoSession
@@ -74,6 +75,7 @@ function startProto(appSessionId: string): ProtoSession {
     lastUsed: Date.now(),
     pending: new Map(),
     buf: '',
+    sessionApproved: false,
   }
 
   proc.stdout!.on('data', (d: Buffer) => {
@@ -126,32 +128,47 @@ function handleProtoEvent(ps: ProtoSession, obj: any) {
 
   // ── exec approval request ───────────────────────────────────────────────────
   if (msg?.type === 'exec_approval_request') {
-    const callId     = msg.call_id ?? msgId
+    const subId      = msg.sub_id ?? 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}`)
+    console.log(`[Codex approval] request recebido sub_id=${subId} cmd="${commandStr.slice(0, 80)}"`)
+
+    // Respond using the original message id so Codex can correlate the reply
+    const respond = (decision: string) => {
+      // Handle app-level session approval — Codex only understands 'approved'/'denied'/'abort'
+      if (decision === 'approved_for_session') {
+        ps.sessionApproved = true
+        decision = 'approved'
+      }
+      console.log(`[Codex approval] enviando exec_approval sub_id=${subId} decision=${decision}`)
       try {
         ps.proc.stdin!.write(JSON.stringify({
-          id:  randomUUID(),
-          op:  { type: 'exec_approval', id: callId, decision: approved ? 'approved' : 'denied' },
+          id:  msgId,   // use original event id, not a new UUID
+          op:  { type: 'exec_approval', sub_id: subId, decision },
         }) + '\n')
         console.log(`[Codex approval] enviado ok`)
       } catch (e: any) {
         console.error(`[Codex approval] erro ao enviar: ${e.message}`)
       }
     }
+
+    // If the user already approved the whole session, skip the prompt
+    if (ps.sessionApproved) {
+      console.log(`[Codex approval] sessão aprovada — auto-aprovando`)
+      respond('approved')
+      return
+    }
+
     if (ps.approvalHandler) {
       console.log(`[Codex approval] aguardando usuário via Telegram...`)
-      ps.approvalHandler(callId, commandStr)
+      ps.approvalHandler(subId, commandStr)
         .then(respond)
         .catch((e: any) => {
           console.error(`[Codex approval] handler error: ${e?.message} — negando`)
-          respond(false)
+          respond('denied')
         })
     } else {
       console.log(`[Codex approval] sem handler — auto-aprovando`)
-      respond(true)
+      respond('approved')
     }
     return
   }
@@ -205,7 +222,7 @@ export async function askCodex(
   session:         { id: string; codexThreadId?: string },
   userMessage:     string,
   _onNewThreadId?: (id: string) => void,
-  approvalHandler?: (callId: string, commandStr: string) => Promise<boolean>
+  approvalHandler?: (callId: string, commandStr: string) => Promise<string>
 ): Promise<{ text: string; usage?: TokenUsage }> {
   const ps = getOrStart(session.id)
   // Update handler every call (chat context may have changed)

package/src/handlers/approvals.ts

@@ -1,11 +1,11 @@
 /**
  * Shared state for pending Codex exec approval requests.
  * When codex wants to run a shell command, the bot sends a Telegram message
- * with Approve/Deny buttons. The user's answer is routed back here.
+ * with Approve/Deny/Session/Abort buttons. The user's answer is routed back here.
  */
 
 interface PendingApproval {
-  resolve:  (approved: boolean) => void
+  resolve:  (decision: string) => void
   timeout:  ReturnType<typeof setTimeout>
 }
 
@@ -14,25 +14,25 @@ const pending = new Map<string, PendingApproval>()
 /** Store a pending approval that will resolve when the user responds. */
 export function registerApproval(
   id:      string,
-  resolve: (approved: boolean) => void,
+  resolve: (decision: string) => void,
   ttlMs    = 5 * 60 * 1000   // auto-deny after 5 min
 ): void {
   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)
+    respondApproval(id, 'denied')
   }, 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 {
+/** Called by the callback-query handler when the user clicks a decision button. */
+export function respondApproval(id: string, decision: string): boolean {
   const found = pending.has(id)
-  console.log(`[approvals] respondApproval id=${id.slice(0, 8)}... approved=${approved} found=${found} total=${pending.size}`)
+  console.log(`[approvals] respondApproval id=${id.slice(0, 8)}... decision=${decision} found=${found} total=${pending.size}`)
   const p = pending.get(id)
   if (!p) return false
   clearTimeout(p.timeout)
   pending.delete(id)
-  p.resolve(approved)
+  p.resolve(decision)
   return true
 }

package/src/handlers/messages.ts

@@ -113,13 +113,19 @@ async function processMessage(ctx: Context, storage: Storage, config: Config) {
           {
             ...replyOpts,
             parse_mode: 'HTML',
-            reply_markup: { inline_keyboard: [[
-              { text: '✅ Aprovar', callback_data: `capprove:${approvalId}` },
-              { text: '❌ Negar',   callback_data: `cdeny:${approvalId}` },
-            ]] },
+            reply_markup: { inline_keyboard: [
+              [
+                { text: '✅ Aprovar',         callback_data: `capprove:${approvalId}` },
+                { text: '🔓 Aprovar Sessão',  callback_data: `csession:${approvalId}` },
+              ],
+              [
+                { text: '❌ Negar',     callback_data: `cdeny:${approvalId}` },
+                { text: '🛑 Abortar',   callback_data: `cabort:${approvalId}` },
+              ],
+            ] },
           }
         ).catch(() => {})
-        return new Promise<boolean>((resolve) => registerApproval(approvalId, resolve))
+        return new Promise<string>((resolve) => registerApproval(approvalId, resolve))
       }
     : undefined