gitdone-agent 0.8.6 → 0.8.8

package/index.js

@@ -4,6 +4,8 @@
 //
 // Setup (once):
 //   npx gitdone-agent --key=gdo_xxx --root=C:\path\to\projects --install
+// Optional WoW progress sync:
+//   npx gitdone-agent --wow="C:\Program Files (x86)\World of Warcraft\_retail_" --install
 //
 // Then pick which discovered repos to track from gitdone.eu/github. Add more
 // roots anytime with --root (repeatable). The running agent reads its config
@@ -29,7 +31,7 @@ import { randomUUID, createHash } 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. The server's offline
 // fallback is bumped only after this release has actually reached npm.
-const AGENT_VERSION = '0.8.6'
+const AGENT_VERSION = '0.8.8'
 
 const AGENT_DIR = join(homedir(), '.gitdone-agent')
 const CONFIG_PATH = join(AGENT_DIR, 'config.json')
@@ -182,21 +184,25 @@ function parseArgs() {
   const argv = process.argv.slice(2)
   const flags = {}
   const roots = []
+  const wowRoots = []
   for (const a of argv) {
     if (!a.startsWith('--')) continue
     const [k, ...rest] = a.slice(2).split('=')
     const v = rest.join('=')
     if (k === 'root') { if (v) roots.push(resolve(v)) }
+    else if (k === 'wow') { if (v) wowRoots.push(resolve(v)) }
     else flags[k] = v
   }
   return {
     key: flags.key,
     roots,
+    wowRoots,
     interval: flags.interval ? Number(flags.interval) : undefined,
     url: flags.url ? flags.url.replace(/\/$/, '') : undefined,
     install: 'install' in flags,
     uninstall: 'uninstall' in flags,
     doctor: 'doctor' in flags,
+    testWow: flags['test-wow'] ? resolve(flags['test-wow']) : undefined,
   }
 }
 
