gitdone-agent 0.5.4 → 0.6.0

package/index.js

@@ -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.5.4'
+const AGENT_VERSION = '0.6.0'
 
 const AGENT_DIR = join(homedir(), '.gitdone-agent')
 const CONFIG_PATH = join(AGENT_DIR, 'config.json')
@@ -264,20 +264,71 @@ function authUrl(auth) {
   return `https://x-access-token:${auth.token}@github.com/${repo}.git`
 }
 
+// A push rejected because the remote branch moved ahead of us (someone else
+// pushed in the meantime). Git prints "non-fast-forward" / "fetch first" /
+// "tip of your current branch is behind". We recover by pulling+rebasing.
+const NON_FAST_FORWARD = /non-fast-forward|fetch first|tip of your current branch is behind|failed to push some refs/i
+
+// Point the local remote-tracking ref (e.g. refs/remotes/origin/master) at the
+// commit we just synced. We push/pull through the ad-hoc token URL, and — unlike
+// `git push origin` — pushing/pulling by URL leaves refs/remotes/origin/* UNTOUCHED.
+// getSnapshot() then measures "ahead"/"behind" against that stale tracking ref
+// (git rev-list @{u}..HEAD), so already-pushed commits keep showing as pending
+// forever: the ahead badge never clears, GitHub Desktop shows the same "N↑", and
+// the user pushes again and again while local commits pile up (gd-273). Fast-
+// forwarding the tracking ref to the true remote tip resets ahead/behind to reality.
+// Best-effort: git() swallows failures so this never breaks the push/pull itself.
+function updateTrackingRef(repoPath, branch, commitish) {
+  // Prefer the branch's configured upstream (usually origin/<branch>); fall back
+  // to origin/<branch> when no upstream is set.
+  const upstream = git('git rev-parse --abbrev-ref --symbolic-full-name @{u}', repoPath)
+  const ref = upstream ? `refs/remotes/${upstream}` : `refs/remotes/origin/${branch}`
+  git(`git update-ref "${ref}" ${commitish}`, repoPath)
+}
+
 // Push/pull using the server-issued token when we have one; otherwise fall back
 // to the machine's own git credentials (old behaviour). Throws on failure.
 function pushOrPull(type, repoPath, auth) {
   const branch = git('git branch --show-current', repoPath) || 'HEAD'
-  let cmd
-  if (auth) {
-    const url = authUrl(auth)
-    cmd = type === 'push' ? `git push "${url}" HEAD:${branch}` : `git pull "${url}" ${branch}`
-  } else {
-    cmd = type === 'push' ? 'git push' : 'git pull'
+  const url = auth ? authUrl(auth) : null
+  const pushCmd = url ? `git push "${url}" HEAD:${branch}` : 'git push'
+
+  if (type === 'pull') {
+    const r = gitTry(url ? `git pull "${url}" ${branch}` : 'git pull', repoPath)
+    if (!r.ok) throw new Error(r.out || 'pull failed')
+    // Pulling by URL never advanced origin/<branch>; point it at the fetched tip
+    // (FETCH_HEAD) so a later push isn't seen as being "ahead" of a stale ref.
+    if (url) updateTrackingRef(repoPath, branch, 'FETCH_HEAD')
+    return r.out || 'pulled'
+  }
+
+  let r = gitTry(pushCmd, repoPath)
+  if (r.ok) {
+    // We just pushed HEAD to the remote branch, so the remote tip == HEAD. Sync
+    // the local tracking ref to clear the "ahead" count (gd-273).
+    if (url) updateTrackingRef(repoPath, branch, 'HEAD')
+    return r.out || 'pushed'
   }
-  const r = gitTry(cmd, repoPath)
-  if (!r.ok) throw new Error(r.out || `${type} failed`)
-  return r.out || (type === 'push' ? 'pushed' : 'pulled')
+
+  // Push rejected because the remote is ahead (gd-272): commit succeeded but the
+  // push bounced with non-fast-forward, so the files looked "pushed" while the
+  // UI showed a scary git error. Pull with --rebase to replay our commits on top
+  // of the remote ones, then push again — what the user means by "push my files".
+  if (NON_FAST_FORWARD.test(r.out)) {
+    const pull = gitTry(url ? `git pull --rebase "${url}" ${branch}` : 'git pull --rebase', repoPath)
+    if (!pull.ok) {
+      // Rebase couldn't apply cleanly (conflicts) — abort so the repo isn't left
+      // mid-rebase, and surface an actionable message instead of guessing.
+      gitTry('git rebase --abort', repoPath)
+      throw new Error(`отдалеченият клон е напред и има конфликт при обединяване — дръпни (Sync) и слей ръчно, после пусни пак.\n${pull.out}`)
+    }
+    r = gitTry(pushCmd, repoPath)
+    if (!r.ok) throw new Error(r.out || 'push failed')
+    if (url) updateTrackingRef(repoPath, branch, 'HEAD')
+    return `дръпнах новите промени от сървъра и пушнах наново.\n${r.out}`.trim()
+  }
+
+  throw new Error(r.out || 'push failed')
 }
 
 const AUTH_FAIL = /authentication|authorization|403|401|denied|could not read Username|invalid username or password|terminal prompts disabled/i
@@ -761,6 +812,38 @@ function runAiChat(cfg, cmd, repoPath) {
   })
 }
 
