gitdone-agent 0.8.3 → 0.8.5

package/index.js

@@ -29,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.3'
+const AGENT_VERSION = '0.8.5'
 
 const AGENT_DIR = join(homedir(), '.gitdone-agent')
 const CONFIG_PATH = join(AGENT_DIR, 'config.json')
@@ -999,17 +999,64 @@ function scanRepos(roots, maxDepth = 5) {
 
 // ─── Server sync + commands ─────────────────────────────────────────────────────
 
-async function api(cfg, path, body) {
-  const res = await fetch(`${cfg.url}${path}`, {
-    method: 'POST',
-    headers: { Authorization: `Bearer ${cfg.key}`, 'Content-Type': 'application/json' },
-    body: JSON.stringify(body),
-  })
-  if (!res.ok) {
-    const text = await res.text().catch(() => '')
-    throw new Error(`HTTP ${res.status} ${path}: ${text}`)
+// Keep the deadline below the server-side session stall window. Without a
+// deadline, a proxy/network connection that never completes can block the
+// event-posting loop forever, so no heartbeat reaches the server and the
+// watchdog incorrectly declares a live AI turn stalled.
+const API_REQUEST_TIMEOUT_MS = 10_000
+
+async function apiOnce(cfg, path, body) {
+  const controller = new AbortController()
+  const timer = setTimeout(() => controller.abort(), API_REQUEST_TIMEOUT_MS)
+  try {
+    const res = await fetch(`${cfg.url}${path}`, {
+      method: 'POST',
+      headers: { Authorization: `Bearer ${cfg.key}`, 'Content-Type': 'application/json' },
+      body: JSON.stringify(body),
+      signal: controller.signal,
+    })
+    if (!res.ok) {
+      const text = await res.text().catch(() => '')
+      const err = new Error(`HTTP ${res.status} ${path}: ${text}`)
+      err.status = res.status
+      throw err
+    }
+    return res.json().catch(() => ({}))
+  } finally {
+    clearTimeout(timer)
+  }
+}
+
+// gd-514: statuses where the app server demonstrably never processed the body,
+// so re-sending it can't double-apply anything. 502/503/504 is Caddy answering
+// while `systemctl restart gitdone` is mid-flight — i.e. EVERY deploy. A thrown
+// fetch (no status) is a connection that never completed, same story. 4xx and
+// 500 are NOT retried: they won't get better, and a 500 may have half-applied.
+function isRetriableApiError(err) {
+  return err?.status === undefined || [408, 429, 502, 503, 504].includes(err.status)
+}
+
+/**
+ * POST to the app, retrying the failures that are purely "the server wasn't
+ * there". Console events used to be strictly best-effort, which meant a single
+ * 502 during a deploy could swallow the terminal "turn finished" post and leave
+ * the session RUNNING forever, showing a half-written reply that never moved
+ * again (gd-514).
+ */
+async function api(cfg, path, body, attempts = 4) {
+  let lastErr
+  for (let i = 0; i < attempts; i++) {
+    try {
+      return await apiOnce(cfg, path, body)
+    } catch (err) {
+      lastErr = err
+      if (i === attempts - 1 || !isRetriableApiError(err)) break
+      // 1s, 2s, 4s — covers the restart window of a deploy without stalling the
+      // console noticeably when the server is merely slow.
+      await new Promise((r) => setTimeout(r, 1000 * 2 ** i))
+    }
   }
-  return res.json().catch(() => ({}))
+  throw lastErr
 }
 
 async function reportCommandResult(cfg, id, status, result) {
@@ -1021,20 +1068,28 @@ async function reportCommandResult(cfg, id, status, result) {
 // how many tokens the run cost. `streamingText` / `activityText` (gd-419) carry
 // the live "being typed" preview and the latest thinking snippet — explicit ''
 // clears them; `undefined` leaves them untouched.
-async function postRunEvents(cfg, runId, events, status, result, usage, streamingText, activityText, extra) {
-  await api(cfg, '/api/v1/agent/ai-run/events', {
-    runId,
-    events,
-    ...(status ? { status } : {}),
-    ...(result !== undefined ? { result } : {}),
-    ...(usage ? { usage } : {}),
-    ...(streamingText !== undefined ? { streamingText } : {}),
-    ...(activityText !== undefined ? { activityText } : {}),
-    // gd-466: claude's own session id (for --resume) + precise stop cause.
-    ...(extra?.claudeSessionId ? { claudeSessionId: extra.claudeSessionId } : {}),
-    ...(extra?.stopReason ? { stopReason: extra.stopReason } : {}),
-    ...(typeof extra?.resetAt === 'number' ? { resetAt: extra.resetAt } : {}),
-  }).catch((e) => log(`✗ ai-run events post failed: ${e.message}`))
+// Same contract as postSessionEvents: true when it landed, false when the
+// caller must keep the batch and retry it (gd-514).
+async function postRunEvents(cfg, runId, events, status, result, usage, streamingText, activityText, extra, attempts) {
+  try {
+    await api(cfg, '/api/v1/agent/ai-run/events', {
+      runId,
+      events,
+      ...(status ? { status } : {}),
+      ...(result !== undefined ? { result } : {}),
+      ...(usage ? { usage } : {}),
+      ...(streamingText !== undefined ? { streamingText } : {}),
+      ...(activityText !== undefined ? { activityText } : {}),
+      // gd-466: claude's own session id (for --resume) + precise stop cause.
+      ...(extra?.claudeSessionId ? { claudeSessionId: extra.claudeSessionId } : {}),
+      ...(extra?.stopReason ? { stopReason: extra.stopReason } : {}),
+      ...(typeof extra?.resetAt === 'number' ? { resetAt: extra.resetAt } : {}),
+    }, attempts)
+    return true
+  } catch (e) {
+    log(`✗ ai-run events post failed: ${e.message}`)
+    return false
+  }
 }
 
 // gd-466: parse a hard usage-limit stop out of claude's headless output. On the
@@ -1058,17 +1113,26 @@ function detectUsageLimit(text) {
 
 // Post transcript lines (and optional turn status / Claude session id) for an
 // interactive AiSession chat turn.
-async function postSessionEvents(cfg, sessionId, events, status, claudeSessionId, streamingText, activityText) {
-  await api(cfg, '/api/v1/agent/ai-session/events', {
-    sessionId,
-    events,
-    ...(status ? { status } : {}),
-    ...(claudeSessionId ? { claudeSessionId } : {}),
-    // Explicit '' clears the live preview; `undefined` leaves it untouched.
-    ...(streamingText !== undefined ? { streamingText } : {}),
-    // Same semantics for the live thinking snippet (gd-419).
-    ...(activityText !== undefined ? { activityText } : {}),
-  }).catch((e) => log(`✗ ai-session events post failed: ${e.message}`))
+// Returns true when the post landed. A false is the caller's cue to put the
+// batch back and re-send it next tick, instead of dropping it on the floor
+// (gd-514) — that is how whole chunks of a reply used to go missing.
+async function postSessionEvents(cfg, sessionId, events, status, claudeSessionId, streamingText, activityText, attempts) {
+  try {
+    await api(cfg, '/api/v1/agent/ai-session/events', {
+      sessionId,
+      events,
+      ...(status ? { status } : {}),
+      ...(claudeSessionId ? { claudeSessionId } : {}),
+      // Explicit '' clears the live preview; `undefined` leaves it untouched.
+      ...(streamingText !== undefined ? { streamingText } : {}),
+      // Same semantics for the live thinking snippet (gd-419).
+      ...(activityText !== undefined ? { activityText } : {}),
+    }, attempts)
+    return true
+  } catch (e) {
+    log(`✗ ai-session events post failed: ${e.message}`)
+    return false
+  }
 }
 
 // Turn one stream-json line from `claude -p` into console events. Phase 1 shows
@@ -1645,7 +1709,9 @@ function runAiCommand(cfg, cmd, repoPath) {
     const activityChanged = liveActivity !== sentActivity
     if (pending.length === 0 && !liveChanged && !activityChanged) return
     flushing = true
-    const batch = pending; pending = []
+    const taken = pending; pending = []
+    const prevSentLive = sentLive
+    const prevSentActivity = sentActivity
     const streamingText = liveChanged ? liveText : undefined
     const activityText = activityChanged ? liveActivity : undefined
     sentLive = liveText
@@ -1654,7 +1720,16 @@ function runAiCommand(cfg, cmd, repoPath) {
     // resume survives even if the agent dies before the clean close handler.
     const extra = (!sentSession && capturedSession) ? { claudeSessionId: capturedSession } : undefined
     if (extra) sentSession = true
-    await postRunEvents(cfg, runId, batch, undefined, undefined, undefined, streamingText, activityText, extra)
+    const ok = await postRunEvents(cfg, runId, taken, undefined, undefined, undefined, streamingText, activityText, extra)
+    if (!ok) {
+      // Keep everything for the next tick rather than losing console lines to
+      // one bad request (gd-514) — including the session id, so a resume still
+      // gets it.
+      pending = taken.concat(pending)
+      sentLive = prevSentLive
+      sentActivity = prevSentActivity
+      if (extra) sentSession = false
+    }
     flushing = false
   }
   const push = (kind, text) => {
@@ -1757,7 +1832,9 @@ function runAiCommand(cfg, cmd, repoPath) {
         : (ok ? '✓ Готово.' : `✗ Процесът приключи с код ${code}.`),
     }]
     if (usage) events.push({ kind: 'SYSTEM', text: `📊 Токени: ${fmtTokens(usage.inputTokens)} вход · ${fmtTokens(usage.outputTokens)} изход${usage.cacheReadTokens ? ` · ${fmtTokens(usage.cacheReadTokens)} кеш` : ''}${typeof usage.costUsd === 'number' ? ` · $${usage.costUsd.toFixed(4)}` : ''}` })
-    await postRunEvents(
+    // Terminal post — retried hard (gd-514): losing it leaves the run stuck on
+    // RUNNING, and with it the token-limit park/resume the server keys off.
+    const landed = await postRunEvents(
       cfg, runId,
       events,
       // A limit stop is not a clean finish — report it as 'error' so the run
@@ -1768,7 +1845,9 @@ function runAiCommand(cfg, cmd, repoPath) {
       undefined,
       undefined,
       extra,
+      7,
     )
+    if (!landed) log(`✗ ai_run ${runId}: терминалният пост не мина — сървърният watchdog поема`)
     reportCommandResult(cfg, cmd.id, ok && !limit.limited ? 'done' : 'error', limit.limited ? 'usage_limit' : `exit ${code}`)
     log(`■ ai_run ${runId} приключи (code ${code}${limit.limited ? ', usage_limit' : ''})`)
   })
@@ -1863,12 +1942,26 @@ async function flushChatTurn(cfg, entry) {
   const heartbeat = !hasEvents && !liveChanged && !activityChanged && Date.now() - t.lastPostAt > 2500
   if (!hasEvents && !liveChanged && !activityChanged && !heartbeat) return
   t.flushing = true
-  const batch = t.pending.map((e) => ({ role: chatRoleFor(e.kind), text: e.text })); t.pending = []
+  const taken = t.pending; t.pending = []
+  const prevSentLive = t.sentLive
+  const prevSentActivity = t.sentActivity
   const streamingText = liveChanged ? t.liveText : undefined
   const activityText = activityChanged ? t.liveActivity : undefined
   t.sentLive = t.liveText
   t.sentActivity = t.liveActivity
-  await postSessionEvents(cfg, entry.sessionId, batch, 'running', entry.capturedSession || undefined, streamingText, activityText)
+  const ok = await postSessionEvents(
+    cfg, entry.sessionId,
+    taken.map((e) => ({ role: chatRoleFor(e.kind), text: e.text })),
+    'running', entry.capturedSession || undefined, streamingText, activityText,
+  )
+  if (!ok) {
+    // Put it all back so the next tick re-sends it (gd-514). Dropping the batch
+    // is what used to tear holes in the transcript; rewinding sentLive makes the
+    // next post carry the current live text again (it's a replace, not a delta).
+    t.pending = taken.concat(t.pending)
+    t.sentLive = prevSentLive
+    t.sentActivity = prevSentActivity
+  }
   t.lastPostAt = Date.now()
   t.flushing = false
 }
@@ -1889,21 +1982,31 @@ async function finishChatTurn(cfg, entry, outcome) {
   for (let i = 0; i < 20 && t.flushing; i++) await new Promise((r) => setTimeout(r, 100))
   const batch = t.pending.map((e) => ({ role: chatRoleFor(e.kind), text: e.text }))
   t.pending = []
+  // The one post that MUST land: it carries the last of the reply and the
+  // terminal status. Lose it and the console shows "АИ пише…" over a
+  // half-written answer forever (gd-514) — so it gets ~1 minute of retries,
+  // enough to outlast an app restart. The server's stall watchdog is the net if
+  // even that fails.
+  const terminal = async (status, extra) => {
+    const ok = await postSessionEvents(
+      cfg, entry.sessionId, extra ? batch.concat(extra) : batch, status,
+      entry.capturedSession || undefined, '', '', 7,
+    )
+    if (!ok) log(`✗ ai_chat ${entry.sessionId}: терминалният пост не мина — сървърът ще помири сесията`)
+  }
   if (outcome.stopped) {
-    batch.push({ role: 'SYSTEM', text: '⏹ Спряно. Напиши още нещо, за да продължим разговора.' })
-    await postSessionEvents(cfg, entry.sessionId, batch, 'idle', entry.capturedSession || undefined, '', '')
+    await terminal('idle', { role: 'SYSTEM', text: '⏹ Спряно. Напиши още нещо, за да продължим разговора.' })
     reportCommandResult(cfg, t.cmdId, 'done', 'stopped by user')
     log(`⏹ ai_chat ${entry.sessionId} спряно от потребителя`)
     return
   }
   if (!outcome.ok) {
-    batch.push({ role: 'SYSTEM', text: `✗ Ходът приключи с код ${outcome.code}.` })
-    await postSessionEvents(cfg, entry.sessionId, batch, 'error', entry.capturedSession || undefined, '', '')
+    await terminal('error', { role: 'SYSTEM', text: `✗ Ходът приключи с код ${outcome.code}.` })
     reportCommandResult(cfg, t.cmdId, 'error', `exit ${outcome.code}`)
     log(`✗ ai_chat ход в ${entry.sessionId} падна (code ${outcome.code})`)
     return
   }
-  await postSessionEvents(cfg, entry.sessionId, batch, 'idle', entry.capturedSession || undefined, '', '')
+  await terminal('idle')
   reportCommandResult(cfg, t.cmdId, 'done', 'ok')
   log(`✓ ai_chat ход в ${entry.sessionId} приключи (процесът остава жив)`)
 }

package/package.json

@@ -1,7 +1,7 @@
 {
     "name":  "gitdone-agent",
-    "version":  "0.8.3",
-    "description":  "Local git agent for gitdone — watches a local repo and sends snapshots to gitdone.eu",
+    "version":  "0.8.5",
+    "description":  "Local git agent for gitdone — watches a local repo and sends snapshots to gitdone.eu",
     "type":  "module",
     "bin":  {
                 "gitdone-agent":  "index.js"