cliclaw 1.0.17 → 1.0.18

package/package.json

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

package/src/agents/codex.ts

@@ -1,10 +1,9 @@
-import { spawn } from 'child_process'
-import type { Session, Message } from '../storage'
+import { spawn, ChildProcess } from 'child_process'
+import { randomUUID } from 'crypto'
 import type { TokenUsage } from './claude'
 
 const HOME = process.env.HOME || process.env.USERPROFILE || '/root'
 const SEP = process.platform === 'win32' ? ';' : ':'
-// Keep system PATH (contains npm global bin) and append Linux fallbacks for non-Windows
 const BASE_ENV = {
   PATH: [
     process.env.PATH || '',
@@ -15,119 +14,195 @@ 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
+const SESSION_TTL_MS = 30 * 60 * 1000  // kill idle processes after 30 min
+const RESPONSE_TIMEOUT_MS = 120_000     // 2 min per message
+
+interface PendingReq {
+  resolve: (r: { text: string; usage?: TokenUsage }) => void
+  reject:  (e: Error) => void
+  texts:   string[]
+  usage?:  TokenUsage
+  timer:   ReturnType<typeof setTimeout>
 }
 
-function buildPrompt(history: Message[], userMessage: string): string {
-  // history already contains the current user message as the last item (added before askCodex)
-  const prior = history.slice(0, -1).slice(-20)  // up to last 20 prior messages
-  if (prior.length === 0) return userMessage
-  const lines = prior.map(m => {
-    let content = m.content
-    // Strip usage stats suffix (e.g. "\n`📊 ↑1234 ↓56`")
-    const usageIdx = content.lastIndexOf('\n`📊')
-    if (usageIdx > 0) content = content.slice(0, usageIdx)
-    if (content.length > 600) content = content.slice(0, 600) + '…'
-    return `${m.role === 'user' ? 'User' : 'Assistant'}: ${content}`
-  })
-  return `<conversation_history>\n${lines.join('\n')}\n</conversation_history>\n\nUser: ${userMessage}`
+interface ProtoSession {
+  proc:      ChildProcess
+  sessionId: string
+  lastUsed:  number
+  pending:   Map<string, PendingReq>
+  buf:       string   // incomplete stdout line buffer
 }
 
-function spawnCodex(args: string[], stdinText?: 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 },
-      cwd: process.cwd(),
-      shell: isWin,
-      windowsHide: true,
-      // Use pipe for stdin when we have text to send; otherwise ignore to prevent PM2 hang
-      stdio: [stdinText != null ? 'pipe' : 'ignore', 'pipe', 'pipe'],
-    })
-    if (stdinText != null) {
-      proc.stdin!.end(stdinText, 'utf8')
+// Map from cliclaw session.id → ProtoSession
+const protoSessions = new Map<string, ProtoSession>()
+
+// ─── cleanup idle sessions every 5 min ───────────────────────────────────────
+setInterval(() => {
+  const now = Date.now()
+  for (const [id, ps] of protoSessions) {
+    if (ps.pending.size === 0 && now - ps.lastUsed > SESSION_TTL_MS) {
+      console.log(`[Codex] closing idle proto session ${ps.sessionId}`)
+      try { ps.proc.stdin!.write(JSON.stringify({ id: 'shutdown', op: { type: 'shutdown' } }) + '\n') } catch {}
+      setTimeout(() => { try { ps.proc.kill() } catch {} }, 2000)
+      protoSessions.delete(id)
     }
-    proc.stdout.on('data', (d: Buffer) => { stdout += d.toString() })
-    proc.stderr.on('data', (d: Buffer) => {
-      const s = d.toString().trim()
-      if (s) { stderr += s + '\n'; console.error('[Codex stderr]', s) }
-    })
-    proc.on('close', (code) => {
-      const lines = stdout.split('\n').filter(l => l.trim())
-      const texts: string[] = []
-      let threadId: string | null = null
-      let usage: TokenUsage | undefined
-
-      for (const line of lines) {
-        try {
-          const obj = JSON.parse(line)
-          if (obj.type === 'thread.started' && obj.thread_id)
-            threadId = obj.thread_id
-          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)) {
-            usage = {
-              input:      u.input_tokens  ?? u.prompt_tokens     ?? 0,
-              output:     u.output_tokens ?? u.completion_tokens ?? 0,
-              cacheRead:  u.input_tokens_details?.cached_tokens  ?? 0,
-              cacheWrite: 0,
-            }
-          }
-        } catch {}
-      }
+  }
+}, 5 * 60 * 1000)
 
-      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)
+// ─── start a codex proto process ─────────────────────────────────────────────
+function startProto(appSessionId: string): ProtoSession {
+  const isWin = process.platform === 'win32'
+  const proc = spawn('codex', ['proto'], {
+    env: { ...process.env, ...BASE_ENV },
+    shell: isWin,
+    windowsHide: true,
+    stdio: ['pipe', 'pipe', 'pipe'],
   })
+
+  const ps: ProtoSession = {
+    proc,
+    sessionId: '',
+    lastUsed: Date.now(),
+    pending: new Map(),
+    buf: '',
+  }
+
+  proc.stdout!.on('data', (d: Buffer) => {
+    const lines = (ps.buf + d.toString()).split('\n')
+    ps.buf = lines.pop() || ''
+    for (const line of lines) {
+      if (!line.trim()) continue
+      try {
+        const obj = JSON.parse(line)
+        handleProtoEvent(ps, obj)
+      } catch {}
+    }
+  })
+
+  proc.stderr!.on('data', (d: Buffer) => {
+    const s = d.toString()
+    // Only log actual errors, not Rust INFO/DEBUG log lines
+    if (s.includes(' ERROR ') || (!s.includes(' INFO ') && !s.includes(' WARN ') && s.trim()))
+      console.error('[Codex proto]', s.trim())
+  })
+
+  proc.on('close', () => {
+    for (const [, req] of ps.pending) {
+      clearTimeout(req.timer)
+      req.reject(new Error('Codex process exited unexpectedly'))
+    }
+    protoSessions.delete(appSessionId)
+  })
+
+  proc.on('error', (err) => {
+    for (const [, req] of ps.pending) {
+      clearTimeout(req.timer)
+      req.reject(err)
+    }
+    protoSessions.delete(appSessionId)
+  })
+
+  protoSessions.set(appSessionId, ps)
+  return ps
 }
 
+function handleProtoEvent(ps: ProtoSession, obj: any) {
+  const msgId: string = obj.id
+  const msg = obj.msg
+
+  if (msg?.type === 'session_configured') {
+    ps.sessionId = msg.session_id ?? ''
+    return
+  }
+
+  const req = msgId ? ps.pending.get(msgId) : null
+  if (!req) return
+
+  switch (msg?.type) {
+    case 'agent_message':
+      if (msg.message) req.texts.push(msg.message)
+      break
+    case 'token_count': {
+      const u = msg.info?.last_token_usage
+      if (u) {
+        req.usage = {
+          input:      u.input_tokens         ?? 0,
+          output:     u.output_tokens        ?? 0,
+          cacheRead:  u.cached_input_tokens  ?? 0,
+          cacheWrite: 0,
+        }
+      }
+      break
+    }
+    case 'task_complete': {
+      clearTimeout(req.timer)
+      const text = req.texts.join('\n') || msg.last_agent_message || '[no response]'
+      req.resolve({ text, usage: req.usage })
+      ps.pending.delete(msgId)
+      break
+    }
+    case 'error': {
+      clearTimeout(req.timer)
+      req.reject(new Error(msg.message ?? 'Codex error'))
+      ps.pending.delete(msgId)
+      break
+    }
+  }
+}
+
+function getOrStart(appSessionId: string): ProtoSession {
+  const existing = protoSessions.get(appSessionId)
+  if (existing && existing.proc.exitCode === null) {
+    existing.lastUsed = Date.now()
+    return existing
+  }
+  return startProto(appSessionId)
+}
+
+// ─── public API ──────────────────────────────────────────────────────────────
 export async function askCodex(
-  session: Session,
+  session: { id: string; codexThreadId?: string },
   userMessage: string,
-  onNewThreadId?: (id: string) => void
+  _onNewThreadId?: (id: string) => void
 ): Promise<{ text: string; usage?: TokenUsage }> {
-  try {
-    // Build full prompt with conversation history, send via stdin (avoids Windows arg escaping issues)
-    const prompt = buildPrompt(session.history, userMessage)
-    // `-` tells codex exec to read PROMPT from stdin
-    const args = ['exec', '--dangerously-bypass-approvals-and-sandbox', '--skip-git-repo-check', '--json', '-']
-    const { text, threadId, usage } = await spawnCodex(args, prompt)
-    if (threadId && !session.codexThreadId) onNewThreadId?.(threadId)
-    return { text, usage }
-  } catch (err: any) {
-    return { text: `❌ Codex error: ${err.message}` }
+  const ps = getOrStart(session.id)
+  const msgId = randomUUID()
+
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      ps.pending.delete(msgId)
+      reject(new Error('Codex response timeout (120s)'))
+    }, RESPONSE_TIMEOUT_MS)
+
+    ps.pending.set(msgId, {
+      resolve,
+      reject,
+      texts: [],
+      timer,
+    })
+
+    const op = JSON.stringify({
+      id: msgId,
+      op: { type: 'user_input', items: [{ type: 'text', text: userMessage }] },
+    })
+
+    try {
+      ps.proc.stdin!.write(op + '\n')
+    } catch (err: any) {
+      clearTimeout(timer)
+      ps.pending.delete(msgId)
+      reject(new Error(`Failed to write to codex: ${err.message}`))
+    }
+  }).then(
+    (r: any) => r,
+    async (err: Error) => ({ text: `❌ Codex error: ${err.message}` })
+  )
+}
+
+export function killCodexSession(appSessionId: string) {
+  const ps = protoSessions.get(appSessionId)
+  if (ps) {
+    try { ps.proc.kill() } catch {}
+    protoSessions.delete(appSessionId)
   }
 }

package/src/handlers/commands.ts

@@ -2,6 +2,7 @@ import type { Bot, Context } from 'grammy'
 import type { Storage } from '../storage'
 import type { Config, AgentName } from '../config'
 import { killSession } from '../agents/claude'
+import { killCodexSession } from '../agents/codex'
 import { formatTelegramMarkdown, splitTelegramMessage, TELEGRAM_MARKDOWN_OPTS } from '../telegram'
 import { dockerHelpText, pm2HelpText, runDockerCommand, runPm2Command } from '../admin'
 import { getLang, t } from '../i18n'
@@ -180,6 +181,7 @@ export function registerCommands(bot: Bot<Context>, storage: Storage, config: Co
       : storage.getActiveSession(chatId)
     if (!session) { await ctx.reply(t(lang, 'noActiveSession')); return }
     killSession(session.id)
+    killCodexSession(session.id)
     storage.clearSession(chatId, session.id)
     const opts: any = session.threadId ? { message_thread_id: session.threadId } : {}
     await ctx.reply(