+// deploy — run the project's deploy script (scripts/deploy.sh) in the repo.
+// Long-running (git pull + npm build + service restart), so we spawn it detached
+// from the poll loop and report the result on exit. The agent is its OWN process
+// (not part of any gitdone systemd service), so a `systemctl restart` inside the
+// script doesn't kill the deploy mid-flight — which a server-side spawn would.
+function runDeployCommand(cfg, cmd, repoPath) {
+  const script = 'scripts/deploy.sh'
+  if (!existsSync(join(repoPath, script))) {
+    reportCommandResult(cfg, cmd.id, 'error', `няма ${script} в repo-то — няма какво да деплойна`)
+    log(`✗ deploy @ ${repoPath}: липсва ${script}`)
+    return
+  }
+  log(`▸ deploy стартиран @ ${repoPath}`)
+  const child = spawn('bash', [script], { cwd: repoPath, stdio: ['ignore', 'pipe', 'pipe'] })
+  // Keep only the tail of the output — enough to explain a failure without
+  // shipping a whole build log back.
+  let tail = ''
+  const capture = (d) => { tail = (tail + d.toString()).slice(-2000) }
+  child.stdout.on('data', capture)
+  child.stderr.on('data', capture)
+  child.on('error', (err) => {
+    reportCommandResult(cfg, cmd.id, 'error', `процесна грешка: ${err.message}`)
+    log(`✗ deploy failed @ ${repoPath}: ${err.message}`)
+  })
+  child.on('close', (code) => {
+    const ok = code === 0
+    const detail = tail.trim() ? `\n${tail.trim()}` : ''
+    reportCommandResult(cfg, cmd.id, ok ? 'done' : 'error', `exit ${code}${detail}`.slice(0, 4000))
+    log(`${ok ? '✓' : '✗'} deploy @ ${repoPath} приключи (code ${code})`)
+  })
+}
+
 async function executeCommand(cfg, cmd, repoPath) {
   // ai_run is long-running + streaming — launch it in the background and return
   // so the snapshot loop keeps going. It reports its own result on exit.
@@ -773,6 +856,13 @@ async function executeCommand(cfg, cmd, repoPath) {
     runAiChat(cfg, cmd, repoPath)
     return
   }
+  // deploy — run the repo's deploy script. Long-running (pull + build + service
+  // restart), so it's launched in the background and reports its own result on
+  // exit, same as ai_run.
+  if (cmd.type === 'deploy') {
+    runDeployCommand(cfg, cmd, repoPath)
+    return
+  }
 
   let result = 'ok'
   let status = 'done'
@@ -797,6 +887,14 @@ async function executeCommand(cfg, cmd, repoPath) {
       result = pushOrPull(cmd.type, repoPath, auth)
     } else if (cmd.type === 'discard') {
       result = discardFile(repoPath, cmd.payload?.file)
+    } else {
+      // Unknown command type — almost always a newer server feature (e.g. the
+      // gd-255 `deploy` command) reaching an agent too old to handle it. Do NOT
+      // silently mark it done: an older agent used to fall through here and
+      // report status=done/result=ok, so a queued deploy looked "completed" while
+      // nothing ran. Surface it as an error so the failure is visible and the
+      // user knows to update the agent.
+      throw new Error(`непозната команда „${cmd.type}" — обнови gitdone-agent (npm i -g gitdone-agent@latest)`)
     }
     log(`✓ ${cmd.type} @ ${repoPath}: ${redact(result, auth?.token)}`)
   } catch (err) {
@@ -850,6 +948,99 @@ async function pushSnapshot(cfg, repo) {
   return snapshot
 }
 
+// ─── Low-latency command channel (gd-274) ───────────────────────────────────────
+// The 30s snapshot poll is fine for reflecting git state, but makes user actions
+// (Push/Pull/Commit/АИ) feel sluggish: a queued command waits up to a full tick
+// before the agent even asks for it. So we ALSO hold a persistent SSE connection
+// to the server and drain+run commands the instant it says "wake". The snapshot
+// poll stays as the reliable fallback (and cron heartbeat) if the stream drops.
+
+const GIT_STATE_CMDS = new Set(['commit', 'push', 'pull', 'discard'])
+
+// Pull this machine's pending commands in one shot (no git/snapshot work server-
+// side) and run them. Serialised via a tiny mutex so overlapping wakes don't
+// double-drain; a wake arriving mid-drain sets a flag to run once more after.
+let draining = false
+let drainAgain = false
+async function drainCommands(cfg) {
+  if (draining) { drainAgain = true; return }
+  draining = true
+  try {
+    do {
+      drainAgain = false
+      let data
+      try {
+        data = await api(cfg, '/api/v1/agent/commands', { machineId: cfg.machineId })
+      } catch (err) {
+        log(`✗ command drain failed: ${err.message}`)
+        return
+      }
+      const commands = data.commands ?? []
+      if (commands.length === 0) continue
+
+      // Cache any push tokens the server issued for these commands' repos.
+      if (data.githubAuth && typeof data.githubAuth === 'object') {
+        cfg.auth = cfg.auth ?? {}
+        for (const [path, a] of Object.entries(data.githubAuth)) {
+          if (a && a.token && a.repo) cfg.auth[path] = a
+        }
+        writeConfig(cfg)
+      }
+
+      // Run each command against its own repo path, and remember which repos had
+      // their git state changed so we can push a fresh snapshot right after —
+      // that's what makes the UI update instantly instead of on the next tick.
+      const touched = new Map()
+      for (const cmd of commands) {
+        const repoPath = cmd.path
+        if (!repoPath) { log(`✗ command ${cmd.id} has no path — skipped`); continue }
+        await executeCommand(cfg, cmd, repoPath)
+        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 }) }
+        catch (err) { log(`✗ post-command snapshot failed @ ${path}: ${err.message}`) }
+      }
+    } while (drainAgain)
+  } finally {
+    draining = false
+  }
+}
+
+// Hold a persistent SSE connection open and drain the moment the server pushes a
+// `wake`. Reconnects forever with a short backoff; the server also recycles the
+// connection every few minutes (each reconnect re-sends an initial wake, so
+// anything queued while we were away is picked up). Never throws.
+const STREAM_RECONNECT_MS = 3000
+async function streamCommands(cfg) {
+  const url = `${cfg.url}/api/v1/agent/commands/stream?machineId=${encodeURIComponent(cfg.machineId)}`
+  for (;;) {
+    try {
+      const res = await fetch(url, { headers: { Authorization: `Bearer ${cfg.key}` } })
+      if (!res.ok || !res.body) throw new Error(`HTTP ${res.status}`)
+      log('▶ command stream connected')
+      const reader = res.body.getReader()
+      const decoder = new TextDecoder()
+      let buf = ''
+      for (;;) {
+        const { value, done } = await reader.read()
+        if (done) break
+        buf += decoder.decode(value, { stream: true })
+        // SSE events are separated by a blank line; a `wake` means "drain now".
+        let idx
+        while ((idx = buf.indexOf('\n\n')) >= 0) {
+          const frame = buf.slice(0, idx)
+          buf = buf.slice(idx + 2)
+          if (/(^|\n)event:\s*wake/.test(frame)) drainCommands(cfg)
+        }
+      }
+    } catch (err) {
+      log(`… command stream disconnected (${err.message}); reconnecting`)
+    }
+    await new Promise((r) => setTimeout(r, STREAM_RECONNECT_MS))
+  }
+}
+
 // ─── Main ────────────────────────────────────────────────────────────────────
 
 async function runLoop(cfg) {
@@ -871,6 +1062,10 @@ async function runLoop(cfg) {
     }
   }
 
+  // Fast command path runs alongside the snapshot poll. Fire-and-forget: it owns
+  // its own reconnect loop and never rejects.
+  streamCommands(cfg)
+
   await tick()
   setInterval(tick, cfg.interval * 1000)
 }

package/package.json

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