@@ -204,6 +210,7 @@ function parseArgs() {
 function buildConfig(args) {
   const existing = readConfig() ?? {}
   const mergedRoots = Array.from(new Set([...(existing.roots ?? []), ...args.roots]))
+  const mergedWowRoots = Array.from(new Set([...(existing.wowRoots ?? []), ...args.wowRoots]))
   return {
     key: args.key ?? existing.key,
     url: args.url ?? existing.url ?? 'https://gitdone.eu',
@@ -211,6 +218,8 @@ function buildConfig(args) {
     machineId: existing.machineId ?? randomUUID(),
     hostname: existing.hostname ?? hostname(),
     roots: mergedRoots,
+    wowRoots: mergedWowRoots,
+    ...(existing.auth ? { auth: existing.auth } : {}),
   }
 }
 
@@ -547,6 +556,77 @@ function uninstallStartup() {
 
 // ─── Doctor ────────────────────────────────────────────────────────────────────
 
+// Each sync heartbeat returns the version, URL and SHA-256 of the exact agent
+// script deployed on the server. A supervised stable install downloads it,
+// verifies both checksum and embedded version, atomically replaces itself, and
+// exits; run-agent.cmd then starts the new version within about ten seconds.
+function compareVersions(a, b) {
+  const pa = String(a).split('.').map((n) => parseInt(n, 10) || 0)
+  const pb = String(b).split('.').map((n) => parseInt(n, 10) || 0)
+  const len = Math.max(pa.length, pb.length)
+  for (let i = 0; i < len; i++) {
+    const difference = (pa[i] ?? 0) - (pb[i] ?? 0)
+    if (difference !== 0) return difference > 0 ? 1 : -1
+  }
+  return 0
+}
+
+const UPDATE_RETRY_MS = 60 * 60 * 1000
+let updateInFlight = false
+let lastUpdateAttempt = { version: null, at: 0 }
+
+async function selfUpdate(cfg, latestVersion, downloadUrl, expectedSha256) {
+  if (updateInFlight || !latestVersion || !downloadUrl) return
+  if (compareVersions(latestVersion, AGENT_VERSION) <= 0) return
+  if (lastUpdateAttempt.version === latestVersion && Date.now() - lastUpdateAttempt.at < UPDATE_RETRY_MS) return
+
+  // A foreground/dev invocation has no supervisor to bring it back after the
+  // swap. Announce the update there, but only self-replace a stable install.
+  const runningStable = resolve(process.argv[1] || '') === STABLE_AGENT
+  const supervised = existsSync(join(AGENT_DIR, 'run-agent.cmd'))
+  if (!runningStable || !supervised) {
+    log(`↑ налична е нова версия ${latestVersion} (текуща ${AGENT_VERSION}) — пусни „gitdone-agent --install“ еднократно, за да включиш автообновяването`)
+    lastUpdateAttempt = { version: latestVersion, at: Date.now() }
+    return
+  }
+
+  updateInFlight = true
+  lastUpdateAttempt = { version: latestVersion, at: Date.now() }
+  const url = downloadUrl.startsWith('http') ? downloadUrl : `${cfg.url}${downloadUrl}`
+  const tmp = STABLE_AGENT + '.next'
+  log(`↑ автообновяване ${AGENT_VERSION} → ${latestVersion}`)
+  try {
+    if (!/^[a-f0-9]{64}$/i.test(String(expectedSha256 || ''))) {
+      throw new Error('сървърът не върна валиден sha256')
+    }
+    const response = await fetch(url, { headers: { Authorization: `Bearer ${cfg.key}` } })
+    if (!response.ok) throw new Error(`HTTP ${response.status}`)
+    const buffer = Buffer.from(await response.arrayBuffer())
+    if (buffer.length < 1000) throw new Error(`подозрително малък файл (${buffer.length} B)`)
+
+    const actualSha256 = createHash('sha256').update(buffer).digest('hex')
+    if (actualSha256.toLowerCase() !== String(expectedSha256).toLowerCase()) {
+      throw new Error(`sha256 несъвпадение (очаквано ${expectedSha256}, получено ${actualSha256})`)
+    }
+    const embeddedVersion = buffer
+      .subarray(0, 12_000)
+      .toString('utf8')
+      .match(/const AGENT_VERSION\s*=\s*['"]([^'"]+)['"]/)?.[1]
+    if (embeddedVersion !== latestVersion) {
+      throw new Error(`файлът е v${embeddedVersion || '?'}, а сървърът обяви v${latestVersion}`)
+    }
+
+    writeFileSync(tmp, buffer)
+    renameSync(tmp, STABLE_AGENT)
+    log(`✓ обновено до ${latestVersion} — supervisor-ът ще рестартира агента`)
+    process.exit(0)
+  } catch (err) {
+    updateInFlight = false
+    try { if (existsSync(tmp)) unlinkSync(tmp) } catch { /* best-effort cleanup */ }
+    log(`✗ автообновяването се провали: ${err?.message || err} — оставам на ${AGENT_VERSION}, ще опитам пак до 1 час`)
+  }
+}
+
 function runDoctor() {
   const cfg = readConfig()
   console.log('gitdone-agent doctor')
@@ -586,6 +666,20 @@ function runDoctor() {
       console.log(`  found repos   : ${found.length}`)
       for (const r of found) console.log(`     - ${r.name}  (${r.path})`)
     }
+    console.log(`  WoW roots     : ${cfg.wowRoots?.length ? '' : '(not configured)'}`)
+    for (const root of cfg.wowRoots ?? []) console.log(`     - ${root} ${existsSync(root) ? '' : '(MISSING)'}`)
+    if (cfg.wowRoots?.length) {
+      const files = findWowSavedVariableFiles(cfg.wowRoots)
+      console.log(`  WoW snapshots : ${files.length}`)
+      for (const file of files) {
+        try {
+          const { snapshot } = decodeWowSavedVariables(file)
+          console.log(`     - ${snapshot.character.name}-${snapshot.character.realm} (${file})`)
+        } catch (err) {
+          console.log(`     - INVALID (${file}): ${err.message}`)
+        }
+      }
+    }
   }
 }
 
@@ -997,6 +1091,94 @@ function scanRepos(roots, maxDepth = 5) {
   return found
 }
 
+// ─── World of Warcraft progress bridge ──────────────────────────────────────
+// WoW addons cannot open network connections. GitDoneProgress therefore writes
+// a Base64URL-encoded JSON snapshot to its normal SavedVariables file; this
+// opt-in companion path reads only that explicit file and uploads it with the
+// same API credential the agent already uses. WoW flushes SavedVariables on
+// /reload or logout, so there is no process-memory inspection involved.
+
+function findWowSavedVariableFiles(wowRoots = []) {
+  const files = new Set()
+
+  for (const configuredRoot of wowRoots) {
+    const root = resolve(configuredRoot)
+    if (/GitDoneProgress\.lua$/i.test(root) && existsSync(root)) {
+      files.add(root)
+      continue
+    }
+
+    const normalized = root.replace(/[\\/]+$/, '')
+    const accountRoots = new Set([
+      join(normalized, 'WTF', 'Account'),
+      join(normalized, '_retail_', 'WTF', 'Account'),
+    ])
+    if (/[\\/]WTF$/i.test(normalized)) accountRoots.add(join(normalized, 'Account'))
+    if (/[\\/]Account$/i.test(normalized)) accountRoots.add(normalized)
+
+    for (const accountRoot of accountRoots) {
+      if (!existsSync(accountRoot)) continue
+      let accounts = []
+      try { accounts = readdirSync(accountRoot, { withFileTypes: true }) }
+      catch { continue }
+      for (const account of accounts) {
+        if (!account.isDirectory()) continue
+        const candidate = join(accountRoot, account.name, 'SavedVariables', 'GitDoneProgress.lua')
+        if (existsSync(candidate)) files.add(candidate)
+      }
+    }
+  }
+
+  return [...files].sort()
+}
+
+function decodeWowSavedVariables(path) {
+  const source = readFileSync(path, 'utf8')
+  const match = source.match(/(?:\["payload"\]|payload)\s*=\s*"([A-Za-z0-9_-]+)"/)
+  if (!match) throw new Error('GitDoneProgressDB.payload is missing')
+
+  const json = Buffer.from(match[1], 'base64url').toString('utf8')
+  const snapshot = JSON.parse(json)
+  if (snapshot?.schemaVersion !== 1) {
+    throw new Error(`unsupported snapshot schema ${snapshot?.schemaVersion ?? '?'}`)
+  }
+  if (!snapshot?.character?.guid || !snapshot?.character?.name || !snapshot?.character?.realm) {
+    throw new Error('snapshot character identity is incomplete')
+  }
+  return { snapshot, signature: createHash('sha256').update(match[1]).digest('hex') }
+}
+
+const wowSnapshotSigCache = new Map() // SavedVariables path -> last uploaded payload hash
+
+async function pushWowProgress(cfg) {
+  const files = findWowSavedVariableFiles(cfg.wowRoots)
+  let sent = 0
+  let unchanged = 0
+  let failed = 0
+
+  for (const path of files) {
+    try {
+      const { snapshot, signature } = decodeWowSavedVariables(path)
+      if (wowSnapshotSigCache.get(path) === signature) {
+        unchanged++
+        continue
+      }
+      const result = await api(cfg, '/api/v1/wow/progress', {
+        machineId: cfg.machineId,
+        snapshot,
+      })
+      wowSnapshotSigCache.set(path, signature)
+      sent++
+      log(`✓ WoW progress synced — ${snapshot.character.name}-${snapshot.character.realm}${result.unchanged ? ' (server already current)' : ''}`)
+    } catch (err) {
+      failed++
+      log(`✗ WoW progress sync failed @ ${path}: ${err.message}`)
+    }
+  }
+
+  return { found: files.length, sent, unchanged, failed }
+}
+
 // ─── Server sync + commands ─────────────────────────────────────────────────────
 
 // Keep the deadline below the server-side session stall window. Without a
@@ -2795,7 +2977,12 @@ async function sync(cfg, discovered) {
   })
   if (full) { syncRepoSig = sig; syncFullCountdown = SYNC_FULL_TICKS }
   else syncFullCountdown--
-  return data.tracked ?? []
+  return {
+    tracked: data.tracked ?? [],
+    latestVersion: data.latestVersion,
+    downloadUrl: data.downloadUrl,
+    downloadSha256: data.downloadSha256,
+  }
 }
 
 // Per-repo cache of the last snapshot we actually SENT, so an idle repo whose
