gitdone-agent 0.8.0 → 0.8.1

package/index.js

@@ -10,6 +10,7 @@
 // from ~/.gitdone-agent/config.json, so the autostart entry needs no args.
 
 import { execSync, execFileSync, spawn } from 'node:child_process'
+import readline from 'node:readline'
 import {
   existsSync, writeFileSync, readFileSync, unlinkSync, renameSync,
   mkdirSync, copyFileSync, appendFileSync, readdirSync, rmSync, statSync,
@@ -28,7 +29,7 @@ import { randomUUID, createHash } from 'node:crypto'
 // Reported to the server on every sync so the web UI can flag outdated agents.
 // Keep in lockstep with packages/agent/package.json "version" AND
 // src/lib/agentVersion.ts LATEST_AGENT_VERSION.
-const AGENT_VERSION = '0.8.0'
+const AGENT_VERSION = '0.8.1'
 
 const AGENT_DIR = join(homedir(), '.gitdone-agent')
 const CONFIG_PATH = join(AGENT_DIR, 'config.json')
@@ -2388,19 +2389,14 @@ async function readClaudeUsage() {
 }
 
 // ─── Codex (ChatGPT) plan usage (gd-492) ───────────────────────────────────
-// Codex knows its own rate limits but does NOT put them in the `codex exec
-// --json` stdout stream (upstream openai/codex#14728). It DOES write them to the
-// session rollout it keeps on disk:
-//   ~/.codex/sessions/<YYYY>/<MM>/<DD>/rollout-<ts>-<thread>.jsonl
-// where `token_count` lines carry:
-//   payload.rate_limits = { primary: { used_percent, window_minutes, resets_at },
-//                           secondary: …|null, plan_type, credits, … }
-// So we read the newest rollout and take its LAST rate_limits record.
+// Ask Codex itself for the ChatGPT account rate limits, instead of guessing from
+// a previous run's transcript. The app-server API is the same local surface the
+// clients use for account/rateLimits/read; it returns primary/secondary windows
+// when the account has both a short and a weekly/general Codex bucket.
 //
-// Unlike the Claude numbers — fetched live from Anthropic on every tick — these
-// are only as fresh as the user's last Codex run, which is why we report the
-// rollout line's OWN timestamp as observedAt instead of "now". The console can
-// then say how old they are rather than implying they're live.
+// If that live read fails, fall back to the last rollout file so old Codex
+// installs still show something. Rollout values are telemetry only and may not
+// include every limit the CLI enforces.
 
 // Newest entry in a dir, by name (the sessions tree is zero-padded YYYY/MM/DD,
 // so the lexicographic max IS the newest) or by mtime for the files themselves.
@@ -2435,8 +2431,20 @@ function readTail(file, bytes) {
   return start > 0 ? text.slice(text.indexOf('\n') + 1) : text
 }
 
-// One window of a Codex rate limit → the shape the server stores.
-function codexWindow(w) {
+function codexAppWindow(w) {
+  if (!w || typeof w !== 'object') return null
+  const pct = Number(w.usedPercent)
+  if (!Number.isFinite(pct)) return null
+  const resets = Number(w.resetsAt)
+  return {
+    pct: Math.round(pct),
+    windowMin: Number.isFinite(Number(w.windowDurationMins)) ? Math.round(Number(w.windowDurationMins)) : null,
+    resetsAt: Number.isFinite(resets) && resets > 0 ? new Date(resets * 1000).toISOString() : null,
+  }
+}
+
+// One rollout window of a Codex rate limit → the shape the server stores.
+function codexRolloutWindow(w) {
   if (!w || typeof w !== 'object') return null
   const pct = Number(w.used_percent)
   if (!Number.isFinite(pct)) return null
@@ -2449,10 +2457,77 @@ function codexWindow(w) {
   }
 }
 
-let codexUsageCache = { at: 0, data: null }
-function readCodexUsage() {
-  const now = Date.now()
-  if (codexUsageCache.data && now - codexUsageCache.at < 60_000) return codexUsageCache.data
+function codexUsageFromSnapshot(snapshot) {
+  if (!snapshot || typeof snapshot !== 'object') return null
+  const primary = codexAppWindow(snapshot.primary)
+  const secondary = codexAppWindow(snapshot.secondary)
+  if (!primary && !secondary) return null
+  return {
+    primary,
+    secondary,
+    planType: typeof snapshot.planType === 'string' ? snapshot.planType : null,
+    observedAt: new Date().toISOString(),
+  }
+}
+
+function readCodexUsageFromAppServer() {
+  return new Promise((resolve) => {
+    const { path: codexPath, shell, found } = findCodex()
+    if (!found) return resolve(null)
+
+    let settled = false
+    let child
+    const finish = (value) => {
+      if (settled) return
+      settled = true
+      clearTimeout(timer)
+      try { child?.kill() } catch { /* best-effort */ }
+      resolve(value)
+    }
+    const timer = setTimeout(() => finish(null), 12_000)
+
+    try {
+      child = spawn(codexPath, ['app-server', '--stdio'], {
+        stdio: ['pipe', 'pipe', 'ignore'],
+        shell,
+        windowsHide: true,
+      })
+    } catch {
+      return finish(null)
+    }
+
+    child.on('error', () => finish(null))
+    child.on('exit', () => finish(null))
+
+    const rl = readline.createInterface({ input: child.stdout })
+    rl.on('line', (line) => {
+      let msg
+      try { msg = JSON.parse(line) } catch { return }
+      if (msg.id !== 2) return
+      if (msg.error) return finish(null)
+      const result = msg.result
+      const byId = result?.rateLimitsByLimitId
+      const snapshot = byId?.codex || result?.rateLimits
+      finish(codexUsageFromSnapshot(snapshot))
+    })
+
+    const send = (message) => {
+      try { child.stdin.write(`${JSON.stringify(message)}\n`) } catch { finish(null) }
+    }
+    send({
+      method: 'initialize',
+      id: 1,
+      params: {
+        clientInfo: { name: 'gitdone-agent', title: 'gitDone Agent', version: AGENT_VERSION },
+        capabilities: { experimentalApi: true },
+      },
+    })
+    send({ method: 'initialized', params: {} })
+    send({ method: 'account/rateLimits/read', id: 2 })
+  })
+}
+
+function readCodexUsageFromRollout() {
   try {
     const root = join(homedir(), '.codex', 'sessions')
     if (!existsSync(root)) return null
@@ -2477,18 +2552,16 @@ function readCodexUsage() {
           try { ev = JSON.parse(line) } catch { continue }
           const rl = ev?.payload?.rate_limits
           if (!rl || typeof rl !== 'object') continue
-          const primary = codexWindow(rl.primary)
-          const secondary = codexWindow(rl.secondary)
+          const primary = codexRolloutWindow(rl.primary)
+          const secondary = codexRolloutWindow(rl.secondary)
           if (!primary && !secondary) continue
-          const data = {
+          return {
             primary,
             secondary,
             planType: typeof rl.plan_type === 'string' ? rl.plan_type : null,
             // When these numbers were actually true — the run that produced them.
             observedAt: typeof ev.timestamp === 'string' ? ev.timestamp : new Date(statSync(file).mtimeMs).toISOString(),
           }
-          codexUsageCache = { at: now, data }
-          return data
         }
       }
     }
@@ -2498,6 +2571,15 @@ function readCodexUsage() {
   }
 }
 
+let codexUsageCache = { at: 0, data: null }
+async function readCodexUsage() {
+  const now = Date.now()
+  if (codexUsageCache.data && now - codexUsageCache.at < 60_000) return codexUsageCache.data
+  const data = await readCodexUsageFromAppServer() || readCodexUsageFromRollout()
+  if (data) codexUsageCache = { at: now, data }
+  return data
+}
+
 // The discovered repo list barely ever changes, but re-upserting every repo's
 // row on the server each tick is pure idle write load at scale. So we ship the
 // full `repos` list only when the discovered set actually changed, or every
@@ -2513,7 +2595,7 @@ async function sync(cfg, discovered) {
   const usage = await readClaudeUsage()
   // gd-492: the ChatGPT side's own limits, so a Codex console shows ITS numbers
   // instead of Claude's. Both ride along — one machine can run both engines.
-  const codexUsage = readCodexUsage()
+  const codexUsage = await readCodexUsage()
   const sig = createHash('sha1').update(JSON.stringify(discovered)).digest('hex')
   const full = sig !== syncRepoSig || syncFullCountdown <= 0
   const data = await api(cfg, '/api/v1/agent/sync', {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name":  "gitdone-agent",
-    "version":  "0.8.0",
+    "version":  "0.8.1",
     "description":  "Local git agent for gitdone — watches a local repo and sends snapshots to gitdone.eu",
     "type":  "module",
     "bin":  {