gitdone-agent 0.8.11 → 0.8.12

package/index.js

@@ -6,6 +6,7 @@
 //   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
+// Supported-game activity tracking is automatic on Windows.
 //
 // Then pick which discovered repos to track from gitdone.eu/github. Add more
 // roots anytime with --root (repeatable). The running agent reads its config
@@ -31,7 +32,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.11'
+const AGENT_VERSION = '0.8.12'
 
 const AGENT_DIR = join(homedir(), '.gitdone-agent')
 const CONFIG_PATH = join(AGENT_DIR, 'config.json')
@@ -39,6 +40,7 @@ const CONFIG_PATH = join(AGENT_DIR, 'config.json')
 const CONFIG_BAK_PATH = CONFIG_PATH + '.bak'
 const STABLE_AGENT = join(AGENT_DIR, 'agent.mjs')
 const LOG_PATH = join(AGENT_DIR, 'agent.log')
+const GAME_MONITOR_PATH = join(AGENT_DIR, 'game-monitor.ps1')
 
 function ensureAgentDir() {
   if (!existsSync(AGENT_DIR)) mkdirSync(AGENT_DIR, { recursive: true })
@@ -203,6 +205,7 @@ function parseArgs() {
     uninstall: 'uninstall' in flags,
     doctor: 'doctor' in flags,
     testWow: flags['test-wow'] ? resolve(flags['test-wow']) : undefined,
+    testGames: 'test-games' in flags,
   }
 }
 
