gitdone-agent 0.8.7 → 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.7'
+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 } : {}),
   }
 }
 
@@ -657,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}`)
+        }
+      }
+    }
   }
 }
 
@@ -1068,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
@@ -3041,6 +3152,7 @@ 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 {
@@ -3049,6 +3161,7 @@ async function runLoop(cfg) {
       // 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
@@ -3056,7 +3169,10 @@ async function runLoop(cfg) {
         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}`)
     }
@@ -3073,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)
@@ -3084,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)')
@@ -3100,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.7",
-    "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"
             },