gitdone-agent 0.7.4 → 0.7.5

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.5'
 
 const AGENT_DIR = join(homedir(), '.gitdone-agent')
 const CONFIG_PATH = join(AGENT_DIR, 'config.json')
@@ -1834,22 +1834,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 +1906,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 +1919,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 +1972,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 +2032,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.5",
     "description":  "Local git agent for gitdone — watches a local repo and sends snapshots to gitdone.eu",
     "type":  "module",
     "bin":  {