gitdone-agent 0.6.12 → 0.6.14

package/index.js

@@ -11,7 +11,7 @@
 
 import { execSync, execFileSync, spawn } from 'node:child_process'
 import {
-  existsSync, writeFileSync, readFileSync, unlinkSync,
+  existsSync, writeFileSync, readFileSync, unlinkSync, renameSync,
   mkdirSync, copyFileSync, appendFileSync, readdirSync, rmSync, statSync,
 } from 'node:fs'
 import { resolve, join } from 'node:path'
@@ -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.6.12'
+const AGENT_VERSION = '0.6.14'
 
 const AGENT_DIR = join(homedir(), '.gitdone-agent')
 const CONFIG_PATH = join(AGENT_DIR, 'config.json')
@@ -38,19 +38,60 @@ function ensureAgentDir() {
   if (!existsSync(AGENT_DIR)) mkdirSync(AGENT_DIR, { recursive: true })
 }
 
+// Keep agent.log from growing forever: past 5 MB it rolls to agent.log.old
+// (replacing the previous roll). Checked every 500 lines, not per line.
+const LOG_MAX_BYTES = 5 * 1024 * 1024
+let logLinesSinceCheck = 0
+function rotateLogIfNeeded() {
+  try {
+    if (statSync(LOG_PATH).size > LOG_MAX_BYTES) renameSync(LOG_PATH, LOG_PATH + '.old')
+  } catch { /* no log yet / roll failed — keep appending */ }
+}
+
 function log(msg) {
   const line = `[${new Date().toISOString()}] ${msg}`
   console.log(line)
-  try { ensureAgentDir(); appendFileSync(LOG_PATH, line + '\n') } catch { /* best-effort */ }
+  try {
+    ensureAgentDir()
+    if (logLinesSinceCheck++ % 500 === 0) rotateLogIfNeeded()
+    appendFileSync(LOG_PATH, line + '\n')
+  } catch { /* best-effort */ }
 }
 
+// ─── Crash safety ─────────────────────────────────────────────────────────────
+// Node ≥15 KILLS the process on any unhandled promise rejection, and an uncaught
+// exception always did — and the autostart used to be one-shot, so a single
+// stray error left the machine offline until the next Windows login (gd-403).
+// Log and keep running instead; the loops here are stateless enough that
+// surviving is strictly better than dying. If errors come in a storm (>20/min —
+// something is genuinely broken), exit(1) and let the supervisor loop restart
+// us with a clean slate.
+let crashBurst = { count: 0, since: Date.now() }
+function survive(kind, err) {
+  const now = Date.now()
+  if (now - crashBurst.since > 60_000) crashBurst = { count: 0, since: now }
+  crashBurst.count++
+  log(`✗ ${kind}: ${err?.stack || err?.message || err}`)
+  if (crashBurst.count > 20) {
+    log('✗ over 20 crashes in 60s — exiting so the supervisor restarts us clean')
+    process.exit(1)
+  }
+}
+process.on('uncaughtException', (err) => survive('uncaught exception', err))
+process.on('unhandledRejection', (err) => survive('unhandled rejection', err))
+
 function readConfig() {
   try { return JSON.parse(readFileSync(CONFIG_PATH, 'utf8')) } catch { return null }
 }
 
 function writeConfig(cfg) {
   ensureAgentDir()
-  writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2), 'utf8')
+  // Write-then-rename so a crash / reboot mid-write can never leave a truncated
+  // config.json — a corrupt config makes every subsequent autostart exit
+  // immediately, which reads as "агентът умря и рестартът не помага" (gd-403).
+  const tmp = CONFIG_PATH + '.tmp'
+  writeFileSync(tmp, JSON.stringify(cfg, null, 2), 'utf8')
+  renameSync(tmp, CONFIG_PATH)
 }
 
 // ─── Arg parsing ─────────────────────────────────────────────────────────────
