gitdone-agent 0.5.6 → 0.6.2

package/index.js

@@ -12,10 +12,10 @@
 import { execSync, spawn } from 'node:child_process'
 import {
   existsSync, writeFileSync, readFileSync, unlinkSync,
-  mkdirSync, copyFileSync, appendFileSync, readdirSync,
+  mkdirSync, copyFileSync, appendFileSync, readdirSync, rmSync,
 } from 'node:fs'
 import { resolve, join } from 'node:path'
-import { homedir, hostname } from 'node:os'
+import { homedir, hostname, tmpdir } from 'node:os'
 import { randomUUID } from 'node:crypto'
 
 // ─── Stable agent dir, config + logging ────────────────────────────────────────
@@ -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.6'
+const AGENT_VERSION = '0.6.2'
 
 const AGENT_DIR = join(homedir(), '.gitdone-agent')
 const CONFIG_PATH = join(AGENT_DIR, 'config.json')
@@ -239,6 +239,18 @@ function git(cmd, cwd) {
   }
 }
 
+// Like git(), but returns the RAW bytes instead of a UTF-8 string. Needed for
+// `git diff`, whose payload can be Windows-1251 (CP1251) Cyrillic — decoding
+// those bytes as UTF-8 up front would corrupt them to „�"/„?" irreversibly
+// (gd-276). Callers decode per-file via decodeDiffText().
+function gitRaw(cmd, cwd) {
+  try {
+    return execSync(cmd, { cwd, encoding: 'buffer', stdio: ['pipe', 'pipe', 'pipe'] })
+  } catch {
+    return Buffer.alloc(0)
+  }
+}
+
 // Like git(), but surfaces failures (with stderr) instead of swallowing them —
 // used for push/pull where we need to detect auth rejection.
 function gitTry(cmd, cwd) {
@@ -264,20 +276,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'
+  }
+
+  // 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()
   }
-  const r = gitTry(cmd, repoPath)
-  if (!r.ok) throw new Error(r.out || `${type} failed`)
-  return r.out || (type === 'push' ? 'pushed' : 'pulled')
+
+  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
@@ -303,14 +366,57 @@ function discardFile(repoPath, file) {
   return 'discarded (new file removed)'
 }
 
