gitdone-agent 0.6.11 → 0.6.13

package/index.js

@@ -9,10 +9,10 @@
 // roots anytime with --root (repeatable). The running agent reads its config
 // from ~/.gitdone-agent/config.json, so the autostart entry needs no args.
 
-import { execSync, spawn } from 'node:child_process'
+import { execSync, execFileSync, spawn } from 'node:child_process'
 import {
   existsSync, writeFileSync, readFileSync, unlinkSync,
-  mkdirSync, copyFileSync, appendFileSync, readdirSync, rmSync,
+  mkdirSync, copyFileSync, appendFileSync, readdirSync, rmSync, statSync,
 } from 'node:fs'
 import { resolve, join } from 'node:path'
 import { homedir, hostname, tmpdir } from 'node:os'
@@ -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.11'
+const AGENT_VERSION = '0.6.13'
 
 const AGENT_DIR = join(homedir(), '.gitdone-agent')
 const CONFIG_PATH = join(AGENT_DIR, 'config.json')
@@ -237,6 +237,22 @@ function runDoctor() {
 // return '' (an EMPTY snapshot, worse than the collapsed view). 64 MB is plenty.
 const GIT_MAX_BUFFER = 64 * 1024 * 1024
 
+// Cap for synthesising an untracked file's full-content diff (gd-370) — above
+// this the file keeps the "no diff" placeholder so a huge/binary blob can't
+// 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
+
 function git(cmd, cwd) {
   try {
     return execSync(cmd, { cwd, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'], maxBuffer: GIT_MAX_BUFFER }).trim()
@@ -257,6 +273,22 @@ function gitRaw(cmd, cwd) {
   }
 }
 
+// Full-content diff of a single UNTRACKED file (against /dev/null), so the
+// console can show a new file's whole content as an all-added diff — like
+// GitHub Desktop (gd-370). Uses execFileSync (argv, no shell) so paths with
+// spaces / Cyrillic reach git intact, unlike a shell command string. `--no-index`
+// exits 1 when the file differs from empty (i.e. always) — that's expected, and
+// its stdout still holds the diff. Returns raw bytes for parseDiffByFile.
+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,
+    })
+  } catch (err) {
+    return err && err.stdout && err.stdout.length ? err.stdout : 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) {
@@ -494,6 +526,30 @@ function getSnapshot(repoPath) {
 
   const diffs = parseDiffByFile(gitRaw('git diff HEAD', repoPath))
 
+  // Untracked files (`??`) aren't in `git diff HEAD`, so they had no content to
+  // show ("Нов или untracked файл — няма diff"). Synthesise an all-added diff for
+  // 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.
+  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
+  }
+
   // 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
 

package/package.json

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