gitdone-agent 0.1.2 → 0.2.0

package/index.js

@@ -1,43 +1,89 @@
 #!/usr/bin/env node
-// gitdone-agent — watches a local git repo and pushes snapshots to gitdone.eu
-// Usage: bun index.js --key=gdo_xxx --name=my-repo --path=/path/to/repo [--install]
+// gitdone-agent — scans root folders for git repos and pushes snapshots of the
+// ones the server marks as "tracked" to gitdone.eu.
+//
+// Setup (once):
+//   npx gitdone-agent --key=gdo_xxx --root=C:\path\to\projects --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
+// from ~/.gitdone-agent/config.json, so the autostart entry needs no args.
 
 import { execSync, spawn } from 'node:child_process'
-import { existsSync, writeFileSync, unlinkSync } from 'node:fs'
+import {
+  existsSync, writeFileSync, readFileSync, unlinkSync,
+  mkdirSync, copyFileSync, appendFileSync, readdirSync,
+} from 'node:fs'
 import { resolve, join } from 'node:path'
-import { homedir } from 'node:os'
+import { homedir, hostname } from 'node:os'
+import { randomUUID } from 'node:crypto'
+
+// ─── Stable agent dir, config + logging ────────────────────────────────────────
+// Everything persistent lives here: a stable copy of the agent script (so
+// autostart never points at a purged npx temp dir), the config file (source of
+// truth for the running agent), and a log file (so failures are visible even
+// when the agent runs in a hidden window).
+
+const AGENT_DIR = join(homedir(), '.gitdone-agent')
+const CONFIG_PATH = join(AGENT_DIR, 'config.json')
+const STABLE_AGENT = join(AGENT_DIR, 'agent.mjs')
+const LOG_PATH = join(AGENT_DIR, 'agent.log')
+
+function ensureAgentDir() {
+  if (!existsSync(AGENT_DIR)) mkdirSync(AGENT_DIR, { recursive: true })
+}
+
+function log(msg) {
+  const line = `[${new Date().toISOString()}] ${msg}`
+  console.log(line)
+  try { ensureAgentDir(); appendFileSync(LOG_PATH, line + '\n') } catch { /* best-effort */ }
+}
+
+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')
+}
 
 // ─── Arg parsing ─────────────────────────────────────────────────────────────
 
 function parseArgs() {
-  const args = Object.fromEntries(
-    process.argv.slice(2)
-      .filter((a) => a.startsWith('--'))
-      .map((a) => {
-        const [k, ...rest] = a.slice(2).split('=')
-        return [k, rest.join('=')]
-      })
-  )
-
-  const key = args.key
-  const repoPath = args.path ? resolve(args.path) : process.cwd()
-  const name = args.name ?? repoPath.split(/[\\/]/).pop() ?? 'repo'
-  const projectId = args.project ?? null
-  const interval = Number(args.interval ?? 30)
-  const url = (args.url ?? 'https://gitdone.eu').replace(/\/$/, '')
-  const install = 'install' in args
-  const uninstall = 'uninstall' in args
-
-  if (!key && !uninstall) {
-    console.error('Error: --key is required (e.g. --key=gdo_xxx)')
-    process.exit(1)
+  const argv = process.argv.slice(2)
+  const flags = {}
+  const roots = []
+  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 flags[k] = v
   }
-  if (!existsSync(repoPath) && !uninstall) {
-    console.error(`Error: path does not exist: ${repoPath}`)
-    process.exit(1)
+  return {
+    key: flags.key,
+    roots,
+    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,
   }
+}
 
-  return { key, path: repoPath, name, projectId, interval, url, install, uninstall }
+// Merge CLI args into the persisted config, generating a machineId on first use.
+function buildConfig(args) {
+  const existing = readConfig() ?? {}
+  const mergedRoots = Array.from(new Set([...(existing.roots ?? []), ...args.roots]))
+  return {
+    key: args.key ?? existing.key,
+    url: args.url ?? existing.url ?? 'https://gitdone.eu',
+    interval: args.interval ?? existing.interval ?? 30,
+    machineId: existing.machineId ?? randomUUID(),
+    hostname: existing.hostname ?? hostname(),
+    roots: mergedRoots,
+  }
 }
 
 // ─── Windows auto-start ───────────────────────────────────────────────────────
@@ -46,49 +92,72 @@ function getStartupDir() {
   return join(homedir(), 'AppData', 'Roaming', 'Microsoft', 'Windows', 'Start Menu', 'Programs', 'Startup')
 }
 
+function getVbsPath() {
+  return join(getStartupDir(), 'gitdone-agent.vbs')
+}
+
 function getNodePath() {
   try { return execSync('where node', { encoding: 'utf8' }).trim().split('\n')[0].trim() } catch {}
   try { return execSync('which node', { encoding: 'utf8' }).trim() } catch {}
   return process.execPath
 }
 
-function installStartup({ name, key, path: repoPath, url, interval, projectId }) {
+function installStartup() {
+  ensureAgentDir()
   const nodePath = getNodePath()
-  const agentPath = resolve(process.argv[1])
-  const startupDir = getStartupDir()
-
-  const argLine = [
-    `--key=${key}`,
-    `--name=${name}`,
-    `--path=${repoPath}`,
-    `--url=${url}`,
-    `--interval=${interval}`,
-    ...(projectId ? [`--project=${projectId}`] : []),
-  ].join(' ')
-
-  // VBScript runs the agent silently — no console window pops up on login
+
+  // Copy this script to a stable location. process.argv[1] may point inside an
+  // npx cache dir that gets purged later — referencing it from autostart would
+  // silently break on the next login. A stable copy survives.
+  try {
+    copyFileSync(resolve(process.argv[1]), STABLE_AGENT)
+  } catch (err) {
+    console.error(`Warning: could not copy agent to ${STABLE_AGENT}: ${err.message}`)
+  }
+  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.
   const vbs = [
     'Set WshShell = CreateObject("WScript.Shell")',
-    `WshShell.Run """${nodePath}"" ""${agentPath}"" ${argLine}", 0, False`,
+    `WshShell.Run """${nodePath}"" ""${agentPath}""", 0, False`,
   ].join('\r\n')
 
-  const vbsPath = join(startupDir, `gitdone-${name}.vbs`)
-  writeFileSync(vbsPath, vbs, 'utf8')
-
-  console.log(`✓ Инсталиран! При следващото влизане в Windows агентът ще стартира автоматично.`)
-  console.log(`  Файл: ${vbsPath}`)
-  console.log(`  Repo : ${repoPath}`)
-  console.log(`  Name : ${name}`)
-  console.log()
+  writeFileSync(getVbsPath(), vbs, 'utf8')
 }
 
-function uninstallStartup(name) {
-  const vbsPath = join(getStartupDir(), `gitdone-${name}.vbs`)
+function uninstallStartup() {
+  const vbsPath = getVbsPath()
   if (existsSync(vbsPath)) {
     unlinkSync(vbsPath)
-    console.log(`✓ Премахнат автостарт за "${name}"`)
+    console.log(`✓ Премахнат автостарт за gitdone-agent`)
   } else {
-    console.log(`Не е намерен автостарт за "${name}" (${vbsPath})`)
+    console.log(`Не е намерен автостарт (${vbsPath})`)
+  }
+}
+
+// ─── Doctor ────────────────────────────────────────────────────────────────────
+
+function runDoctor() {
+  const cfg = readConfig()
+  console.log('gitdone-agent doctor')
+  console.log(`  node          : ${getNodePath()}`)
+  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(`  config        : ${CONFIG_PATH} ${existsSync(CONFIG_PATH) ? '(ok)' : '(MISSING)'}`)
+  console.log(`  log file      : ${LOG_PATH} ${existsSync(LOG_PATH) ? '(ok)' : '(none yet)'}`)
+  if (cfg) {
+    console.log(`  machineId     : ${cfg.machineId}`)
+    console.log(`  server        : ${cfg.url}`)
+    console.log(`  interval      : ${cfg.interval}s`)
+    console.log(`  roots         :`)
+    for (const r of cfg.roots ?? []) console.log(`     - ${r} ${existsSync(r) ? '' : '(MISSING)'}`)
+    if (cfg.roots?.length) {
+      const found = scanRepos(cfg.roots)
+      console.log(`  found repos   : ${found.length}`)
+      for (const r of found) console.log(`     - ${r.name}  (${r.path})`)
+    }
   }
 }
 
@@ -102,10 +171,6 @@ function git(cmd, cwd) {
   }
 }
 
-function isGitRepo(path) {
-  return git('git rev-parse --git-dir', path) !== ''
-}
-
 function parseDiffByFile(diffOutput) {
   const files = {}
   if (!diffOutput) return files
@@ -148,109 +213,186 @@ function getSnapshot(repoPath) {
   return { branch, modified, staged, aheadBy, behindBy, lastCommit, statuses, diffs }
 }
 
-// ─── Push to API & execute commands ─────────────────────────────────────────
+// ─── Repo discovery ─────────────────────────────────────────────────────────────
+// Walk each root looking for directories that contain a `.git` entry. Stop
+// descending once a repo is found (don't recurse into submodules/nested repos),
+// skip noisy dirs, and cap depth so a huge tree can't hang a tick.
+
+const SKIP_DIRS = new Set(['node_modules', '.next', 'dist', 'build', '.cache', 'vendor', '.venv', '__pycache__'])
+
+function scanRepos(roots, maxDepth = 5) {
+  const found = []
+  const seen = new Set()
+
+  function walk(dir, depth) {
+    if (depth > maxDepth) return
+    let entries
+    try { entries = readdirSync(dir, { withFileTypes: true }) } catch { return }
+
+    if (entries.some((e) => e.name === '.git')) {
+      const path = resolve(dir)
+      if (!seen.has(path)) {
+        seen.add(path)
+        found.push({ name: path.split(/[\\/]/).pop() ?? path, path })
+      }
+      return // a repo — don't descend further
+    }
+
+    for (const e of entries) {
+      if (!e.isDirectory()) continue
+      if (e.name.startsWith('.') || SKIP_DIRS.has(e.name)) continue
+      walk(join(dir, e.name), depth + 1)
+    }
+  }
 
-async function reportCommandResult(url, key, id, status, result) {
-  await fetch(`${url}/api/v1/agent/command-result`, {
+  for (const root of roots) walk(resolve(root), 0)
+  return found
+}
+
+// ─── Server sync + commands ─────────────────────────────────────────────────────
+
+async function api(cfg, path, body) {
+  const res = await fetch(`${cfg.url}${path}`, {
     method: 'POST',
-    headers: { 'Authorization': `Bearer ${key}`, 'Content-Type': 'application/json' },
-    body: JSON.stringify({ id, status, result }),
-  }).catch(() => {})
+    headers: { Authorization: `Bearer ${cfg.key}`, 'Content-Type': 'application/json' },
+    body: JSON.stringify(body),
+  })
+  if (!res.ok) {
+    const text = await res.text().catch(() => '')
+    throw new Error(`HTTP ${res.status} ${path}: ${text}`)
+  }
+  return res.json().catch(() => ({}))
+}
+
+async function reportCommandResult(cfg, id, status, result) {
+  await api(cfg, '/api/v1/agent/command-result', { id, status, result }).catch(() => {})
 }
 
-async function executeCommand(cmd, repoPath, url, key) {
+async function executeCommand(cfg, cmd, repoPath) {
   let result = 'ok'
   let status = 'done'
   try {
     if (cmd.type === 'commit') {
       const msg = (cmd.payload?.message ?? 'commit').replace(/"/g, '\\"')
       git('git add -A', repoPath)
-      const out = git(`git commit -m "${msg}"`, repoPath)
-      result = out || 'committed'
+      result = git(`git commit -m "${msg}"`, repoPath) || 'committed'
     } else if (cmd.type === 'push') {
-      const out = git('git push', repoPath)
-      result = out || 'pushed'
+      result = git('git push', repoPath) || 'pushed'
     } else if (cmd.type === 'pull') {
-      const out = git('git pull', repoPath)
-      result = out || 'pulled'
+      result = git('git pull', repoPath) || 'pulled'
     }
-    console.log(`[${new Date().toLocaleTimeString()}] ✓ ${cmd.type}: ${result}`)
+    log(`✓ ${cmd.type} @ ${repoPath}: ${result}`)
   } catch (err) {
     status = 'error'
     result = err.message
-    console.error(`[${new Date().toLocaleTimeString()}] ✗ ${cmd.type} failed: ${result}`)
+    log(`✗ ${cmd.type} failed @ ${repoPath}: ${result}`)
   }
-  await reportCommandResult(url, key, cmd.id, status, result)
+  await reportCommandResult(cfg, cmd.id, status, result)
 }
 
-async function push({ url, key, name, projectId, repoPath, snapshot }) {
-  const res = await fetch(`${url}/api/v1/agent/snapshot`, {
-    method: 'POST',
-    headers: { 'Authorization': `Bearer ${key}`, 'Content-Type': 'application/json' },
-    body: JSON.stringify({ repoName: name, projectId, ...snapshot }),
+// Report discovered repos + machine info, get back which repos to track.
+async function sync(cfg, discovered) {
+  const data = await api(cfg, '/api/v1/agent/sync', {
+    machineId: cfg.machineId,
+    hostname: cfg.hostname,
+    roots: cfg.roots,
+    repos: discovered,
+  })
+  return data.tracked ?? []
+}
+
+// Push one tracked repo's snapshot and run any pending commands for it.
+async function pushSnapshot(cfg, repo) {
+  const snapshot = getSnapshot(repo.path)
+  const data = await api(cfg, '/api/v1/agent/snapshot', {
+    machineId: cfg.machineId,
+    path: repo.path,
+    repoName: repo.name,
+    ...snapshot,
   })
-  if (!res.ok) {
-    const text = await res.text().catch(() => '')
-    throw new Error(`HTTP ${res.status}: ${text}`)
-  }
-  const data = await res.json().catch(() => ({}))
   for (const cmd of data.commands ?? []) {
-    await executeCommand(cmd, repoPath, url, key)
+    await executeCommand(cfg, cmd, repo.path)
   }
+  return snapshot
 }
 
 // ─── Main ────────────────────────────────────────────────────────────────────
 
-async function main() {
-  const config = parseArgs()
-  const { key, path: repoPath, name, projectId, interval, url, install, uninstall } = config
+async function runLoop(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)'}`)
 
-  if (uninstall) {
-    uninstallStartup(name)
-    process.exit(0)
+  async function tick() {
+    try {
+      const discovered = scanRepos(cfg.roots)
+      const tracked = await sync(cfg, discovered)
+      let pushed = 0
+      for (const repo of tracked) {
+        try { await pushSnapshot(cfg, repo); pushed++ }
+        catch (err) { log(`✗ snapshot failed @ ${repo.path}: ${err.message}`) }
+      }
+      log(`✓ tick — discovered: ${discovered.length}, tracked: ${tracked.length}, pushed: ${pushed}`)
+    } catch (err) {
+      log(`✗ sync error: ${err.message}`)
+    }
   }
 
-  if (install) {
-    installStartup(config)
+  await tick()
+  setInterval(tick, cfg.interval * 1000)
+}
 
-    // Launch the agent silently in the background right now via wscript.exe
-    const vbsPath = join(getStartupDir(), `gitdone-${name}.vbs`)
-    const child = spawn('wscript.exe', [vbsPath], { detached: true, stdio: 'ignore' })
-    child.unref()
+async function main() {
+  const args = parseArgs()
 
-    console.log()
-    console.log('✓ Агентът е стартиран в заден план — можеш да затвориш прозореца.')
-    console.log('  При следващо влизане в Windows ще стартира автоматично.')
+  if (args.doctor) {
+    runDoctor()
     process.exit(0)
   }
 
-  if (!isGitRepo(repoPath)) {
-    console.error(`Error: ${repoPath} is not a git repository`)
-    process.exit(1)
+  if (args.uninstall) {
+    uninstallStartup()
+    process.exit(0)
   }
 
-  console.log(`gitdone-agent started`)
-  console.log(`  repo    : ${repoPath}`)
-  console.log(`  name    : ${name}`)
-  if (projectId) console.log(`  project : ${projectId}`)
-  console.log(`  server  : ${url}`)
-  console.log(`  interval: ${interval}s`)
-  if (install) console.log(`  startup : registered`)
-  console.log()
-
-  async function tick() {
-    try {
-      const snapshot = getSnapshot(repoPath)
-      await push({ url, key, name, projectId, repoPath, snapshot })
-      const changed = snapshot.modified.length + snapshot.staged.length
-      console.log(`[${new Date().toLocaleTimeString()}] ✓ pushed — branch: ${snapshot.branch}, changes: ${changed}`)
-    } catch (err) {
-      console.error(`[${new Date().toLocaleTimeString()}] ✗ error: ${err.message}`)
+  // Setup / install path: merge CLI args into config, optionally (re)install.
+  if (args.install || args.key || args.roots.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)')
+      process.exit(1)
+    }
+    writeConfig(cfg)
+
+    if (args.install) {
+      installStartup()
+      console.log(`✓ Инсталиран! При следващото влизане в Windows агентът ще стартира автоматично.`)
+      console.log(`  Агент  : ${STABLE_AGENT}`)
+      console.log(`  Config : ${CONFIG_PATH}`)
+      console.log(`  Лог    : ${LOG_PATH}`)
+      console.log(`  Roots  :`)
+      for (const r of cfg.roots) console.log(`     - ${r}`)
+      console.log()
+
+      // Launch silently in the background right now.
+      const child = spawn('wscript.exe', [getVbsPath()], { detached: true, stdio: 'ignore' })
+      child.unref()
+      console.log('✓ Агентът е стартиран в заден план — можеш да затвориш прозореца.')
+      console.log('  Сега избери кои репота да следи от gitdone.eu/github.')
+      process.exit(0)
     }
+
+    // --key/--root without --install: just run the loop in the foreground.
+    await runLoop(cfg)
+    return
   }
 
-  await tick()
-  setInterval(tick, interval * 1000)
+  // No args → running mode (this is how autostart launches us): read config.
+  const cfg = readConfig()
+  if (!cfg || !cfg.key) {
+    console.error(`Error: no config found at ${CONFIG_PATH}. Run with --key=... --root=... --install first.`)
+    process.exit(1)
+  }
+  await runLoop(cfg)
 }
 
 main()

package/package.json

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