cliclaw 1.0.20 → 1.0.22

package/bin/cli.js

@@ -301,11 +301,12 @@ function cmdUpdate() {
         if (!tgzName) throw new Error('npm pack did not produce a .tgz file')
 
         // 2. Extract using the built-in Windows tar (available since Win10 1803)
+        // Use relative paths + cwd so tar doesn't misinterpret "C:" as a network host.
         const extractDir = path.join(tmpDir, 'x')
         fs.mkdirSync(extractDir)
         const winTar = path.join(process.env.SystemRoot || 'C:\\Windows', 'System32', 'tar.exe')
-        execSync(`"${winTar}" -xzf "${path.join(tmpDir, tgzName)}" -C "${extractDir}"`,
-          { stdio: 'pipe' })
+        execSync(`"${winTar}" -xzf "${tgzName}" -C "x"`,
+          { stdio: 'pipe', cwd: tmpDir })
 
         // 3. Copy files into the existing directory (no directory rename = no EBUSY)
         const pkgDir = path.join(extractDir, 'package')

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.20",
-  "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.22",
+  "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
   }
 
@@ -199,6 +237,15 @@ export async function askCodex(
   )
 }
 
+/** Attach a per-session handler that is called whenever codex wants to run a command. */
+export function setCodexApprovalHandler(
+  appSessionId: string,
+  handler: (callId: string, commandStr: string) => Promise<boolean>
+): void {
+  const ps = protoSessions.get(appSessionId)
+  if (ps) ps.approvalHandler = handler
+}
+
 export function killCodexSession(appSessionId: string) {
   const ps = protoSessions.get(appSessionId)
   if (ps) {

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,10 +1,16 @@
+import { randomUUID } from 'crypto'
 import type { Bot, Context, Api } from 'grammy'
 import type { Storage, Session } from '../storage'
 import type { Config } from '../config'
 import { askClaude, type TokenUsage } from '../agents/claude'
-import { askCodex } from '../agents/codex'
+import { askCodex, setCodexApprovalHandler } 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,27 @@ export function registerMessageHandler(bot: Bot<Context>, storage: Storage, conf
 
     storage.addMessage(chatId, session.id, 'user', text)
 
+    // ── Codex approval handler ──────────────────────────────────────────────
+    if (session.model === 'codex') {
+      setCodexApprovalHandler(session.id, (callId, cmdStr) => {
+        const approvalId = randomUUID()
+        const label = `🔧 <b>Codex quer executar:</b>\n<code>${escapeHtml(cmdStr)}</code>`
+        ctx.api.sendMessage(chatId, label, {
+          ...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)
+        })
+      })
+    }
+
     let response: string
     try {
       let result: { text: string; usage?: TokenUsage }