gitdone-agent 0.7.4 → 0.7.6

package/index.js

@@ -16,7 +16,7 @@ import {
 } from 'node:fs'
 import { resolve, join } from 'node:path'
 import { homedir, hostname, tmpdir } from 'node:os'
-import { randomUUID } from 'node:crypto'
+import { randomUUID, createHash } from 'node:crypto'
 
 // ─── Stable agent dir, config + logging ────────────────────────────────────────
 // Everything persistent lives here: a stable copy of the agent script (so
@@ -27,7 +27,7 @@ import { randomUUID } 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.7.4'
+const AGENT_VERSION = '0.7.6'
 
 const AGENT_DIR = join(homedir(), '.gitdone-agent')
 const CONFIG_PATH = join(AGENT_DIR, 'config.json')
@@ -909,7 +909,7 @@ 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) {
+async function postRunEvents(cfg, runId, events, status, result, usage, streamingText, activityText, extra) {
   await api(cfg, '/api/v1/agent/ai-run/events', {
     runId,
     events,
@@ -918,9 +918,32 @@ async function postRunEvents(cfg, runId, events, status, result, usage, streamin
     ...(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}`))
 }
 
+// gd-466: parse a hard usage-limit stop out of claude's headless output. On the
+// limit, the CLI surfaces "Claude AI usage limit reached|<epoch_seconds>" (in
+// the result text and/or stderr); the epoch is the window reset. Returns the
+// reset in ms when found, else { limited } with a null resetAt (telemetry is
+// then the backstop), else not limited.
+function detectUsageLimit(text) {
+  const hay = String(text || '')
+  const withEpoch = hay.match(/usage limit reached\s*\|\s*(\d{9,13})/i)
+  if (withEpoch) {
+    let n = Number(withEpoch[1])
+    if (n < 1e12) n *= 1000 // seconds → ms
+    return { limited: true, resetAt: n }
+  }
+  if (/usage limit reached|reached your usage limit|rate limit(?:ed)?|exceeded your.*\blimit\b/i.test(hay)) {
+    return { limited: true, resetAt: null }
+  }
+  return { limited: false, resetAt: null }
+}
+
 // 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) {
@@ -991,6 +1014,11 @@ function parseStreamLine(line, push, onInit, onDelta, onMeta, onTurnEnd) {
   }
   if (ev.type === 'result') {
     if (ev.subtype && ev.subtype !== 'success') push('SYSTEM', `Резултат: ${ev.subtype}`)
+    // gd-466: surface the final result text + subtype so the caller can detect a
+    // hard usage-limit stop (the "usage limit reached|<epoch>" lands here).
+    if (typeof onMeta === 'function' && (ev.subtype || typeof ev.result === 'string')) {
+      onMeta({ subtype: ev.subtype, resultText: typeof ev.result === 'string' ? ev.result : undefined })
+    }
     // claude's final result carries cumulative token usage + its own cost.
     // Prefer `modelUsage` (summed over every model/subagent turn) which is the
     // true cumulative; top-level `usage` is often just the last turn. Fall back
@@ -1176,6 +1204,8 @@ function runAiCommand(cfg, cmd, repoPath) {
   const prompt = cmd.payload?.prompt ?? ''
   const allowCommit = cmd.payload?.allowCommit === true
   const model = aiModelArg(cmd.payload?.model)
+  // gd-466: a token-reset resume asks us to continue claude's own conversation.
+  const resumeId = cmd.payload?.resume || null
   if (!runId || !prompt) {
     reportCommandResult(cfg, cmd.id, 'error', 'invalid ai_run payload')
     return
@@ -1208,6 +1238,10 @@ function runAiCommand(cfg, cmd, repoPath) {
     // Stream text token-by-token + thinking deltas so the terminal shows the
     // reply being written live, ред по ред, not in whole-block batches (gd-419).
     '--include-partial-messages',
+    // gd-466: resume claude's own prior conversation for this task when we're
+    // continuing after a token reset — it keeps its context/todo. A stale/missing
+    // session errors out fast; the watchdog then re-dispatches fresh (no resume).
+    ...(resumeId ? ['--resume', resumeId] : []),
     // Model chosen in gitDone (project default / task); omitted → machine default (gd-354).
     ...(model ? ['--model', model] : []),
     '--permission-mode', 'acceptEdits',
@@ -1240,7 +1274,11 @@ function runAiCommand(cfg, cmd, repoPath) {
     const activityText = activityChanged ? liveActivity : undefined
     sentLive = liveText
     sentActivity = liveActivity
-    await postRunEvents(cfg, runId, batch, undefined, undefined, undefined, streamingText, activityText)
+    // gd-466: persist claude's session id as soon as we have it (once), so a
+    // 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)
     flushing = false
   }
   const push = (kind, text) => {
@@ -1260,14 +1298,25 @@ function runAiCommand(cfg, cmd, repoPath) {
   const timer = setInterval(flush, 500)
 
   // Accumulate model + token usage across the stream (model from init, usage
-  // from the final result event) to report once on exit (gd-334).
-  const meta = { model: undefined, usage: undefined, costUsd: undefined }
+  // from the final result event) to report once on exit (gd-334). gd-466 also
+  // captures the final result text/subtype (for usage-limit detection).
+  const meta = { model: undefined, usage: undefined, costUsd: undefined, resultText: undefined, subtype: undefined }
   const onMeta = (m) => {
     if (m.model) meta.model = m.model
     if (m.usage) meta.usage = m.usage
     if (typeof m.costUsd === 'number') meta.costUsd = m.costUsd
+    if (m.resultText) meta.resultText = m.resultText
+    if (m.subtype) meta.subtype = m.subtype
   }
 
+  // gd-466: claude's own session id (from its init event) + any stderr — both
+  // feed a token-reset resume: the id lets us --resume, the stderr helps detect
+  // a usage-limit stop.
+  let capturedSession = null
+  let sentSession = false
+  const onInit = (sid) => { if (sid) capturedSession = sid }
+  let stderrBuf = ''
+
   log(`▶ ai_run ${runId} @ ${repoPath} via ${claudePath}`)
   postRunEvents(cfg, runId, [{ kind: 'SYSTEM', text: `Стартиране на Claude Code в ${repoPath}…` }], 'running')
 
@@ -1296,14 +1345,14 @@ function runAiCommand(cfg, cmd, repoPath) {
     while ((nl = buf.indexOf('\n')) >= 0) {
       const line = buf.slice(0, nl).trim()
       buf = buf.slice(nl + 1)
-      if (line) parseStreamLine(line, push, undefined, onDelta, onMeta)
+      if (line) parseStreamLine(line, push, onInit, onDelta, onMeta)
     }
   })
-  child.stderr.on('data', (d) => { const s = d.toString().trim(); if (s) push('SYSTEM', s) })
+  child.stderr.on('data', (d) => { const s = d.toString().trim(); if (s) { stderrBuf = (stderrBuf + '\n' + s).slice(-8000); push('SYSTEM', s) } })
   child.on('error', (err) => push('SYSTEM', `Процесна грешка: ${err.message}`))
   child.on('close', async (code) => {
     clearInterval(timer)
-    if (buf.trim()) parseStreamLine(buf.trim(), push, undefined, onDelta, onMeta)
+    if (buf.trim()) parseStreamLine(buf.trim(), push, onInit, onDelta, onMeta)
     liveText = '' // run is over — drop any lingering live preview / thought
     liveActivity = ''
     await flush()
@@ -1312,17 +1361,38 @@ function runAiCommand(cfg, cmd, repoPath) {
     const usage = meta.usage
       ? { model: meta.model, ...meta.usage, ...(typeof meta.costUsd === 'number' ? { costUsd: meta.costUsd } : {}) }
       : undefined
-    const events = [{ kind: 'SYSTEM', text: ok ? '✓ Готово.' : `✗ Процесът приключи с код ${code}.` }]
+
+    // gd-466: did we stop on the token limit? Check the final result text, its
+    // subtype, and stderr. A hard hit gives us the precise reset epoch; report
+    // it so the server parks the task for an exact auto-resume.
+    const limit = detectUsageLimit(`${meta.resultText || ''}\n${meta.subtype || ''}\n${stderrBuf}`)
+    const extra = {
+      ...(capturedSession ? { claudeSessionId: capturedSession } : {}),
+      ...(limit.limited ? { stopReason: 'usage_limit' } : {}),
+      ...(limit.limited && typeof limit.resetAt === 'number' ? { resetAt: limit.resetAt } : {}),
+    }
+
+    const events = [{
+      kind: 'SYSTEM',
+      text: limit.limited
+        ? '⏳ Достигнат лимит на токени — спирам. gitDone ще ме продължи автоматично след ресета.'
+        : (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(
       cfg, runId,
       events,
-      ok ? 'done' : 'error',
-      ok ? 'ok' : `exit ${code}`,
+      // A limit stop is not a clean finish — report it as 'error' so the run
+      // ends and the server's park/resume path (not the DONE path) takes over.
+      ok && !limit.limited ? 'done' : 'error',
+      limit.limited ? 'usage_limit' : (ok ? 'ok' : `exit ${code}`),
       usage,
+      undefined,
+      undefined,
+      extra,
     )
-    reportCommandResult(cfg, cmd.id, ok ? 'done' : 'error', `exit ${code}`)
-    log(`■ ai_run ${runId} приключи (code ${code})`)
+    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' : ''})`)
   })
 }
 
@@ -1834,22 +1904,69 @@ async function readClaudeUsage() {
   }
 }
 