@@ -150,8 +191,14 @@ function findClaude() {
 // (~/.gitdone-agent), excluding ourselves — the npx installer runs from the
 // npx cache, so it won't match. Best-effort; failures are non-fatal.
 function stopRunningAgents() {
+  // Kill the supervisor loops (cmd.exe running run-agent.cmd) FIRST, then the
+  // agents — the other order lets a still-alive supervisor immediately respawn
+  // the agent we just killed, leaving two agents reporting after an update.
   const ps = [
     "$ErrorActionPreference='SilentlyContinue'",
+    "Get-CimInstance Win32_Process -Filter \"Name='cmd.exe'\" |",
+    "  Where-Object { $_.CommandLine -like '*run-agent.cmd*' } |",
+    '  ForEach-Object { Stop-Process -Id $_.ProcessId -Force }',
     "Get-CimInstance Win32_Process -Filter \"Name='node.exe'\" |",
     `  Where-Object { $_.CommandLine -like '*.gitdone-agent*' -and $_.ProcessId -ne ${process.pid} } |`,
     '  ForEach-Object { Stop-Process -Id $_.ProcessId -Force }',
@@ -182,11 +229,32 @@ function installStartup() {
   }
   const agentPath = existsSync(STABLE_AGENT) ? STABLE_AGENT : resolve(process.argv[1])
 
-  // The running agent reads everything from config.json — no args needed.
-  // VBScript runs it silently so no console window pops up on login.
+  // The autostart used to launch the agent DIRECTLY — one crash and the machine
+  // stayed offline until the next Windows login (gd-403). Now the VBS launches a
+  // tiny supervisor loop instead: run the agent, and if it ever exits, note it
+  // in agent-crash.log and start it again after 10s. stderr is captured too, so
+  // node-level failures (corrupt file, bad path) finally leave a trace. If the
+  // node path recorded at install time vanished (node upgraded/moved), fall
+  // back to whatever `node` is on PATH.
+  const crashLog = join(AGENT_DIR, 'agent-crash.log')
+  const cmd = [
+    '@echo off',
+    'rem gitdone-agent supervisor — restarts the agent if it ever dies (gd-403)',
+    `set "NODE=${nodePath}"`,
+    'if not exist "%NODE%" set "NODE=node"',
+    ':loop',
+    `"%NODE%" "${agentPath}" 2>> "${crashLog}"`,
+    `echo [%date% %time%] agent exited (code %errorlevel%) - restart in 10s >> "${crashLog}"`,
+    'ping -n 11 127.0.0.1 >nul',
+    'goto loop',
+  ].join('\r\n')
+  const cmdPath = join(AGENT_DIR, 'run-agent.cmd')
+  writeFileSync(cmdPath, cmd, 'utf8')
+
+  // VBScript runs the supervisor with window style 0 so nothing pops up on login.
   const vbs = [
     'Set WshShell = CreateObject("WScript.Shell")',
-    `WshShell.Run """${nodePath}"" ""${agentPath}""", 0, False`,
+    `WshShell.Run """${cmdPath}""", 0, False`,
   ].join('\r\n')
 
   writeFileSync(getVbsPath(), vbs, 'utf8')
@@ -200,6 +268,11 @@ function uninstallStartup() {
   } else {
     console.log(`Не е намерен автостарт (${vbsPath})`)
   }
+  const cmdPath = join(AGENT_DIR, 'run-agent.cmd')
+  if (existsSync(cmdPath)) unlinkSync(cmdPath)
+  // Also stop the live supervisor + agent — otherwise they keep running (and
+  // the supervisor keeps resurrecting the agent) until the next reboot.
+  stopRunningAgents()
 }
 
 // ─── Doctor ────────────────────────────────────────────────────────────────────
@@ -211,8 +284,10 @@ function runDoctor() {
   console.log(`  agent dir     : ${AGENT_DIR} ${existsSync(AGENT_DIR) ? '(ok)' : '(MISSING)'}`)
   console.log(`  stable agent  : ${STABLE_AGENT} ${existsSync(STABLE_AGENT) ? '(ok)' : '(not installed)'}`)
   console.log(`  autostart vbs : ${getVbsPath()} ${existsSync(getVbsPath()) ? '(ok)' : '(not installed)'}`)
+  console.log(`  supervisor    : ${join(AGENT_DIR, 'run-agent.cmd')} ${existsSync(join(AGENT_DIR, 'run-agent.cmd')) ? '(ok)' : '(not installed — пусни --install за авторестарт при crash)'}`)
   console.log(`  config        : ${CONFIG_PATH} ${existsSync(CONFIG_PATH) ? '(ok)' : '(MISSING)'}`)
   console.log(`  log file      : ${LOG_PATH} ${existsSync(LOG_PATH) ? '(ok)' : '(none yet)'}`)
+  console.log(`  crash log     : ${join(AGENT_DIR, 'agent-crash.log')} ${existsSync(join(AGENT_DIR, 'agent-crash.log')) ? '(има записи — виж го при проблеми)' : '(празен — няма крашове)'}`)
   const claude = findClaude()
   console.log(`  claude cli    : ${claude.found ? claude.path : 'NOT FOUND — инсталирай от claude.ai/code и рестартирай агента'}`)
   if (cfg) {
@@ -242,9 +317,31 @@ const GIT_MAX_BUFFER = 64 * 1024 * 1024
 // bloat the snapshot payload.
 const UNTRACKED_DIFF_MAX_BYTES = 1024 * 1024
 
+// Synthesising a per-file diff spawns a synchronous `git diff --no-index` per
+// untracked file. Individually cheap, but a repo with a huge untracked/scratch
+// tree (e.g. extracted game assets — thousands of files) would spawn thousands
+// of blocking git processes and freeze the single-threaded agent for MINUTES on
+// every snapshot, starving the 30s sync heartbeat so the machine flips offline.
+// Bound the synthesis two ways — a file-count cap and a wall-clock budget — so
+// no single repo can ever monopolise the event loop. Anything past either keeps
+// the "no diff" placeholder, identical to the size-cap path above.
+const UNTRACKED_DIFF_MAX_FILES = 200
+const UNTRACKED_DIFF_TIME_BUDGET_MS = 3000
+
+// Every git call here is execSync — synchronous, on the ONLY thread. A git that
+// stops to ask for credentials (a repo whose remote lost its token → Git
+// Credential Manager pops an invisible dialog) blocks the whole agent forever:
+// no ticks, no heartbeat, machine flips offline until someone restarts it
+// (gd-403). Two guards: never allow interactive prompts, and hard-timeout every
+// call so the worst case is one failed command, not a dead agent. Local
+// commands get 2 min; push/pull (network) get 5.
+const GIT_ENV = { ...process.env, GIT_TERMINAL_PROMPT: '0', GCM_INTERACTIVE: 'never' }
+const GIT_TIMEOUT_MS = 2 * 60 * 1000
+const GIT_NET_TIMEOUT_MS = 5 * 60 * 1000
+
 function git(cmd, cwd) {
   try {
-    return execSync(cmd, { cwd, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'], maxBuffer: GIT_MAX_BUFFER }).trim()
+    return execSync(cmd, { cwd, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'], maxBuffer: GIT_MAX_BUFFER, timeout: GIT_TIMEOUT_MS, env: GIT_ENV }).trim()
   } catch {
     return ''
   }
@@ -256,7 +353,7 @@ function git(cmd, cwd) {
 // (gd-276). Callers decode per-file via decodeDiffText().
 function gitRaw(cmd, cwd) {
   try {
-    return execSync(cmd, { cwd, encoding: 'buffer', stdio: ['pipe', 'pipe', 'pipe'], maxBuffer: GIT_MAX_BUFFER })
+    return execSync(cmd, { cwd, encoding: 'buffer', stdio: ['pipe', 'pipe', 'pipe'], maxBuffer: GIT_MAX_BUFFER, timeout: GIT_TIMEOUT_MS, env: GIT_ENV })
   } catch {
     return Buffer.alloc(0)
   }
@@ -271,7 +368,7 @@ function gitRaw(cmd, cwd) {
 function gitDiffUntracked(file, cwd) {
   try {
     return execFileSync('git', ['diff', '--no-index', '--', '/dev/null', file], {
-      cwd, encoding: 'buffer', stdio: ['pipe', 'pipe', 'pipe'], maxBuffer: GIT_MAX_BUFFER,
+      cwd, encoding: 'buffer', stdio: ['pipe', 'pipe', 'pipe'], maxBuffer: GIT_MAX_BUFFER, timeout: GIT_TIMEOUT_MS, env: GIT_ENV,
     })
   } catch (err) {
     return err && err.stdout && err.stdout.length ? err.stdout : Buffer.alloc(0)
@@ -282,10 +379,11 @@ function gitDiffUntracked(file, cwd) {
 // used for push/pull where we need to detect auth rejection.
 function gitTry(cmd, cwd) {
   try {
-    const out = execSync(cmd, { cwd, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim()
+    const out = execSync(cmd, { cwd, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'], timeout: GIT_NET_TIMEOUT_MS, env: GIT_ENV }).trim()
     return { ok: true, out }
   } catch (err) {
-    const out = (err.stderr || err.stdout || err.message || '').toString().trim()
+    const timedOut = err.signal === 'SIGTERM' && err.code == null
+    const out = (err.stderr || err.stdout || (timedOut ? `git не отговори ${GIT_NET_TIMEOUT_MS / 60000} мин и беше прекратен` : err.message) || '').toString().trim()
     return { ok: false, out }
   }
 }
@@ -520,12 +618,20 @@ function getSnapshot(repoPath) {
   // each from /dev/null so the console shows the whole new file — like GitHub
   // Desktop (gd-370). Skip anything over the size cap so a stray big/binary blob
   // can't bloat the snapshot; those keep the "no diff" placeholder.
-  for (const [file, xy] of Object.entries(statuses)) {
-    if (xy !== '??' || diffs[file]) continue
-    try {
-      const st = statSync(join(repoPath, file))
-      if (!st.isFile() || st.size > UNTRACKED_DIFF_MAX_BYTES) continue
-    } catch { continue }
+  const untracked = Object.keys(statuses).filter((f) => statuses[f] === '??' && !diffs[f])
+  const diffDeadline = Date.now() + UNTRACKED_DIFF_TIME_BUDGET_MS
+  let synthesised = 0
+  for (const file of untracked) {
+    // Stop before either bound so a scratch tree can't starve the heartbeat; the
+    // rest keep the "no diff" placeholder. Log once so it's visible why.
+    if (synthesised >= UNTRACKED_DIFF_MAX_FILES || Date.now() > diffDeadline) {
+      log(`⚠ untracked diff cap reached @ ${repoPath} (${synthesised}/${untracked.length} synthesised) — rest shown without preview`)
+      break
+    }
+    let st
+    try { st = statSync(join(repoPath, file)) } catch { continue }
+    if (!st.isFile() || st.size > UNTRACKED_DIFF_MAX_BYTES) continue
+    synthesised++
     const parsed = parseDiffByFile(gitDiffUntracked(file, repoPath))
     const val = parsed[file] ?? Object.values(parsed)[0]
     if (val) diffs[file] = val

package/package.json

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