cliclaw 1.0.21 → 1.0.23

package/index.ts

@@ -3,6 +3,7 @@ import { loadConfig } from './src/config'
 import { Storage } from './src/storage'
 import { registerCommands } from './src/handlers/commands'
 import { registerMessageHandler } from './src/handlers/messages'
+import { respondApproval } from './src/handlers/approvals'
 
 const config = loadConfig()
 const storage = new Storage(config.DATA_DIR)
@@ -11,6 +12,26 @@ const bot = new Bot(config.TELEGRAM_BOT_TOKEN)
 registerCommands(bot, storage, config)
 registerMessageHandler(bot, storage, config)
 
+// ── Codex exec approval callbacks ──────────────────────────────────────────
+bot.on('callback_query:data', async (ctx) => {
+  const data = ctx.callbackQuery.data
+  if (!data.startsWith('capprove:') && !data.startsWith('cdeny:')) return
+  const [prefix, approvalId] = data.split(':')
+  const approved = prefix === 'capprove'
+  const found = respondApproval(approvalId, approved)
+  const label = approved ? '✅ Aprovado' : '❌ Negado'
+  try {
+    if (found) {
+      await ctx.editMessageReplyMarkup({ reply_markup: { inline_keyboard: [] } })
+      await ctx.editMessageText(
+        (ctx.callbackQuery.message?.text ?? '') + `\n\n${label}`,
+        { parse_mode: 'HTML' }
+      )
+    }
+    await ctx.answerCallbackQuery({ text: label })
+  } catch {}
+})
+
 bot.catch((err) => {
   const ctx = err.ctx
   console.error(`[OpenClaw] Erro em update ${ctx.update.update_id}: ${err.error}`)

package/package.json

@@ -1,48 +1,48 @@
-{
-  "name": "cliclaw",
-  "version": "1.0.21",
-  "description": "Telegram bot bridging AI CLIs (Claude Code, Codex) to Forum Topics",
-  "main": "index.ts",
-  "scripts": {
-    "start": "tsx index.ts",
-    "dev": "tsx watch index.ts",
-    "setup": "node bin/cli.js setup"
-  },
-  "dependencies": {
-    "@anthropic-ai/sdk": "^0.39.0",
-    "grammy": "^1.31.3",
-    "openai": "^4.97.0",
-    "tsx": "^4.21.0"
-  },
-  "devDependencies": {
-    "@types/node": "^20.0.0",
-    "typescript": "^5.0.0"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/luizfeer/cliclaw.git"
-  },
-  "keywords": [
-    "telegram",
-    "claude",
-    "codex",
-    "cli",
-    "bot",
-    "forum"
-  ],
-  "license": "MIT",
-  "bin": {
-    "cliclaw": "./bin/cli.js"
-  },
-  "files": [
-    "bin/",
-    "src/",
-    "index.ts",
-    "ecosystem.config.js",
-    ".env.example",
-    "tsconfig.json"
-  ],
-  "engines": {
-    "node": ">=18"
-  }
-}
+{
+  "name": "cliclaw",
+  "version": "1.0.23",
+  "description": "Telegram bot bridging AI CLIs (Claude Code, Codex) to Forum Topics",
+  "main": "index.ts",
+  "scripts": {
+    "start": "tsx index.ts",
+    "dev": "tsx watch index.ts",
+    "setup": "node bin/cli.js setup"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.39.0",
+    "grammy": "^1.31.3",
+    "openai": "^4.97.0",
+    "tsx": "^4.21.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/luizfeer/cliclaw.git"
+  },
+  "keywords": [
+    "telegram",
+    "claude",
+    "codex",
+    "cli",
+    "bot",
+    "forum"
+  ],
+  "license": "MIT",
+  "bin": {
+    "cliclaw": "./bin/cli.js"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "index.ts",
+    "ecosystem.config.js",
+    ".env.example",
+    "tsconfig.json"
+  ],
+  "engines": {
+    "node": ">=18"
+  }
+}

package/src/agents/codex.ts

@@ -26,16 +26,25 @@ interface PendingReq {
 }
 
 interface ProtoSession {
-  proc:      ChildProcess
-  sessionId: string
-  lastUsed:  number
-  pending:   Map<string, PendingReq>
-  buf:       string   // incomplete stdout line buffer
+  proc:            ChildProcess
+  sessionId:       string
+  lastUsed:        number
+  pending:         Map<string, PendingReq>
+  buf:             string   // incomplete stdout line buffer
+  approvalHandler?: (callId: string, commandStr: string) => Promise<boolean>
 }
 
 // Map from cliclaw session.id → ProtoSession
 const protoSessions = new Map<string, ProtoSession>()
 
+function formatApprovalCommand(cmd: any): string {
+  if (!cmd) return '(unknown)'
+  if (cmd.type === 'shell' && Array.isArray(cmd.command)) return cmd.command.join(' ')
+  if (typeof cmd === 'string') return cmd
+  if (Array.isArray(cmd)) return cmd.join(' ')
+  return JSON.stringify(cmd)
+}
+
 // ─── cleanup idle sessions every 5 min ───────────────────────────────────────
 setInterval(() => {
   const now = Date.now()
@@ -112,6 +121,35 @@ function handleProtoEvent(ps: ProtoSession, obj: any) {
 
   if (msg?.type === 'session_configured') {
     ps.sessionId = msg.session_id ?? ''
+    // Ask codex to route exec approvals to us instead of auto-approving
+    try {
+      ps.proc.stdin!.write(JSON.stringify({
+        id: 'cfg-approval',
+        op: { type: 'configure', config: { approval_policy: 'user_approval' } },
+      }) + '\n')
+    } catch {}
+    return
+  }
+
+  // ── exec approval request ───────────────────────────────────────────────────
+  if (msg?.type === 'exec_approval_request') {
+    const callId     = msg.call_id ?? msgId
+    const commandStr = formatApprovalCommand(msg.command ?? msg.cmd)
+    const respond = (approved: boolean) => {
+      try {
+        ps.proc.stdin!.write(JSON.stringify({
+          id:  randomUUID(),
+          op:  { type: 'exec_approval_response', call_id: callId, approved },
+        }) + '\n')
+      } catch {}
+    }
+    if (ps.approvalHandler) {
+      ps.approvalHandler(callId, commandStr)
+        .then(respond)
+        .catch(() => respond(false))
+    } else {
+      respond(true)  // no handler → auto-approve
+    }
     return
   }
 
@@ -161,11 +199,14 @@ function getOrStart(appSessionId: string): ProtoSession {
 
 // ─── public API ──────────────────────────────────────────────────────────────
 export async function askCodex(
-  session: { id: string; codexThreadId?: string },
-  userMessage: string,
-  _onNewThreadId?: (id: string) => void
+  session:         { id: string; codexThreadId?: string },
+  userMessage:     string,
+  _onNewThreadId?: (id: string) => void,
+  approvalHandler?: (callId: string, commandStr: string) => Promise<boolean>
 ): Promise<{ text: string; usage?: TokenUsage }> {
   const ps = getOrStart(session.id)
+  // Update handler every call (chat context may have changed)
+  if (approvalHandler !== undefined) ps.approvalHandler = approvalHandler
   const msgId = randomUUID()
 
   return new Promise((resolve, reject) => {

package/src/config.ts

@@ -5,6 +5,7 @@ import { homedir } from 'os'
 
 export type AgentName = 'claude' | 'codex'
 export type PermissionMode = 'auto' | 'session' | 'ask'
+export type CodexApproval = 'ask' | 'allow'
 
 export interface Config {
   TELEGRAM_BOT_TOKEN: string
@@ -12,6 +13,7 @@ export interface Config {
   FORUM_GROUP_ID: string
   TELEGRAM_ADMIN_IDS: string[]
   PERMISSION_MODE: PermissionMode
+  CODEX_APPROVAL: CodexApproval
   availableAgents: AgentName[]
 }
 
@@ -59,6 +61,9 @@ export function loadConfig(): Config {
     rawMode === 'session' ? 'session' :
     rawMode === 'ask'     ? 'ask'     : 'auto'
 
+  const rawApproval = (process.env.CODEX_APPROVAL || 'ask').toLowerCase()
+  const codexApproval: CodexApproval = rawApproval === 'allow' ? 'allow' : 'ask'
+
   const config: Config = {
     TELEGRAM_BOT_TOKEN: process.env.TELEGRAM_BOT_TOKEN || '',
     DATA_DIR:           process.env.DATA_DIR || join(USER_DIR, 'data'),
@@ -66,6 +71,7 @@ export function loadConfig(): Config {
     TELEGRAM_ADMIN_IDS: (process.env.TELEGRAM_ADMIN_IDS || '')
       .split(',').map(id => id.trim()).filter(Boolean),
     PERMISSION_MODE:    permMode,
+    CODEX_APPROVAL:     codexApproval,
     availableAgents:    checkAgents(),
   }
 

package/src/handlers/approvals.ts

@@ -0,0 +1,32 @@
+/**
+ * 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.
+ */
+
+interface PendingApproval {
+  resolve:  (approved: boolean) => void
+  timeout:  ReturnType<typeof setTimeout>
+}
+
+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,
+  ttlMs    = 5 * 60 * 1000   // auto-deny after 5 min
+): void {
+  const timeout = setTimeout(() => 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 p = pending.get(id)
+  if (!p) return false
+  clearTimeout(p.timeout)
+  pending.delete(id)
+  p.resolve(approved)
+  return true
+}

package/src/handlers/messages.ts

@@ -1,3 +1,4 @@
+import { randomUUID } from 'crypto'
 import type { Bot, Context, Api } from 'grammy'
 import type { Storage, Session } from '../storage'
 import type { Config } from '../config'
@@ -5,6 +6,11 @@ import { askClaude, type TokenUsage } from '../agents/claude'
 import { askCodex } from '../agents/codex'
 import { mdToTg, splitHtml } from '../utils/markdown'
 import { getLang, t } from '../i18n'
+import { registerApproval, respondApproval } from './approvals'
+
+function escapeHtml(s: string): string {
+  return s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
+}
 
 function formatUsage(usage: TokenUsage): string {
   const fmt = (n: number) => n.toLocaleString('en')
@@ -96,6 +102,25 @@ export function registerMessageHandler(bot: Bot<Context>, storage: Storage, conf
 
     storage.addMessage(chatId, session.id, 'user', text)
 
+    // ── build codex approval handler (only if CODEX_APPROVAL=ask) ──────────
+    const codexApprovalHandler = (session.model === 'codex' && config.CODEX_APPROVAL === '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 }
@@ -104,7 +129,8 @@ export function registerMessageHandler(bot: Bot<Context>, storage: Storage, conf
           (id) => storage.setClaudeSessionId(chatId, session!.id, id))
       } else {
         result = await askCodex(session, text,
-          (id) => storage.setCodexThreadId(chatId, session!.id, id))
+          (id) => storage.setCodexThreadId(chatId, session!.id, id),
+          codexApprovalHandler)
       }
       response = (isFirstMessage && result.usage) ? result.text + formatUsage(result.usage) : result.text
     } catch (err: any) {