+// 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
+// SYNC_FULL_TICKS as a reconciliation (so a repo the user "forgot" server-side
+// reappears within ~10 min, and a fresh row is recreated if one went missing).
+// In between we send a liveness-only sync (no repos) — the server still returns
+// the tracked list from the DB, so nothing downstream notices (gd-459).
+const SYNC_FULL_TICKS = 20
+let syncRepoSig = null
+let syncFullCountdown = 0
+
 async function sync(cfg, discovered) {
   const usage = await readClaudeUsage()
+  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', {
     machineId: cfg.machineId,
     hostname: cfg.hostname,
     agentVersion: AGENT_VERSION,
     roots: cfg.roots,
-    repos: discovered,
+    repos: full ? discovered : [],
     ...(usage ? { usage } : {}),
   })
+  if (full) { syncRepoSig = sig; syncFullCountdown = SYNC_FULL_TICKS }
+  else syncFullCountdown--
   return data.tracked ?? []
 }
 
-// Push one tracked repo's snapshot and run any pending commands for it.
-async function pushSnapshot(cfg, repo) {
+// Per-repo cache of the last snapshot we actually SENT, so an idle repo whose
+// git state hasn't moved doesn't re-POST an identical snapshot every 30s tick
+// (gd-457). At scale that unchanged-snapshot flood is the dominant idle load on
+// the server; skipping it drops idle traffic by ~an order of magnitude. We still
+// resend at least every SNAPSHOT_HEARTBEAT_TICKS to refresh the repo's
+// lastSeenAt (used only for ordering — no tight online threshold reads it) and
+// as a last-ditch command-drain backstop. Kept long: the SSE stream is the fast
+// path and it reconnects every ~5 min (re-waking a drain), so the snapshot only
+// has to backstop the pathological "SSE totally dead" case (gd-459).
+const SNAPSHOT_HEARTBEAT_TICKS = 40
+const snapshotSigCache = new Map() // path → { sig, skipped }
+
+// Cheap content signature of everything the server persists for a repo. Includes
+// diffs, so an edit to a working-tree file (which leaves modified/staged the
+// same but changes content) still counts as a change and is re-sent.
+function snapshotSignature(snapshot) {
+  return createHash('sha1').update(JSON.stringify(snapshot)).digest('hex')
+}
+
+// Push one tracked repo's snapshot and run any pending commands for it. `force`
+// bypasses the unchanged-skip — used right after a command mutates git state, so
+// the UI reflects it instantly regardless of the signature cache.
+async function pushSnapshot(cfg, repo, force = false) {
   const snapshot = getSnapshot(repo.path)
+
+  // Skip the network POST (and all the server-side DB work it triggers) when the
+  // repo is byte-for-byte unchanged since we last sent it — unless we're due a
+  // heartbeat resend or the caller forced it (gd-457).
+  const sig = snapshotSignature(snapshot)
+  const cached = snapshotSigCache.get(repo.path)
+  if (!force && cached && cached.sig === sig && cached.skipped < SNAPSHOT_HEARTBEAT_TICKS) {
+    cached.skipped++
+    return false // unchanged — nothing sent
+  }
+
   const data = await api(cfg, '/api/v1/agent/snapshot', {
     machineId: cfg.machineId,
     path: repo.path,
@@ -1859,6 +1976,10 @@ async function pushSnapshot(cfg, repo) {
     hasGithubAuth: !!cfg.auth?.[repo.path],
     ...snapshot,
   })
+  // Sent successfully — remember this signature so identical follow-up ticks are
+  // skipped until the next real change or heartbeat (gd-457). A thrown POST never
+  // reaches here, so a failure just retries next tick.
+  snapshotSigCache.set(repo.path, { sig, skipped: 0 })
   // Server issued a (fresh) push token — cache it on disk so we ask only once.
   if (data.githubAuth?.token && data.githubAuth?.repo) {
     cfg.auth = cfg.auth ?? {}
@@ -1868,7 +1989,7 @@ async function pushSnapshot(cfg, repo) {
   for (const cmd of data.commands ?? []) {
     await executeCommand(cfg, cmd, repo.path)
   }
-  return snapshot
+  return true // sent
 }
 
 // ─── Low-latency command channel (gd-274) ───────────────────────────────────────
@@ -1921,7 +2042,7 @@ async function drainCommands(cfg) {
         if (GIT_STATE_CMDS.has(cmd.type)) touched.set(repoPath, cmd.repoName || repoPath)
       }
       for (const [path, name] of touched) {
-        try { await pushSnapshot(cfg, { path, name }) }
+        try { await pushSnapshot(cfg, { path, name }, true) }
         catch (err) { log(`✗ post-command snapshot failed @ ${path}: ${err.message}`) }
       }
     } while (drainAgain)
@@ -1981,11 +2102,12 @@ async function runLoop(cfg) {
       const discovered = scanRepos(cfg.roots)
       const tracked = await sync(cfg, discovered)
       let pushed = 0
+      let skipped = 0
       for (const repo of tracked) {
-        try { await pushSnapshot(cfg, repo); pushed++ }
+        try { (await pushSnapshot(cfg, repo)) ? pushed++ : skipped++ }
         catch (err) { log(`✗ snapshot failed @ ${repo.path}: ${err.message}`) }
       }
-      log(`✓ tick — discovered: ${discovered.length}, tracked: ${tracked.length}, pushed: ${pushed}`)
+      log(`✓ tick — discovered: ${discovered.length}, tracked: ${tracked.length}, pushed: ${pushed}, unchanged: ${skipped}`)
     } catch (err) {
       log(`✗ sync error: ${err.message}`)
     }

package/package.json

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