@@ -1212,6 +1215,200 @@ async function pushWowProgress(cfg) {
 // deadline, a proxy/network connection that never completes can block the
 // event-posting loop forever, so no heartbeat reaches the server and the
 // watchdog incorrectly declares a live AI turn stalled.
+// Each detector is locked to a verified executable hash and only opens the
+// process with query/read rights. The first profile reuses gd-657's live-tested
+// heartbeat. Future games are added here and to the website catalogue.
+const GAME_PROFILES = [
+  {
+    id: 'ac-black-flag-resynced',
+    processNames: ['ACBlackFlag', 'ACBlackFlag_Plus'],
+    sha256: 'EE40622D0F25126A11BF05DBEEC9C128B9B3A67373BC1FA5692E4C4C2D4665E3',
+    heartbeatRvas: [0x0CCF9590, 0x0CCF9098],
+    pauseDelayMs: 1350,
+  },
+]
+
+const GAME_REPORT_HEARTBEAT_MS = 5_000
+const gameLastReport = new Map()
+let gameReportQueue = Promise.resolve()
+
+function gameMonitorScript() {
+  const profiles = Buffer.from(JSON.stringify(GAME_PROFILES), 'utf8').toString('base64')
+  return String.raw`
+$ErrorActionPreference = 'Stop'
+Add-Type -TypeDefinition @'
+using System;
+using System.Runtime.InteropServices;
+public static class GitDoneGameMemory {
+  [DllImport("kernel32.dll", SetLastError=true)]
+  public static extern IntPtr OpenProcess(uint access, bool inherit, int pid);
+  [DllImport("kernel32.dll", SetLastError=true)]
+  public static extern bool ReadProcessMemory(IntPtr process, IntPtr address, byte[] buffer, int size, out UIntPtr read);
+  [DllImport("kernel32.dll")]
+  public static extern bool CloseHandle(IntPtr handle);
+  public static UInt32 ReadUInt32(IntPtr process, UInt64 address) {
+    var bytes = new byte[4]; UIntPtr read;
+    if (!ReadProcessMemory(process, new IntPtr(unchecked((long)address)), bytes, 4, out read) || read.ToUInt64() != 4)
+      throw new System.ComponentModel.Win32Exception(Marshal.GetLastWin32Error());
+    return BitConverter.ToUInt32(bytes, 0);
+  }
+}
+'@
+$profilesJson = [Text.Encoding]::UTF8.GetString([Convert]::FromBase64String('${profiles}'))
+$profiles = @($profilesJson | ConvertFrom-Json)
+$attached = @{}
+
+function Emit-State($profile, $state, $detail) {
+  [pscustomobject]@{
+    gameId = $profile.id
+    state = $state
+    detail = $detail
+    observedAt = [DateTime]::UtcNow.ToString('o')
+  } | ConvertTo-Json -Compress
+  [Console]::Out.Flush()
+}
+
+while ($true) {
+  foreach ($profile in $profiles) {
+    $process = $null
+    foreach ($processName in @($profile.processNames)) {
+      $process = Get-Process -Name $processName -ErrorAction SilentlyContinue | Select-Object -First 1
+      if ($null -ne $process) { break }
+    }
+
+    $entry = $attached[$profile.id]
+    if ($null -eq $process) {
+      if ($null -ne $entry -and $entry.Handle -ne [IntPtr]::Zero) { [GitDoneGameMemory]::CloseHandle($entry.Handle) | Out-Null }
+      $attached.Remove($profile.id)
+      Emit-State $profile 'not_running' 'process not found'
+      continue
+    }
+
+    try {
+      if ($null -eq $entry -or $entry.Pid -ne $process.Id) {
+        if ($null -ne $entry -and $entry.Handle -ne [IntPtr]::Zero) { [GitDoneGameMemory]::CloseHandle($entry.Handle) | Out-Null }
+        $path = $process.MainModule.FileName
+        $hash = (Get-FileHash -LiteralPath $path -Algorithm SHA256).Hash
+        if ($hash -ne $profile.sha256) {
+          $entry = [pscustomobject]@{ Pid=$process.Id; Handle=[IntPtr]::Zero; Unsupported=$true }
+          $attached[$profile.id] = $entry
+          Emit-State $profile 'unsupported' 'executable hash does not match a verified profile'
+          continue
+        }
+        $handle = [GitDoneGameMemory]::OpenProcess(0x1010, $false, $process.Id)
+        if ($handle -eq [IntPtr]::Zero) { throw 'OpenProcess failed' }
+        $entry = [pscustomobject]@{
+          Pid = $process.Id
+          Handle = $handle
+          Unsupported = $false
+          Base = [UInt64]$process.MainModule.BaseAddress.ToInt64()
+          LastHeartbeat = $null
+          LastChangeAt = [DateTime]::UtcNow
+          ObservedChange = $false
+        }
+        $attached[$profile.id] = $entry
+      }
+      if ($entry.Unsupported) {
+        Emit-State $profile 'unsupported' 'executable hash does not match a verified profile'
+        continue
+      }
+
+      $heartbeat = [UInt64]0
+      $shift = 0
+      foreach ($rva in @($profile.heartbeatRvas)) {
+        $part = [GitDoneGameMemory]::ReadUInt32($entry.Handle, $entry.Base + [UInt64]$rva)
+        $heartbeat = $heartbeat -bxor ([UInt64]$part -shl $shift)
+        $shift = ($shift + 32) % 64
+      }
+      $now = [DateTime]::UtcNow
+      if ($null -eq $entry.LastHeartbeat) {
+        $entry.LastHeartbeat = $heartbeat
+        $entry.LastChangeAt = $now
+        Emit-State $profile 'detecting' 'waiting for a game heartbeat change'
+      } elseif ($entry.LastHeartbeat -ne $heartbeat) {
+        $entry.LastHeartbeat = $heartbeat
+        $entry.LastChangeAt = $now
+        $entry.ObservedChange = $true
+        Emit-State $profile 'playing' 'game world is updating'
+      } elseif (($now - $entry.LastChangeAt).TotalMilliseconds -ge [int]$profile.pauseDelayMs) {
+        Emit-State $profile 'paused' 'game world is paused or in a menu'
+      } elseif ($entry.ObservedChange) {
+        Emit-State $profile 'playing' 'game world is updating'
+      } else {
+        Emit-State $profile 'detecting' 'waiting for a game heartbeat change'
+      }
+    } catch {
+      if ($null -ne $entry -and $entry.Handle -ne [IntPtr]::Zero) { [GitDoneGameMemory]::CloseHandle($entry.Handle) | Out-Null }
+      $attached.Remove($profile.id)
+      Emit-State $profile 'error' $_.Exception.Message
+    }
+  }
+  Start-Sleep -Milliseconds 250
+}
+`
+}
+
+function queueGameReport(cfg, reading) {
+  if (!GAME_PROFILES.some((profile) => profile.id === reading?.gameId)) return
+  const state = reading.state === 'detecting' ? 'paused' : reading.state
+  if (!['playing', 'paused', 'not_running', 'unsupported', 'error'].includes(state)) return
+
+  const now = Date.now()
+  const previous = gameLastReport.get(reading.gameId)
+  if (previous?.state === state && (state !== 'playing' || now - previous.at < GAME_REPORT_HEARTBEAT_MS)) return
+  gameLastReport.set(reading.gameId, { state, at: now })
+
+  gameReportQueue = gameReportQueue
+    .then(async () => {
+      await api(cfg, '/api/v1/games/activity', {
+        machineId: cfg.machineId,
+        gameId: reading.gameId,
+        state,
+        observedAt: reading.observedAt || new Date().toISOString(),
+      })
+      if (previous?.state !== state) log(`🎮 ${reading.gameId}: ${state}`)
+    })
+    .catch((err) => log(`✗ game activity sync failed: ${err.message}`))
+}
+
+async function startGameActivityMonitor(cfg, printOnly = false) {
+  if (process.platform !== 'win32') {
+    if (printOnly) console.log('Game activity detection is currently available on Windows only.')
+    return
+  }
+  for (;;) {
+    try {
+      ensureAgentDir()
+      writeFileSync(GAME_MONITOR_PATH, gameMonitorScript(), 'utf8')
+      const child = spawn('powershell.exe', ['-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-File', GAME_MONITOR_PATH], {
+        windowsHide: true,
+        stdio: ['ignore', 'pipe', 'pipe'],
+      })
+      const lines = readline.createInterface({ input: child.stdout })
+      lines.on('line', (line) => {
+        try {
+          const reading = JSON.parse(line)
+          if (printOnly) console.log(`${reading.observedAt} ${reading.gameId}: ${reading.state} — ${reading.detail}`)
+          else queueGameReport(cfg, reading)
+        } catch { /* ignore non-JSON PowerShell host noise */ }
+      })
+      let stderr = ''
+      child.stderr.on('data', (chunk) => { stderr = (stderr + chunk.toString()).slice(-2000) })
+      const exitCode = await new Promise((resolveExit) => child.once('exit', resolveExit))
+      lines.close()
+      for (const profile of GAME_PROFILES) {
+        const reading = { gameId: profile.id, state: 'error', observedAt: new Date().toISOString() }
+        if (printOnly) console.error(`${reading.observedAt} ${profile.id}: monitor stopped`)
+        else queueGameReport(cfg, reading)
+      }
+      log(`… game monitor stopped (${exitCode}${stderr ? `: ${stderr.trim()}` : ''}); restarting`)
+    } catch (err) {
+      log(`… game monitor unavailable (${err.message}); retrying`)
+    }
+    await new Promise((resolveWait) => setTimeout(resolveWait, 3000))
+  }
+}
+
 const API_REQUEST_TIMEOUT_MS = 10_000
 
 async function apiOnce(cfg, path, body) {
@@ -3232,6 +3429,7 @@ 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)
+  startGameActivityMonitor(cfg)
 
   await tick()
   setInterval(tick, cfg.interval * 1000)
@@ -3246,6 +3444,12 @@ async function main() {
     process.exit(0)
   }
 
+  if (args.testGames) {
+    const cfg = buildConfig(args)
+    await startGameActivityMonitor(cfg, true)
+    return
+  }
+
   if (args.doctor) {
     runDoctor()
     process.exit(0)

package/package.json

@@ -1,6 +1,6 @@
 {
     "name":  "gitdone-agent",
-    "version":  "0.8.11",
+    "version":  "0.8.12",
     "description":  "Local gitDone companion for repository and optional World of Warcraft progress sync",
     "type":  "module",
     "files":  [