-function parseDiffByFile(diffOutput) {
+// ─── Windows-1251 (CP1251) aware diff decoding (gd-276) ───────────────────────
+// Legacy Cyrillic sources are often saved in CP1251. Their high bytes (0x80–0xFF,
+// single-byte) are invalid UTF-8, so reading the diff as UTF-8 shows „?"/„�"
+// instead of кирилица. We keep the raw bytes and decode each file's diff section
+// on its own: valid UTF-8 stays UTF-8; the rest goes through the CP1251 table
+// below — so a UTF-8 repo is untouched while CP1251 files finally read correctly.
+
+// CP1251 high range 0x80–0xFF → Unicode code points (0x00–0x7F is plain ASCII).
+// 0x98 is unassigned in CP1251 → U+FFFD.
+const CP1251_HIGH = [
+  0x0402, 0x0403, 0x201A, 0x0453, 0x201E, 0x2026, 0x2020, 0x2021, 0x20AC, 0x2030, 0x0409, 0x2039, 0x040A, 0x040C, 0x040B, 0x040F,
+  0x0452, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014, 0xFFFD, 0x2122, 0x0459, 0x203A, 0x045A, 0x045C, 0x045B, 0x045F,
+  0x00A0, 0x040E, 0x045E, 0x0408, 0x00A4, 0x0490, 0x00A6, 0x00A7, 0x0401, 0x00A9, 0x0404, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x0407,
+  0x00B0, 0x00B1, 0x0406, 0x0456, 0x0491, 0x00B5, 0x00B6, 0x00B7, 0x0451, 0x2116, 0x0454, 0x00BB, 0x0458, 0x0405, 0x0455, 0x0457,
+  0x0410, 0x0411, 0x0412, 0x0413, 0x0414, 0x0415, 0x0416, 0x0417, 0x0418, 0x0419, 0x041A, 0x041B, 0x041C, 0x041D, 0x041E, 0x041F,
+  0x0420, 0x0421, 0x0422, 0x0423, 0x0424, 0x0425, 0x0426, 0x0427, 0x0428, 0x0429, 0x042A, 0x042B, 0x042C, 0x042D, 0x042E, 0x042F,
+  0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0436, 0x0437, 0x0438, 0x0439, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E, 0x043F,
+  0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447, 0x0448, 0x0449, 0x044A, 0x044B, 0x044C, 0x044D, 0x044E, 0x044F,
+]
+
+function decodeCp1251(buf) {
+  let out = ''
+  for (const b of buf) out += String.fromCharCode(b < 0x80 ? b : CP1251_HIGH[b - 0x80])
+  return out
+}
+
+// A strict UTF-8 decoder (always available even on small-ICU builds) — throws on
+// any invalid sequence, which is exactly how we tell UTF-8 apart from CP1251.
+const UTF8_STRICT = new TextDecoder('utf-8', { fatal: true })
+function decodeDiffText(buf) {
+  try {
+    return UTF8_STRICT.decode(buf)
+  } catch {
+    return decodeCp1251(buf)
+  }
+}
+
+function parseDiffByFile(diffBuf) {
   const files = {}
-  if (!diffOutput) return files
-  const sections = diffOutput.split(/(?=^diff --git )/m)
+  if (!diffBuf || diffBuf.length === 0) return files
+  // Latin1 is a lossless 1-byte⇢1-char mapping, so the ASCII "diff --git" split
+  // markers match while every original byte survives for the per-section decode.
+  const raw = Buffer.isBuffer(diffBuf) ? diffBuf.toString('latin1') : String(diffBuf)
+  const sections = raw.split(/(?=^diff --git )/m)
   for (const section of sections) {
     if (!section.trim()) continue
-    const match = section.match(/^diff --git a\/.+ b\/(.+)$/m)
-    if (match) files[match[1]] = section
+    // Decode THIS file's bytes on their own (UTF-8 or CP1251), then read the
+    // filename from the decoded header.
+    const text = decodeDiffText(Buffer.from(section, 'latin1'))
+    const match = text.match(/^diff --git a\/.+ b\/(.+)$/m)
+    if (match) files[match[1]] = text
   }
   return files
 }
@@ -340,7 +446,7 @@ function getSnapshot(repoPath) {
     lastCommit = { sha, message, author, date }
   }
 
-  const diffs = parseDiffByFile(git('git diff HEAD', repoPath))
+  const diffs = parseDiffByFile(gitRaw('git diff HEAD', repoPath))
 
   // Origin remote → lets the server auto-detect the GitHub repo for the History tab.
   const remoteUrl = git('git config --get remote.origin.url', repoPath) || null
@@ -660,15 +766,42 @@ function runAiCommand(cfg, cmd, repoPath) {
   })
 }
 
+// Download the images attached to a chat turn to a per-session temp dir and
+// return their local paths. `claude -p` can't take image URLs on stdin, so we
+// fetch them locally and point Claude at the files (its Read tool renders
+// images). Best-effort: a failed download is skipped, not fatal.
+async function downloadSessionImages(sessionId, urls) {
+  const dir = join(tmpdir(), `gitdone-ai-${sessionId}`)
+  mkdirSync(dir, { recursive: true })
+  const paths = []
+  for (let i = 0; i < urls.length; i++) {
+    try {
+      const res = await fetch(urls[i])
+      if (!res.ok) { log(`✗ image download HTTP ${res.status}: ${urls[i]}`); continue }
+      const buf = Buffer.from(await res.arrayBuffer())
+      const m = /\.(png|jpe?g|gif|webp|bmp)(?:\?|$)/i.exec(urls[i])
+      const ext = m ? m[1].toLowerCase() : 'png'
+      const file = join(dir, `image-${i + 1}.${ext}`)
+      writeFileSync(file, buf)
+      paths.push(file)
+    } catch (e) {
+      log(`✗ image download failed (${urls[i]}): ${e.message}`)
+    }
+  }
+  return { dir, paths }
+}
+
 // Run one turn of an interactive chat session: `claude -p` (resuming the prior
 // Claude session when known) with the user's message on stdin, streaming the
 // reply back to the session console. Long-running + fire-and-forget like ai_run.