@@ -2965,18 +3152,27 @@ async function runLoop(cfg) {
   backupConfig(cfg)
   log(`gitdone-agent started — machine: ${cfg.hostname}, server: ${cfg.url}, interval: ${cfg.interval}s`)
   log(`  roots: ${cfg.roots.join(', ') || '(none — add one with --root)'}`)
+  log(`  WoW: ${cfg.wowRoots?.join(', ') || '(disabled — add retail path with --wow)'}`)
 
   async function tick() {
     try {
       const discovered = scanRepos(cfg.roots)
-      const tracked = await sync(cfg, discovered)
+      const state = await sync(cfg, discovered)
+      // A successful update exits here; the supervisor starts the new stable
+      // script before any more repo work is performed.
+      await selfUpdate(cfg, state.latestVersion, state.downloadUrl, state.downloadSha256)
+      const wow = await pushWowProgress(cfg)
+      const tracked = state.tracked
       let pushed = 0
       let skipped = 0
       for (const repo of tracked) {
         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}, unchanged: ${skipped}`)
+      const wowStatus = cfg.wowRoots?.length
+        ? `, WoW: ${wow.sent} sent/${wow.unchanged} unchanged/${wow.failed} failed`
+        : ''
+      log(`✓ tick — discovered: ${discovered.length}, tracked: ${tracked.length}, pushed: ${pushed}, unchanged: ${skipped}${wowStatus}`)
     } catch (err) {
       log(`✗ sync error: ${err.message}`)
     }
@@ -2993,6 +3189,12 @@ async function runLoop(cfg) {
 async function main() {
   const args = parseArgs()
 
+  if (args.testWow) {
+    const { snapshot, signature } = decodeWowSavedVariables(args.testWow)
+    console.log(JSON.stringify({ signature, snapshot }, null, 2))
+    process.exit(0)
+  }
+
   if (args.doctor) {
     runDoctor()
     process.exit(0)
@@ -3004,7 +3206,7 @@ async function main() {
   }
 
   // Setup / install path: merge CLI args into config, optionally (re)install.
-  if (args.install || args.key || args.roots.length || args.url || args.interval) {
+  if (args.install || args.key || args.roots.length || args.wowRoots.length || args.url || args.interval) {
     const cfg = buildConfig(args)
     if (!cfg.key) {
       console.error('Error: --key is required on first setup (e.g. --key=gdo_xxx)')
@@ -3020,6 +3222,8 @@ async function main() {
       console.log(`  Лог    : ${LOG_PATH}`)
       console.log(`  Roots  :`)
       for (const r of cfg.roots) console.log(`     - ${r}`)
+      console.log(`  WoW    :`)
+      for (const r of cfg.wowRoots ?? []) console.log(`     - ${r}`)
       console.log()
 
       // Launch silently in the background right now.

package/package.json

@@ -1,8 +1,11 @@
 {
     "name":  "gitdone-agent",
-    "version":  "0.8.6",
-    "description":  "Local git agent for gitdone — watches a local repo and sends snapshots to gitdone.eu",
+    "version":  "0.8.8",
+    "description":  "Local gitDone companion for repository and optional World of Warcraft progress sync",
     "type":  "module",
+    "files":  [
+                  "index.js"
+              ],
     "bin":  {
                 "gitdone-agent":  "index.js"
             },