cliclaw 1.0.14 → 1.0.16

package/package.json

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

package/src/agents/codex.ts

@@ -15,9 +15,29 @@ const BASE_ENV = {
   LANG: 'en_US.UTF-8',
 }
 
+function extractTextFromObj(obj: any): string | null {
+  // New codex format: {"id":"...","msg":{"type":"agent_message","text":"..."}}
+  if (obj.msg?.type === 'agent_message' && obj.msg?.text) return obj.msg.text
+  // Old format: item.completed with agent_message
+  if (obj.type === 'item.completed' && obj.item?.type === 'agent_message' && obj.item?.text)
+    return obj.item.text
+  // OpenAI Responses API: response.output_item.done with message content array
+  if (obj.item?.type === 'message' && Array.isArray(obj.item?.content)) {
+    const parts = obj.item.content
+      .filter((c: any) => c.type === 'output_text' && c.text)
+      .map((c: any) => c.text)
+    if (parts.length > 0) return parts.join('')
+  }
+  // Fallback: top-level result/output
+  if (typeof obj.result === 'string' && obj.result) return obj.result
+  if (typeof obj.output === 'string' && obj.output) return obj.output
+  return null
+}
+
 function spawnCodex(args: string[]): Promise<{ text: string; threadId: string | null; usage?: TokenUsage }> {
   return new Promise((resolve, reject) => {
     let stdout = ''
+    let stderr = ''
     const isWin = process.platform === 'win32'
     const proc = spawn('codex', args, {
       env: { ...process.env, ...BASE_ENV },
@@ -29,7 +49,7 @@ function spawnCodex(args: string[]): Promise<{ text: string; threadId: string |
     proc.stdout.on('data', (d: Buffer) => { stdout += d.toString() })
     proc.stderr.on('data', (d: Buffer) => {
       const s = d.toString().trim()
-      if (s) console.error('[Codex stderr]', s)
+      if (s) { stderr += s + '\n'; console.error('[Codex stderr]', s) }
     })
     proc.on('close', (code) => {
       const lines = stdout.split('\n').filter(l => l.trim())
@@ -42,8 +62,8 @@ function spawnCodex(args: string[]): Promise<{ text: string; threadId: string |
           const obj = JSON.parse(line)
           if (obj.type === 'thread.started' && obj.thread_id)
             threadId = obj.thread_id
-          if (obj.type === 'item.completed' && obj.item?.type === 'agent_message' && obj.item?.text)
-            texts.push(obj.item.text)
+          const extracted = extractTextFromObj(obj)
+          if (extracted) texts.push(extracted)
           // Codex/OpenAI usage events (response.completed carries usage)
           const u = obj.usage ?? obj.response?.usage ?? obj.item?.usage
           if (u && (u.input_tokens != null || u.prompt_tokens != null)) {
@@ -57,9 +77,19 @@ function spawnCodex(args: string[]): Promise<{ text: string; threadId: string |
         } catch {}
       }
 
-      if (texts.length > 0) resolve({ text: texts.join('\n'), threadId, usage })
-      else if (code !== 0) reject(new Error(`Codex exited with code ${code}`))
-      else resolve({ text: '[no response]', threadId, usage })
+      if (texts.length > 0) {
+        resolve({ text: texts.join('\n'), threadId, usage })
+      } else if (code !== 0) {
+        reject(new Error(`Codex exited with code ${code}${stderr ? ': ' + stderr.trim() : ''}`))
+      } else {
+        // Log raw output to help diagnose format issues
+        if (stdout.trim()) console.error('[Codex no-parse] raw stdout:', stdout.trim().slice(0, 500))
+        if (stderr.trim()) console.error('[Codex no-parse] stderr:', stderr.trim().slice(0, 500))
+        // Fall back to raw stdout if it's plain text (not JSON)
+        const raw = stdout.trim()
+        const looksLikeJson = raw.startsWith('{') || raw.startsWith('[')
+        resolve({ text: raw && !looksLikeJson ? raw : '[no response]', threadId, usage })
+      }
     })
     proc.on('error', reject)
   })
@@ -71,12 +101,10 @@ export async function askCodex(
   onNewThreadId?: (id: string) => void
 ): Promise<{ text: string; usage?: TokenUsage }> {
   try {
-    const codexThreadId = session.codexThreadId
-    const args = codexThreadId
-      ? ['exec', 'resume', codexThreadId, '--dangerously-bypass-approvals-and-sandbox', '--skip-git-repo-check', '--json', userMessage]
-      : ['exec', '--dangerously-bypass-approvals-and-sandbox', '--skip-git-repo-check', '--json', userMessage]
+    // Always start fresh — codex exec resume <id> <message> rejects the message as unexpected arg
+    const args = ['exec', '--dangerously-bypass-approvals-and-sandbox', '--skip-git-repo-check', '--json', userMessage]
     const { text, threadId, usage } = await spawnCodex(args)
-    if (threadId && !codexThreadId) onNewThreadId?.(threadId)
+    if (threadId && !session.codexThreadId) onNewThreadId?.(threadId)
     return { text, usage }
   } catch (err: any) {
     return { text: `❌ Codex error: ${err.message}` }