-function runAiChat(cfg, cmd, repoPath) {
+async function runAiChat(cfg, cmd, repoPath) {
   const sessionId = cmd.payload?.sessionId
   const prompt = cmd.payload?.prompt ?? ''
+  const images = Array.isArray(cmd.payload?.images) ? cmd.payload.images.filter((u) => typeof u === 'string' && u) : []
   const claudeSessionId = cmd.payload?.claudeSessionId || null
   const allowCommit = cmd.payload?.allowCommit === true
-  if (!sessionId || !prompt) {
+  // A turn may be text-only, image-only, or both — but needs at least one.
+  if (!sessionId || (!prompt && images.length === 0)) {
     reportCommandResult(cfg, cmd.id, 'error', 'invalid ai_chat payload')
     return
   }
@@ -715,13 +848,28 @@ function runAiChat(cfg, cmd, repoPath) {
   const onInit = (sid) => { if (sid && !claudeSessionId) capturedSession = sid }
   const timer = setInterval(flush, 800)
 
-  log(`▶ ai_chat ${sessionId} @ ${repoPath} (resume=${claudeSessionId ? 'yes' : 'no'}) via ${claudePath}`)
+  // Fetch any attached images locally and fold their paths into the prompt so
+  // Claude reads them with its Read tool (URLs on stdin don't render).
+  let imgDir = null
+  let fullPrompt = prompt
+  if (images.length > 0) {
+    const dl = await downloadSessionImages(sessionId, images)
+    imgDir = dl.dir
+    if (dl.paths.length > 0) {
+      const list = dl.paths.map((p) => `- ${p}`).join('\n')
+      const note = `Потребителят прикачи ${dl.paths.length} изображени${dl.paths.length === 1 ? 'е' : 'я'}. Прегледай ги с Read tool от следните локални пътища:\n${list}`
+      fullPrompt = prompt ? `${prompt}\n\n[${note}]` : `[${note}]`
+    }
+  }
+
+  log(`▶ ai_chat ${sessionId} @ ${repoPath} (resume=${claudeSessionId ? 'yes' : 'no'}, images=${images.length}) via ${claudePath}`)
 
   let child
   try {
     child = spawn(claudePath, args, { cwd: repoPath, shell, windowsHide: true, env: childEnv })
   } catch (err) {
     clearInterval(timer)
+    if (imgDir) { try { rmSync(imgDir, { recursive: true, force: true }) } catch { /* best-effort */ } }
     postSessionEvents(cfg, sessionId, [{ role: 'SYSTEM', text: `Грешка при стартиране: ${err.message}` }], 'error')
     reportCommandResult(cfg, cmd.id, 'error', err.message)
     return
@@ -729,7 +877,7 @@ function runAiChat(cfg, cmd, repoPath) {
 
   if (child.stdin) {
     child.stdin.on('error', () => {})
-    try { child.stdin.write(prompt); child.stdin.end() }
+    try { child.stdin.write(fullPrompt); child.stdin.end() }
     catch (e) { push('SYSTEM', `stdin write failed: ${e.message}`) }
   }
 
@@ -747,6 +895,7 @@ function runAiChat(cfg, cmd, repoPath) {
   child.on('error', (err) => push('SYSTEM', `Процесна грешка: ${err.message}`))
   child.on('close', async (code) => {
     clearInterval(timer)
+    if (imgDir) { try { rmSync(imgDir, { recursive: true, force: true }) } catch { /* best-effort */ } }
     if (buf.trim()) parseStreamLine(buf.trim(), push, onInit)
     await flush()
     const ok = code === 0
@@ -897,6 +1046,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) {
@@ -918,6 +1160,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.6",
+    "version":  "0.6.2",
     "description":  "Local git agent for gitdone — watches a local repo and sends snapshots to gitdone.eu",
     "type":  "module",
     "bin":  {