gitdone-agent 0.5.2 → 0.5.4

package/index.js

@@ -1,863 +1,932 @@
-#!/usr/bin/env node
-// 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, readFileSync, unlinkSync,
-  mkdirSync, copyFileSync, appendFileSync, readdirSync,
-} from 'node:fs'
-import { resolve, join } from 'node:path'
-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).
-
-// 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.5.2'
-
-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 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
-  }
-  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,
-  }
-}
-
-// 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 ───────────────────────────────────────────────────────
-
-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
-}
-
-// Locate the Claude Code CLI. Prefer a real executable (claude.exe from the
-// native installer) so spawn works WITHOUT a shell — that lets us pass a
-// multi-line, non-ASCII prompt as a single argv element with no escaping. An
-// npm shim (claude.cmd) needs shell:true, where we collapse the prompt to one
-// line to survive cmd.exe parsing.
-function findClaude() {
-  const tryCmd = (c) => {
-    try {
-      const out = execSync(c, { encoding: 'utf8' }).trim()
-      return out ? out.split(/\r?\n/).map((s) => s.trim()).filter(Boolean) : []
-    } catch { return [] }
-  }
-  const cands = [...tryCmd('where claude'), ...tryCmd('which claude')]
-  const exe = cands.find((p) => /\.exe$/i.test(p))
-  if (exe) return { path: exe, shell: false }
-  if (cands.length) return { path: cands[0], shell: true }
-  return { path: 'claude', shell: true }
-}
-
-// Kill any previously-running agent processes so an update applies WITHOUT a
-// Windows re-login. Targets node processes launched from the agent dir
-// (~/.gitdone-agent), excluding ourselves — the npx installer runs from the
-// npx cache, so it won't match. Best-effort; failures are non-fatal.
-function stopRunningAgents() {
-  const ps = [
-    "$ErrorActionPreference='SilentlyContinue'",
-    "Get-CimInstance Win32_Process -Filter \"Name='node.exe'\" |",
-    `  Where-Object { $_.CommandLine -like '*.gitdone-agent*' -and $_.ProcessId -ne ${process.pid} } |`,
-    '  ForEach-Object { Stop-Process -Id $_.ProcessId -Force }',
-  ].join('\n')
-  try {
-    ensureAgentDir()
-    const scriptPath = join(AGENT_DIR, 'stop-agents.ps1')
-    writeFileSync(scriptPath, ps, 'utf8')
-    execSync(`powershell -NoProfile -NonInteractive -ExecutionPolicy Bypass -File "${scriptPath}"`, { stdio: 'ignore' })
-  } catch { /* best-effort — at worst the old agent lingers until next login */ }
-}
-
-function installStartup() {
-  ensureAgentDir()
-  const nodePath = getNodePath()
-
-  // Stop the previously-running agent(s) first so we don't end up with the old
-  // build still reporting alongside the new one until the next Windows login.
-  stopRunningAgents()
-
-  // 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}""", 0, False`,
-  ].join('\r\n')
-
-  writeFileSync(getVbsPath(), vbs, 'utf8')
-}
-
-function uninstallStartup() {
-  const vbsPath = getVbsPath()
-  if (existsSync(vbsPath)) {
-    unlinkSync(vbsPath)
-    console.log(`✓ Премахнат автостарт за gitdone-agent`)
-  } else {
-    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})`)
-    }
-  }
-}
-
-// ─── Git helpers ─────────────────────────────────────────────────────────────
-
-function git(cmd, cwd) {
-  try {
-    return execSync(cmd, { cwd, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim()
-  } catch {
-    return ''
-  }
-}
-
-// 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) {
-  try {
-    const out = execSync(cmd, { cwd, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim()
-    return { ok: true, out }
-  } catch (err) {
-    const out = (err.stderr || err.stdout || err.message || '').toString().trim()
-    return { ok: false, out }
-  }
-}
-
-// Never let a token reach the log file or the server's command-result.
-function redact(text, token) {
-  if (!text || !token) return text
-  return text.split(token).join('***')
-}
-
-// https://x-access-token:<token>@github.com/<owner>/<repo>.git — an ad-hoc URL
-// passed straight to push/pull, so it never gets written into .git/config.
-function authUrl(auth) {
-  const repo = auth.repo.replace(/\.git$/i, '')
-  return `https://x-access-token:${auth.token}@github.com/${repo}.git`
-}
-
-// Push/pull using the server-issued token when we have one; otherwise fall back
-// to the machine's own git credentials (old behaviour). Throws on failure.
-function pushOrPull(type, repoPath, auth) {
-  const branch = git('git branch --show-current', repoPath) || 'HEAD'
-  let cmd
-  if (auth) {
-    const url = authUrl(auth)
-    cmd = type === 'push' ? `git push "${url}" HEAD:${branch}` : `git pull "${url}" ${branch}`
-  } else {
-    cmd = type === 'push' ? 'git push' : 'git pull'
-  }
-  const r = gitTry(cmd, repoPath)
-  if (!r.ok) throw new Error(r.out || `${type} failed`)
-  return r.out || (type === 'push' ? 'pushed' : 'pulled')
-}
-
-const AUTH_FAIL = /authentication|authorization|403|401|denied|could not read Username|invalid username or password|terminal prompts disabled/i
-
-function parseDiffByFile(diffOutput) {
-  const files = {}
-  if (!diffOutput) return files
-  const sections = diffOutput.split(/(?=^diff --git )/m)
-  for (const section of sections) {
-    if (!section.trim()) continue
-    const match = section.match(/^diff --git a\/.+ b\/(.+)$/m)
-    if (match) files[match[1]] = section
-  }
-  return files
-}
-
-function getSnapshot(repoPath) {
-  const branch = git('git branch --show-current', repoPath) || 'HEAD'
-
-  const statusLines = git('git status --porcelain', repoPath).split('\n').filter(Boolean)
-  const modified = []
-  const staged = []
-  const statuses = {}
-  for (const line of statusLines) {
-    const xy = line.slice(0, 2)
-    const file = line.slice(3)
-    statuses[file] = xy
-    if (xy[0] !== ' ' && xy[0] !== '?') staged.push(file)
-    if (xy[1] !== ' ') modified.push(file)
-  }
-
-  const aheadBy = parseInt(git('git rev-list --count @{u}..HEAD', repoPath), 10) || 0
-  const behindBy = parseInt(git('git rev-list --count HEAD..@{u}', repoPath), 10) || 0
-
-  const logLine = git('git log -1 --pretty=format:%H|%s|%an|%aI', repoPath)
-  let lastCommit = null
-  if (logLine) {
-    const [sha, message, author, date] = logLine.split('|')
-    lastCommit = { sha, message, author, date }
-  }
-
-  const diffs = parseDiffByFile(git('git diff HEAD', repoPath))
-
-  // 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
-
-  return { branch, modified, staged, aheadBy, behindBy, lastCommit, statuses, diffs, remoteUrl }
-}
-
-// ─── 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)
-    }
-  }
-
-  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 ${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(() => {})
-}
-
-// Post a batch of console events (and optional lifecycle status) for an AiRun.
-async function postRunEvents(cfg, runId, events, status, result) {
-  await api(cfg, '/api/v1/agent/ai-run/events', {
-    runId,
-    events,
-    ...(status ? { status } : {}),
-    ...(result !== undefined ? { result } : {}),
-  }).catch((e) => log(`✗ ai-run events post failed: ${e.message}`))
-}
-
-// Post transcript lines (and optional turn status / Claude session id) for an
-// interactive AiSession chat turn.
-async function postSessionEvents(cfg, sessionId, events, status, claudeSessionId) {
-  await api(cfg, '/api/v1/agent/ai-session/events', {
-    sessionId,
-    events,
-    ...(status ? { status } : {}),
-    ...(claudeSessionId ? { claudeSessionId } : {}),
-  }).catch((e) => log(`✗ ai-session events post failed: ${e.message}`))
-}
-
-// Turn one stream-json line from `claude -p` into console events. Phase 1 shows
-// what the model writes (TEXT) and which tools it calls (TOOL_CALL); raw tool
-// results (Bash stdout etc.) come in Phase 2 via a PostToolUse hook.
-function parseStreamLine(line, push, onInit) {
-  let ev
-  try { ev = JSON.parse(line) } catch { return }
-  if (ev.type === 'system') {
-    if (ev.subtype === 'init') {
-      push('SYSTEM', `Сесия стартирана${ev.model ? ` (${ev.model})` : ''}.`)
-      // Surface Claude's own session id so chat sessions can --resume it.
-      if (ev.session_id && typeof onInit === 'function') onInit(ev.session_id)
-    }
-    return
-  }
-  if (ev.type === 'assistant' && ev.message?.content) {
-    for (const block of ev.message.content) {
-      if (block.type === 'text' && block.text?.trim()) {
-        push('TEXT', block.text.trim())
-      } else if (block.type === 'tool_use') {
-        const input = block.input ? JSON.stringify(block.input) : ''
-        push('TOOL_CALL', `${block.name}${input ? ` ${input.slice(0, 400)}` : ''}`)
-      }
-    }
-    return
-  }
-  if (ev.type === 'result' && ev.subtype && ev.subtype !== 'success') {
-    push('SYSTEM', `Резултат: ${ev.subtype}`)
-  }
-}
-
-// Phase 2: write (once) a PostToolUse hook that forwards each tool's raw output
-// (Bash stdout, edit results, …) to the run's console, plus the settings file
-// that registers it. The hook reads GITDONE_* from its env (set per run on the
-// claude process). Returns the settings path to pass via --settings.
-const AI_HOOK_SCRIPT = join(AGENT_DIR, 'ai-run-hook.mjs')
-const AI_SETTINGS_PATH = join(AGENT_DIR, 'ai-run-settings.json')
-
-function ensureAiHookFiles() {
-  ensureAgentDir()
-  const hookSrc = [
-    "import process from 'node:process'",
-    "let data = ''",
-    "process.stdin.setEncoding('utf8')",
-    "process.stdin.on('data', (c) => { data += c })",
-    'process.stdin.on(\'end\', async () => {',
-    '  try {',
-    "    const ev = JSON.parse(data || '{}')",
-    '    const url = process.env.GITDONE_URL, key = process.env.GITDONE_KEY, runId = process.env.GITDONE_RUN_ID',
-    '    if (url && key && runId) {',
-    "      const name = ev.tool_name || 'tool'",
-    '      const o = ev.tool_output',
-    "      let out = ''",
-    "      if (typeof o === 'string') out = o",
-    "      else if (o && typeof o === 'object') out = o.text || o.stdout || o.content || JSON.stringify(o)",
-    "      out = String(out || '').slice(0, 2000)",
-    "      const inp = ev.tool_input ? JSON.stringify(ev.tool_input).slice(0, 300) : ''",
-    "      const text = name + (inp ? ' ' + inp : '') + (out ? '\\n' + out : ' ✓')",
-    "      await fetch(url + '/api/v1/agent/ai-run/events', {",
-    "        method: 'POST',",
-    "        headers: { Authorization: 'Bearer ' + key, 'Content-Type': 'application/json' },",
-    "        body: JSON.stringify({ runId, events: [{ kind: 'TOOL_RESULT', text }] }),",
-    '      }).catch(() => {})',
-    '    }',
-    '  } catch {}',
-    '  process.exit(0)',
-    '})',
-  ].join('\n')
-  writeFileSync(AI_HOOK_SCRIPT, hookSrc, 'utf8')
-
-  const nodePath = getNodePath()
-  const settings = {
-    hooks: {
-      PostToolUse: [
-        { matcher: '', hooks: [{ type: 'command', command: `"${nodePath}" "${AI_HOOK_SCRIPT}"` }] },
-      ],
-    },
-  }
-  writeFileSync(AI_SETTINGS_PATH, JSON.stringify(settings, null, 2), 'utf8')
-  return AI_SETTINGS_PATH
-}
-
-// Same PostToolUse hook, for interactive chat sessions: posts raw tool output to
-// the session endpoint, reading GITDONE_SESSION_ID from the per-turn env.
-const AI_SESSION_HOOK_SCRIPT = join(AGENT_DIR, 'ai-session-hook.mjs')
-const AI_SESSION_SETTINGS_PATH = join(AGENT_DIR, 'ai-session-settings.json')
-
-function ensureAiSessionHookFiles() {
-  ensureAgentDir()
-  const hookSrc = [
-    "import process from 'node:process'",
-    "let data = ''",
-    "process.stdin.setEncoding('utf8')",
-    "process.stdin.on('data', (c) => { data += c })",
-    'process.stdin.on(\'end\', async () => {',
-    '  try {',
-    "    const ev = JSON.parse(data || '{}')",
-    '    const url = process.env.GITDONE_URL, key = process.env.GITDONE_KEY, sessionId = process.env.GITDONE_SESSION_ID',
-    '    if (url && key && sessionId) {',
-    "      const name = ev.tool_name || 'tool'",
-    '      const o = ev.tool_output',
-    "      let out = ''",
-    "      if (typeof o === 'string') out = o",
-    "      else if (o && typeof o === 'object') out = o.text || o.stdout || o.content || JSON.stringify(o)",
-    "      out = String(out || '').slice(0, 2000)",
-    "      const inp = ev.tool_input ? JSON.stringify(ev.tool_input).slice(0, 300) : ''",
-    "      const text = name + (inp ? ' ' + inp : '') + (out ? '\\n' + out : ' ✓')",
-    "      await fetch(url + '/api/v1/agent/ai-session/events', {",
-    "        method: 'POST',",
-    "        headers: { Authorization: 'Bearer ' + key, 'Content-Type': 'application/json' },",
-    "        body: JSON.stringify({ sessionId, events: [{ role: 'TOOL_RESULT', text }] }),",
-    '      }).catch(() => {})',
-    '    }',
-    '  } catch {}',
-    '  process.exit(0)',
-    '})',
-  ].join('\n')
-  writeFileSync(AI_SESSION_HOOK_SCRIPT, hookSrc, 'utf8')
-
-  const nodePath = getNodePath()
-  const settings = {
-    hooks: {
-      PostToolUse: [
-        { matcher: '', hooks: [{ type: 'command', command: `"${nodePath}" "${AI_SESSION_HOOK_SCRIPT}"` }] },
-      ],
-    },
-  }
-  writeFileSync(AI_SESSION_SETTINGS_PATH, JSON.stringify(settings, null, 2), 'utf8')
-  return AI_SESSION_SETTINGS_PATH
-}
-
-// Run a headless Claude Code session for an `ai_run` command and stream its
-// output back. Long-running and fire-and-forget: it wires up async handlers and
-// returns immediately so the agent's snapshot loop is never blocked.
-function runAiCommand(cfg, cmd, repoPath) {
-  const runId = cmd.payload?.runId
-  const prompt = cmd.payload?.prompt ?? ''
-  const allowCommit = cmd.payload?.allowCommit === true
-  if (!runId || !prompt) {
-    reportCommandResult(cfg, cmd.id, 'error', 'invalid ai_run payload')
-    return
-  }
-
-  const { path: claudePath, shell } = findClaude()
-
-  let settingsPath
-  try { settingsPath = ensureAiHookFiles() } catch (e) { log(`✗ ai hook setup failed: ${e.message}`) }
-
-  // The prompt is delivered on STDIN, not as a `-p <arg>` command-line value.
-  // A multi-line, non-ASCII (Cyrillic) prompt passed as an argv element gets
-  // mangled under the claude.cmd npm shim (shell:true → cmd.exe splits/strips
-  // it), so Claude received no prompt and fell back to an empty stdin
-  // ("no stdin data received…"), then ran blind off whatever was in the repo.
-  // Piping it to stdin is robust for both the native exe and the shim.
-  const args = [
-    '-p',
-    '--output-format', 'stream-json',
-    '--verbose',
-    '--permission-mode', 'acceptEdits',
-    '--allowedTools', 'Read,Edit,Write,Bash,mcp__gitdone__*',
-    // Block git commit/push unless this repo opted in (per-repo aiAutoCommit).
-    ...(allowCommit ? [] : ['--disallowedTools', 'Bash(git commit *),Bash(git push *)']),
-    ...(settingsPath ? ['--settings', settingsPath] : []),
-  ]
-
-  // The PostToolUse hook reads these from its env to post raw tool output.
-  const childEnv = { ...process.env, GITDONE_URL: cfg.url, GITDONE_KEY: cfg.key, GITDONE_RUN_ID: runId }
-
-  // Batch events on a timer so we don't hammer the server per token/line.
-  let pending = []
-  let flushing = false
-  const flush = async () => {
-    if (flushing || pending.length === 0) return
-    flushing = true
-    const batch = pending; pending = []
-    await postRunEvents(cfg, runId, batch)
-    flushing = false
-  }
-  const push = (kind, text) => { if (text != null && String(text) !== '') pending.push({ kind, text: String(text) }) }
-  const timer = setInterval(flush, 800)
-
-  log(`▶ ai_run ${runId} @ ${repoPath} via ${claudePath}`)
-  postRunEvents(cfg, runId, [{ kind: 'SYSTEM', text: `Стартиране на Claude Code в ${repoPath}…` }], 'running')
-
-  let child
-  try {
-    child = spawn(claudePath, args, { cwd: repoPath, shell, windowsHide: true, env: childEnv })
-  } catch (err) {
-    clearInterval(timer)
-    postRunEvents(cfg, runId, [{ kind: 'SYSTEM', text: `Грешка при стартиране: ${err.message}` }], 'error', err.message)
-    reportCommandResult(cfg, cmd.id, 'error', err.message)
-    return
-  }
-
-  // Write the prompt to stdin and close it so Claude reads it as the task.
-  // Swallow EPIPE in case the process exits before we finish writing.
-  if (child.stdin) {
-    child.stdin.on('error', () => {})
-    try { child.stdin.write(prompt); child.stdin.end() }
-    catch (e) { push('SYSTEM', `stdin write failed: ${e.message}`) }
-  }
-
-  let buf = ''
-  child.stdout.on('data', (d) => {
-    buf += d.toString()
-    let nl
-    while ((nl = buf.indexOf('\n')) >= 0) {
-      const line = buf.slice(0, nl).trim()
-      buf = buf.slice(nl + 1)
-      if (line) parseStreamLine(line, push)
-    }
-  })
-  child.stderr.on('data', (d) => { const s = d.toString().trim(); if (s) push('SYSTEM', s) })
-  child.on('error', (err) => push('SYSTEM', `Процесна грешка: ${err.message}`))
-  child.on('close', async (code) => {
-    clearInterval(timer)
-    if (buf.trim()) parseStreamLine(buf.trim(), push)
-    await flush()
-    const ok = code === 0
-    await postRunEvents(
-      cfg, runId,
-      [{ kind: 'SYSTEM', text: ok ? '✓ Готово.' : `✗ Процесът приключи с код ${code}.` }],
-      ok ? 'done' : 'error',
-      ok ? 'ok' : `exit ${code}`,
-    )
-    reportCommandResult(cfg, cmd.id, ok ? 'done' : 'error', `exit ${code}`)
-    log(`■ ai_run ${runId} приключи (code ${code})`)
-  })
-}
-
-// Run one turn of an interactive chat session: `claude -p` (resuming the prior
-// Claude session when known) with the user's message on stdin, streaming the
-// reply back to the session console. Long-running + fire-and-forget like ai_run.
-function runAiChat(cfg, cmd, repoPath) {
-  const sessionId = cmd.payload?.sessionId
-  const prompt = cmd.payload?.prompt ?? ''
-  const claudeSessionId = cmd.payload?.claudeSessionId || null
-  const allowCommit = cmd.payload?.allowCommit === true
-  if (!sessionId || !prompt) {
-    reportCommandResult(cfg, cmd.id, 'error', 'invalid ai_chat payload')
-    return
-  }
-
-  const { path: claudePath, shell } = findClaude()
-
-  let settingsPath
-  try { settingsPath = ensureAiSessionHookFiles() } catch (e) { log(`✗ ai session hook setup failed: ${e.message}`) }
-
-  const args = [
-    '-p',
-    '--output-format', 'stream-json',
-    '--verbose',
-    '--permission-mode', 'acceptEdits',
-    '--allowedTools', 'Read,Edit,Write,Bash,mcp__gitdone__*',
-    // Block git commit/push unless this repo opted in (per-repo aiAutoCommit).
-    ...(allowCommit ? [] : ['--disallowedTools', 'Bash(git commit *),Bash(git push *)']),
-    ...(claudeSessionId ? ['--resume', claudeSessionId] : []),
-    ...(settingsPath ? ['--settings', settingsPath] : []),
-  ]
-
-  const childEnv = { ...process.env, GITDONE_URL: cfg.url, GITDONE_KEY: cfg.key, GITDONE_SESSION_ID: sessionId }
-
-  // Map console kinds → session transcript roles (model text → ASSISTANT).
-  const roleFor = (kind) => (kind === 'TEXT' ? 'ASSISTANT' : kind)
-  let pending = []
-  let capturedSession = null // Claude's session id, sent (idempotently) for --resume
-  let flushing = false
-  const flush = async () => {
-    if (flushing || pending.length === 0) return
-    flushing = true
-    const batch = pending.map((e) => ({ role: roleFor(e.kind), text: e.text })); pending = []
-    await postSessionEvents(cfg, sessionId, batch, 'running', capturedSession || undefined)
-    flushing = false
-  }
-  const push = (kind, text) => { if (text != null && String(text) !== '') pending.push({ kind, text: String(text) }) }
-  const onInit = (sid) => { if (sid && !claudeSessionId) capturedSession = sid }
-  const timer = setInterval(flush, 800)
-
-  log(`▶ ai_chat ${sessionId} @ ${repoPath} (resume=${claudeSessionId ? 'yes' : 'no'}) via ${claudePath}`)
-
-  let child
-  try {
-    child = spawn(claudePath, args, { cwd: repoPath, shell, windowsHide: true, env: childEnv })
-  } catch (err) {
-    clearInterval(timer)
-    postSessionEvents(cfg, sessionId, [{ role: 'SYSTEM', text: `Грешка при стартиране: ${err.message}` }], 'error')
-    reportCommandResult(cfg, cmd.id, 'error', err.message)
-    return
-  }
-
-  if (child.stdin) {
-    child.stdin.on('error', () => {})
-    try { child.stdin.write(prompt); child.stdin.end() }
-    catch (e) { push('SYSTEM', `stdin write failed: ${e.message}`) }
-  }
-
-  let buf = ''
-  child.stdout.on('data', (d) => {
-    buf += d.toString()
-    let nl
-    while ((nl = buf.indexOf('\n')) >= 0) {
-      const line = buf.slice(0, nl).trim()
-      buf = buf.slice(nl + 1)
-      if (line) parseStreamLine(line, push, onInit)
-    }
-  })
-  child.stderr.on('data', (d) => { const s = d.toString().trim(); if (s) push('SYSTEM', s) })
-  child.on('error', (err) => push('SYSTEM', `Процесна грешка: ${err.message}`))
-  child.on('close', async (code) => {
-    clearInterval(timer)
-    if (buf.trim()) parseStreamLine(buf.trim(), push, onInit)
-    await flush()
-    const ok = code === 0
-    await postSessionEvents(
-      cfg, sessionId,
-      ok ? [] : [{ role: 'SYSTEM', text: `✗ Ходът приключи с код ${code}.` }],
-      ok ? 'idle' : 'error',
-      capturedSession || undefined,
-    )
-    reportCommandResult(cfg, cmd.id, ok ? 'done' : 'error', `exit ${code}`)
-    log(`■ ai_chat ${sessionId} приключи (code ${code})`)
-  })
-}
-
-async function executeCommand(cfg, cmd, repoPath) {
-  // ai_run is long-running + streaming — launch it in the background and return
-  // so the snapshot loop keeps going. It reports its own result on exit.
-  if (cmd.type === 'ai_run') {
-    runAiCommand(cfg, cmd, repoPath)
-    return
-  }
-  // ai_chat — one interactive turn, same fire-and-forget model.
-  if (cmd.type === 'ai_chat') {
-    runAiChat(cfg, cmd, repoPath)
-    return
-  }
-
-  let result = 'ok'
-  let status = 'done'
-  const auth = cfg.auth?.[repoPath] ?? null
-  try {
-    if (cmd.type === 'commit') {
-      const msg = (cmd.payload?.message ?? 'commit').replace(/"/g, '\\"')
-      git('git add -A', repoPath)
-      result = git(`git commit -m "${msg}"`, repoPath) || 'committed'
-    } else if (cmd.type === 'push' || cmd.type === 'pull') {
-      result = pushOrPull(cmd.type, repoPath, auth)
-    }
-    log(`✓ ${cmd.type} @ ${repoPath}: ${redact(result, auth?.token)}`)
-  } catch (err) {
-    status = 'error'
-    result = redact(err.message, auth?.token)
-    // Cached token rejected (e.g. rotated/expired on the server) → drop it so
-    // the next snapshot reports hasGithubAuth:false and the server reissues one.
-    if (auth && AUTH_FAIL.test(err.message)) {
-      delete cfg.auth[repoPath]
-      writeConfig(cfg)
-      result += ' — токенът е изчистен, пробвай командата пак'
-    }
-    log(`✗ ${cmd.type} failed @ ${repoPath}: ${result}`)
-  }
-  await reportCommandResult(cfg, cmd.id, status, result)
-}
-
-// 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,
-    agentVersion: AGENT_VERSION,
-    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,
-    // Tells the server whether we already hold a push token for this repo.
-    // Always a boolean → marks us as a token-capable agent.
-    hasGithubAuth: !!cfg.auth?.[repo.path],
-    ...snapshot,
-  })
-  // Server issued a (fresh) push token — cache it on disk so we ask only once.
-  if (data.githubAuth?.token && data.githubAuth?.repo) {
-    cfg.auth = cfg.auth ?? {}
-    cfg.auth[repo.path] = { token: data.githubAuth.token, repo: data.githubAuth.repo }
-    writeConfig(cfg)
-  }
-  for (const cmd of data.commands ?? []) {
-    await executeCommand(cfg, cmd, repo.path)
-  }
-  return snapshot
-}
-
-// ─── Main ────────────────────────────────────────────────────────────────────
-
-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)'}`)
-
-  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}`)
-    }
-  }
-
-  await tick()
-  setInterval(tick, cfg.interval * 1000)
-}
-
-async function main() {
-  const args = parseArgs()
-
-  if (args.doctor) {
-    runDoctor()
-    process.exit(0)
-  }
-
-  if (args.uninstall) {
-    uninstallStartup()
-    process.exit(0)
-  }
-
-  // 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
-  }
-
-  // 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()
+#!/usr/bin/env node
+// 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, readFileSync, unlinkSync,
+  mkdirSync, copyFileSync, appendFileSync, readdirSync,
+} from 'node:fs'
+import { resolve, join } from 'node:path'
+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).
+
+// 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.5.4'
+
+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 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
+  }
+  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,
+  }
+}
+
+// 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 ───────────────────────────────────────────────────────
+
+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
+}
+
+// Locate the Claude Code CLI. Prefer a real executable (claude.exe from the
+// native installer) so spawn works WITHOUT a shell — that lets us pass a
+// multi-line, non-ASCII prompt as a single argv element with no escaping. An
+// npm shim (claude.cmd) needs shell:true, where we collapse the prompt to one
+// line to survive cmd.exe parsing. Returns `found:false` when nothing was
+// located, so callers can show a clear message instead of spawning bare
+// `claude` and letting cmd.exe emit "'claude' is not recognized…".
+function findClaude() {
+  const tryCmd = (c) => {
+    try {
+      const out = execSync(c, { encoding: 'utf8' }).trim()
+      return out ? out.split(/\r?\n/).map((s) => s.trim()).filter(Boolean) : []
+    } catch { return [] }
+  }
+  const cands = [...tryCmd('where claude'), ...tryCmd('which claude')]
+
+  // The agent is auto-started at login, so its PATH is frozen at that moment —
+  // a `claude` installed (or a PATH entry added) afterwards is invisible to
+  // `where`/`which` above. Probe the well-known install locations directly so a
+  // freshly-installed CLI works without a Windows re-login.
+  const home = homedir()
+  const appData = process.env.APPDATA || join(home, 'AppData', 'Roaming')
+  for (const p of [
+    join(home, '.local', 'bin', 'claude.exe'), // Windows native installer
+    join(appData, 'npm', 'claude.cmd'),        // Windows npm global shim
+    join(home, '.local', 'bin', 'claude'),     // macOS/Linux native installer
+    '/usr/local/bin/claude',                   // Homebrew (Intel) / manual install
+    '/opt/homebrew/bin/claude',                // Homebrew (Apple silicon)
+  ]) {
+    if (existsSync(p) && !cands.includes(p)) cands.push(p)
+  }
+
+  const exe = cands.find((p) => /\.exe$/i.test(p))
+  if (exe) return { path: exe, shell: false, found: true }
+  if (cands.length) return { path: cands[0], shell: true, found: true }
+  return { path: 'claude', shell: true, found: false }
+}
+
+// Kill any previously-running agent processes so an update applies WITHOUT a
+// Windows re-login. Targets node processes launched from the agent dir
+// (~/.gitdone-agent), excluding ourselves — the npx installer runs from the
+// npx cache, so it won't match. Best-effort; failures are non-fatal.
+function stopRunningAgents() {
+  const ps = [
+    "$ErrorActionPreference='SilentlyContinue'",
+    "Get-CimInstance Win32_Process -Filter \"Name='node.exe'\" |",
+    `  Where-Object { $_.CommandLine -like '*.gitdone-agent*' -and $_.ProcessId -ne ${process.pid} } |`,
+    '  ForEach-Object { Stop-Process -Id $_.ProcessId -Force }',
+  ].join('\n')
+  try {
+    ensureAgentDir()
+    const scriptPath = join(AGENT_DIR, 'stop-agents.ps1')
+    writeFileSync(scriptPath, ps, 'utf8')
+    execSync(`powershell -NoProfile -NonInteractive -ExecutionPolicy Bypass -File "${scriptPath}"`, { stdio: 'ignore' })
+  } catch { /* best-effort — at worst the old agent lingers until next login */ }
+}
+
+function installStartup() {
+  ensureAgentDir()
+  const nodePath = getNodePath()
+
+  // Stop the previously-running agent(s) first so we don't end up with the old
+  // build still reporting alongside the new one until the next Windows login.
+  stopRunningAgents()
+
+  // 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}""", 0, False`,
+  ].join('\r\n')
+
+  writeFileSync(getVbsPath(), vbs, 'utf8')
+}
+
+function uninstallStartup() {
+  const vbsPath = getVbsPath()
+  if (existsSync(vbsPath)) {
+    unlinkSync(vbsPath)
+    console.log(`✓ Премахнат автостарт за gitdone-agent`)
+  } else {
+    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)'}`)
+  const claude = findClaude()
+  console.log(`  claude cli    : ${claude.found ? claude.path : 'NOT FOUND — инсталирай от claude.ai/code и рестартирай агента'}`)
+  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})`)
+    }
+  }
+}
+
+// ─── Git helpers ─────────────────────────────────────────────────────────────
+
+function git(cmd, cwd) {
+  try {
+    return execSync(cmd, { cwd, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim()
+  } catch {
+    return ''
+  }
+}
+
+// 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) {
+  try {
+    const out = execSync(cmd, { cwd, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim()
+    return { ok: true, out }
+  } catch (err) {
+    const out = (err.stderr || err.stdout || err.message || '').toString().trim()
+    return { ok: false, out }
+  }
+}
+
+// Never let a token reach the log file or the server's command-result.
+function redact(text, token) {
+  if (!text || !token) return text
+  return text.split(token).join('***')
+}
+
+// https://x-access-token:<token>@github.com/<owner>/<repo>.git — an ad-hoc URL
+// passed straight to push/pull, so it never gets written into .git/config.
+function authUrl(auth) {
+  const repo = auth.repo.replace(/\.git$/i, '')
+  return `https://x-access-token:${auth.token}@github.com/${repo}.git`
+}
+
+// Push/pull using the server-issued token when we have one; otherwise fall back
+// to the machine's own git credentials (old behaviour). Throws on failure.
+function pushOrPull(type, repoPath, auth) {
+  const branch = git('git branch --show-current', repoPath) || 'HEAD'
+  let cmd
+  if (auth) {
+    const url = authUrl(auth)
+    cmd = type === 'push' ? `git push "${url}" HEAD:${branch}` : `git pull "${url}" ${branch}`
+  } else {
+    cmd = type === 'push' ? 'git push' : 'git pull'
+  }
+  const r = gitTry(cmd, repoPath)
+  if (!r.ok) throw new Error(r.out || `${type} failed`)
+  return r.out || (type === 'push' ? 'pushed' : 'pulled')
+}
+
+const AUTH_FAIL = /authentication|authorization|403|401|denied|could not read Username|invalid username or password|terminal prompts disabled/i
+
+// Discard all local changes to a SINGLE file, so it disappears from the repo's
+// "changes". Mirrors GitHub Desktop's "Discard changes": unstage first, then
+// either restore the file from HEAD (tracked) or delete it (new/untracked).
+function discardFile(repoPath, file) {
+  if (!file) throw new Error('no file')
+  // Unstage so index + worktree get reverted together (no-op if not staged).
+  gitTry(`git reset -q HEAD -- "${file}"`, repoPath)
+  // Does the file exist in the last commit? If so we restore its content; if
+  // not, it's a newly-added/untracked file and discarding means removing it.
+  const inHead = gitTry(`git cat-file -e "HEAD:${file}"`, repoPath).ok
+  if (inHead) {
+    const r = gitTry(`git checkout HEAD -- "${file}"`, repoPath)
+    if (!r.ok) throw new Error(r.out || 'checkout failed')
+    return 'discarded'
+  }
+  // New/untracked file (now unstaged) — drop it from the working tree.
+  const r = gitTry(`git clean -fdq -- "${file}"`, repoPath)
+  if (!r.ok) throw new Error(r.out || 'clean failed')
+  return 'discarded (new file removed)'
+}
+
+function parseDiffByFile(diffOutput) {
+  const files = {}
+  if (!diffOutput) return files
+  const sections = diffOutput.split(/(?=^diff --git )/m)
+  for (const section of sections) {
+    if (!section.trim()) continue
+    const match = section.match(/^diff --git a\/.+ b\/(.+)$/m)
+    if (match) files[match[1]] = section
+  }
+  return files
+}
+
+function getSnapshot(repoPath) {
+  const branch = git('git branch --show-current', repoPath) || 'HEAD'
+
+  const statusLines = git('git status --porcelain', repoPath).split('\n').filter(Boolean)
+  const modified = []
+  const staged = []
+  const statuses = {}
+  for (const line of statusLines) {
+    const xy = line.slice(0, 2)
+    const file = line.slice(3)
+    statuses[file] = xy
+    if (xy[0] !== ' ' && xy[0] !== '?') staged.push(file)
+    if (xy[1] !== ' ') modified.push(file)
+  }
+
+  const aheadBy = parseInt(git('git rev-list --count @{u}..HEAD', repoPath), 10) || 0
+  const behindBy = parseInt(git('git rev-list --count HEAD..@{u}', repoPath), 10) || 0
+
+  const logLine = git('git log -1 --pretty=format:%H|%s|%an|%aI', repoPath)
+  let lastCommit = null
+  if (logLine) {
+    const [sha, message, author, date] = logLine.split('|')
+    lastCommit = { sha, message, author, date }
+  }
+
+  const diffs = parseDiffByFile(git('git diff HEAD', repoPath))
+
+  // 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
+
+  return { branch, modified, staged, aheadBy, behindBy, lastCommit, statuses, diffs, remoteUrl }
+}
+
+// ─── 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)
+    }
+  }
+
+  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 ${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(() => {})
+}
+
+// Post a batch of console events (and optional lifecycle status) for an AiRun.
+async function postRunEvents(cfg, runId, events, status, result) {
+  await api(cfg, '/api/v1/agent/ai-run/events', {
+    runId,
+    events,
+    ...(status ? { status } : {}),
+    ...(result !== undefined ? { result } : {}),
+  }).catch((e) => log(`✗ ai-run events post failed: ${e.message}`))
+}
+
+// Post transcript lines (and optional turn status / Claude session id) for an
+// interactive AiSession chat turn.
+async function postSessionEvents(cfg, sessionId, events, status, claudeSessionId) {
+  await api(cfg, '/api/v1/agent/ai-session/events', {
+    sessionId,
+    events,
+    ...(status ? { status } : {}),
+    ...(claudeSessionId ? { claudeSessionId } : {}),
+  }).catch((e) => log(`✗ ai-session events post failed: ${e.message}`))
+}
+
+// Turn one stream-json line from `claude -p` into console events. Phase 1 shows
+// what the model writes (TEXT) and which tools it calls (TOOL_CALL); raw tool
+// results (Bash stdout etc.) come in Phase 2 via a PostToolUse hook.
+function parseStreamLine(line, push, onInit) {
+  let ev
+  try { ev = JSON.parse(line) } catch { return }
+  if (ev.type === 'system') {
+    if (ev.subtype === 'init') {
+      push('SYSTEM', `Сесия стартирана${ev.model ? ` (${ev.model})` : ''}.`)
+      // Surface Claude's own session id so chat sessions can --resume it.
+      if (ev.session_id && typeof onInit === 'function') onInit(ev.session_id)
+    }
+    return
+  }
+  if (ev.type === 'assistant' && ev.message?.content) {
+    for (const block of ev.message.content) {
+      if (block.type === 'text' && block.text?.trim()) {
+        push('TEXT', block.text.trim())
+      } else if (block.type === 'tool_use') {
+        const input = block.input ? JSON.stringify(block.input) : ''
+        push('TOOL_CALL', `${block.name}${input ? ` ${input.slice(0, 400)}` : ''}`)
+      }
+    }
+    return
+  }
+  if (ev.type === 'result' && ev.subtype && ev.subtype !== 'success') {
+    push('SYSTEM', `Резултат: ${ev.subtype}`)
+  }
+}
+
+// Phase 2: write (once) a PostToolUse hook that forwards each tool's raw output
+// (Bash stdout, edit results, …) to the run's console, plus the settings file
+// that registers it. The hook reads GITDONE_* from its env (set per run on the
+// claude process). Returns the settings path to pass via --settings.
+const AI_HOOK_SCRIPT = join(AGENT_DIR, 'ai-run-hook.mjs')
+const AI_SETTINGS_PATH = join(AGENT_DIR, 'ai-run-settings.json')
+
+function ensureAiHookFiles() {
+  ensureAgentDir()
+  const hookSrc = [
+    "import process from 'node:process'",
+    "let data = ''",
+    "process.stdin.setEncoding('utf8')",
+    "process.stdin.on('data', (c) => { data += c })",
+    'process.stdin.on(\'end\', async () => {',
+    '  try {',
+    "    const ev = JSON.parse(data || '{}')",
+    '    const url = process.env.GITDONE_URL, key = process.env.GITDONE_KEY, runId = process.env.GITDONE_RUN_ID',
+    '    if (url && key && runId) {',
+    "      const name = ev.tool_name || 'tool'",
+    '      const o = ev.tool_output',
+    "      let out = ''",
+    "      if (typeof o === 'string') out = o",
+    "      else if (o && typeof o === 'object') out = o.text || o.stdout || o.content || JSON.stringify(o)",
+    "      out = String(out || '').slice(0, 2000)",
+    "      const inp = ev.tool_input ? JSON.stringify(ev.tool_input).slice(0, 300) : ''",
+    "      const text = name + (inp ? ' ' + inp : '') + (out ? '\\n' + out : ' ✓')",
+    "      await fetch(url + '/api/v1/agent/ai-run/events', {",
+    "        method: 'POST',",
+    "        headers: { Authorization: 'Bearer ' + key, 'Content-Type': 'application/json' },",
+    "        body: JSON.stringify({ runId, events: [{ kind: 'TOOL_RESULT', text }] }),",
+    '      }).catch(() => {})',
+    '    }',
+    '  } catch {}',
+    '  process.exit(0)',
+    '})',
+  ].join('\n')
+  writeFileSync(AI_HOOK_SCRIPT, hookSrc, 'utf8')
+
+  const nodePath = getNodePath()
+  const settings = {
+    hooks: {
+      PostToolUse: [
+        { matcher: '', hooks: [{ type: 'command', command: `"${nodePath}" "${AI_HOOK_SCRIPT}"` }] },
+      ],
+    },
+  }
+  writeFileSync(AI_SETTINGS_PATH, JSON.stringify(settings, null, 2), 'utf8')
+  return AI_SETTINGS_PATH
+}
+
+// Same PostToolUse hook, for interactive chat sessions: posts raw tool output to
+// the session endpoint, reading GITDONE_SESSION_ID from the per-turn env.
+const AI_SESSION_HOOK_SCRIPT = join(AGENT_DIR, 'ai-session-hook.mjs')
+const AI_SESSION_SETTINGS_PATH = join(AGENT_DIR, 'ai-session-settings.json')
+
+function ensureAiSessionHookFiles() {
+  ensureAgentDir()
+  const hookSrc = [
+    "import process from 'node:process'",
+    "let data = ''",
+    "process.stdin.setEncoding('utf8')",
+    "process.stdin.on('data', (c) => { data += c })",
+    'process.stdin.on(\'end\', async () => {',
+    '  try {',
+    "    const ev = JSON.parse(data || '{}')",
+    '    const url = process.env.GITDONE_URL, key = process.env.GITDONE_KEY, sessionId = process.env.GITDONE_SESSION_ID',
+    '    if (url && key && sessionId) {',
+    "      const name = ev.tool_name || 'tool'",
+    '      const o = ev.tool_output',
+    "      let out = ''",
+    "      if (typeof o === 'string') out = o",
+    "      else if (o && typeof o === 'object') out = o.text || o.stdout || o.content || JSON.stringify(o)",
+    "      out = String(out || '').slice(0, 2000)",
+    "      const inp = ev.tool_input ? JSON.stringify(ev.tool_input).slice(0, 300) : ''",
+    "      const text = name + (inp ? ' ' + inp : '') + (out ? '\\n' + out : ' ✓')",
+    "      await fetch(url + '/api/v1/agent/ai-session/events', {",
+    "        method: 'POST',",
+    "        headers: { Authorization: 'Bearer ' + key, 'Content-Type': 'application/json' },",
+    "        body: JSON.stringify({ sessionId, events: [{ role: 'TOOL_RESULT', text }] }),",
+    '      }).catch(() => {})',
+    '    }',
+    '  } catch {}',
+    '  process.exit(0)',
+    '})',
+  ].join('\n')
+  writeFileSync(AI_SESSION_HOOK_SCRIPT, hookSrc, 'utf8')
+
+  const nodePath = getNodePath()
+  const settings = {
+    hooks: {
+      PostToolUse: [
+        { matcher: '', hooks: [{ type: 'command', command: `"${nodePath}" "${AI_SESSION_HOOK_SCRIPT}"` }] },
+      ],
+    },
+  }
+  writeFileSync(AI_SESSION_SETTINGS_PATH, JSON.stringify(settings, null, 2), 'utf8')
+  return AI_SESSION_SETTINGS_PATH
+}
+
+// Run a headless Claude Code session for an `ai_run` command and stream its
+// output back. Long-running and fire-and-forget: it wires up async handlers and
+// returns immediately so the agent's snapshot loop is never blocked.
+function runAiCommand(cfg, cmd, repoPath) {
+  const runId = cmd.payload?.runId
+  const prompt = cmd.payload?.prompt ?? ''
+  const allowCommit = cmd.payload?.allowCommit === true
+  if (!runId || !prompt) {
+    reportCommandResult(cfg, cmd.id, 'error', 'invalid ai_run payload')
+    return
+  }
+
+  const { path: claudePath, shell, found } = findClaude()
+  if (!found) {
+    const msg = `Claude Code CLI не е намерен на този компютър (${cfg.hostname}). Инсталирай го от claude.ai/code и се увери, че „claude" е в PATH, после рестартирай агента.`
+    log(`✗ ai_run ${runId}: claude not found`)
+    postRunEvents(cfg, runId, [{ kind: 'SYSTEM', text: `✗ ${msg}` }], 'error', 'claude not found')
+    reportCommandResult(cfg, cmd.id, 'error', 'claude not found')
+    return
+  }
+
+  let settingsPath
+  try { settingsPath = ensureAiHookFiles() } catch (e) { log(`✗ ai hook setup failed: ${e.message}`) }
+
+  // The prompt is delivered on STDIN, not as a `-p <arg>` command-line value.
+  // A multi-line, non-ASCII (Cyrillic) prompt passed as an argv element gets
+  // mangled under the claude.cmd npm shim (shell:true → cmd.exe splits/strips
+  // it), so Claude received no prompt and fell back to an empty stdin
+  // ("no stdin data received…"), then ran blind off whatever was in the repo.
+  // Piping it to stdin is robust for both the native exe and the shim.
+  const args = [
+    '-p',
+    '--output-format', 'stream-json',
+    '--verbose',
+    '--permission-mode', 'acceptEdits',
+    '--allowedTools', 'Read,Edit,Write,Bash,mcp__gitdone__*',
+    // Block git commit/push unless this repo opted in (per-repo aiAutoCommit).
+    ...(allowCommit ? [] : ['--disallowedTools', 'Bash(git commit *),Bash(git push *)']),
+    ...(settingsPath ? ['--settings', settingsPath] : []),
+  ]
+
+  // The PostToolUse hook reads these from its env to post raw tool output.
+  const childEnv = { ...process.env, GITDONE_URL: cfg.url, GITDONE_KEY: cfg.key, GITDONE_RUN_ID: runId }
+
+  // Batch events on a timer so we don't hammer the server per token/line.
+  let pending = []
+  let flushing = false
+  const flush = async () => {
+    if (flushing || pending.length === 0) return
+    flushing = true
+    const batch = pending; pending = []
+    await postRunEvents(cfg, runId, batch)
+    flushing = false
+  }
+  const push = (kind, text) => { if (text != null && String(text) !== '') pending.push({ kind, text: String(text) }) }
+  const timer = setInterval(flush, 800)
+
+  log(`▶ ai_run ${runId} @ ${repoPath} via ${claudePath}`)
+  postRunEvents(cfg, runId, [{ kind: 'SYSTEM', text: `Стартиране на Claude Code в ${repoPath}…` }], 'running')
+
+  let child
+  try {
+    child = spawn(claudePath, args, { cwd: repoPath, shell, windowsHide: true, env: childEnv })
+  } catch (err) {
+    clearInterval(timer)
+    postRunEvents(cfg, runId, [{ kind: 'SYSTEM', text: `Грешка при стартиране: ${err.message}` }], 'error', err.message)
+    reportCommandResult(cfg, cmd.id, 'error', err.message)
+    return
+  }
+
+  // Write the prompt to stdin and close it so Claude reads it as the task.
+  // Swallow EPIPE in case the process exits before we finish writing.
+  if (child.stdin) {
+    child.stdin.on('error', () => {})
+    try { child.stdin.write(prompt); child.stdin.end() }
+    catch (e) { push('SYSTEM', `stdin write failed: ${e.message}`) }
+  }
+
+  let buf = ''
+  child.stdout.on('data', (d) => {
+    buf += d.toString()
+    let nl
+    while ((nl = buf.indexOf('\n')) >= 0) {
+      const line = buf.slice(0, nl).trim()
+      buf = buf.slice(nl + 1)
+      if (line) parseStreamLine(line, push)
+    }
+  })
+  child.stderr.on('data', (d) => { const s = d.toString().trim(); if (s) push('SYSTEM', s) })
+  child.on('error', (err) => push('SYSTEM', `Процесна грешка: ${err.message}`))
+  child.on('close', async (code) => {
+    clearInterval(timer)
+    if (buf.trim()) parseStreamLine(buf.trim(), push)
+    await flush()
+    const ok = code === 0
+    await postRunEvents(
+      cfg, runId,
+      [{ kind: 'SYSTEM', text: ok ? '✓ Готово.' : `✗ Процесът приключи с код ${code}.` }],
+      ok ? 'done' : 'error',
+      ok ? 'ok' : `exit ${code}`,
+    )
+    reportCommandResult(cfg, cmd.id, ok ? 'done' : 'error', `exit ${code}`)
+    log(`■ ai_run ${runId} приключи (code ${code})`)
+  })
+}
+
+// Run one turn of an interactive chat session: `claude -p` (resuming the prior
+// Claude session when known) with the user's message on stdin, streaming the
+// reply back to the session console. Long-running + fire-and-forget like ai_run.
+function runAiChat(cfg, cmd, repoPath) {
+  const sessionId = cmd.payload?.sessionId
+  const prompt = cmd.payload?.prompt ?? ''
+  const claudeSessionId = cmd.payload?.claudeSessionId || null
+  const allowCommit = cmd.payload?.allowCommit === true
+  if (!sessionId || !prompt) {
+    reportCommandResult(cfg, cmd.id, 'error', 'invalid ai_chat payload')
+    return
+  }
+
+  const { path: claudePath, shell, found } = findClaude()
+  if (!found) {
+    const msg = `Claude Code CLI не е намерен на този компютър (${cfg.hostname}). Инсталирай го от claude.ai/code и се увери, че „claude" е в PATH, после рестартирай агента.`
+    log(`✗ ai_chat ${sessionId}: claude not found`)
+    postSessionEvents(cfg, sessionId, [{ role: 'SYSTEM', text: `✗ ${msg}` }], 'error')
+    reportCommandResult(cfg, cmd.id, 'error', 'claude not found')
+    return
+  }
+
+  let settingsPath
+  try { settingsPath = ensureAiSessionHookFiles() } catch (e) { log(`✗ ai session hook setup failed: ${e.message}`) }
+
+  const args = [
+    '-p',
+    '--output-format', 'stream-json',
+    '--verbose',
+    '--permission-mode', 'acceptEdits',
+    '--allowedTools', 'Read,Edit,Write,Bash,mcp__gitdone__*',
+    // Block git commit/push unless this repo opted in (per-repo aiAutoCommit).
+    ...(allowCommit ? [] : ['--disallowedTools', 'Bash(git commit *),Bash(git push *)']),
+    ...(claudeSessionId ? ['--resume', claudeSessionId] : []),
+    ...(settingsPath ? ['--settings', settingsPath] : []),
+  ]
+
+  const childEnv = { ...process.env, GITDONE_URL: cfg.url, GITDONE_KEY: cfg.key, GITDONE_SESSION_ID: sessionId }
+
+  // Map console kinds → session transcript roles (model text → ASSISTANT).
+  const roleFor = (kind) => (kind === 'TEXT' ? 'ASSISTANT' : kind)
+  let pending = []
+  let capturedSession = null // Claude's session id, sent (idempotently) for --resume
+  let flushing = false
+  const flush = async () => {
+    if (flushing || pending.length === 0) return
+    flushing = true
+    const batch = pending.map((e) => ({ role: roleFor(e.kind), text: e.text })); pending = []
+    await postSessionEvents(cfg, sessionId, batch, 'running', capturedSession || undefined)
+    flushing = false
+  }
+  const push = (kind, text) => { if (text != null && String(text) !== '') pending.push({ kind, text: String(text) }) }
+  const onInit = (sid) => { if (sid && !claudeSessionId) capturedSession = sid }
+  const timer = setInterval(flush, 800)
+
+  log(`▶ ai_chat ${sessionId} @ ${repoPath} (resume=${claudeSessionId ? 'yes' : 'no'}) via ${claudePath}`)
+
+  let child
+  try {
+    child = spawn(claudePath, args, { cwd: repoPath, shell, windowsHide: true, env: childEnv })
+  } catch (err) {
+    clearInterval(timer)
+    postSessionEvents(cfg, sessionId, [{ role: 'SYSTEM', text: `Грешка при стартиране: ${err.message}` }], 'error')
+    reportCommandResult(cfg, cmd.id, 'error', err.message)
+    return
+  }
+
+  if (child.stdin) {
+    child.stdin.on('error', () => {})
+    try { child.stdin.write(prompt); child.stdin.end() }
+    catch (e) { push('SYSTEM', `stdin write failed: ${e.message}`) }
+  }
+
+  let buf = ''
+  child.stdout.on('data', (d) => {
+    buf += d.toString()
+    let nl
+    while ((nl = buf.indexOf('\n')) >= 0) {
+      const line = buf.slice(0, nl).trim()
+      buf = buf.slice(nl + 1)
+      if (line) parseStreamLine(line, push, onInit)
+    }
+  })
+  child.stderr.on('data', (d) => { const s = d.toString().trim(); if (s) push('SYSTEM', s) })
+  child.on('error', (err) => push('SYSTEM', `Процесна грешка: ${err.message}`))
+  child.on('close', async (code) => {
+    clearInterval(timer)
+    if (buf.trim()) parseStreamLine(buf.trim(), push, onInit)
+    await flush()
+    const ok = code === 0
+    await postSessionEvents(
+      cfg, sessionId,
+      ok ? [] : [{ role: 'SYSTEM', text: `✗ Ходът приключи с код ${code}.` }],
+      ok ? 'idle' : 'error',
+      capturedSession || undefined,
+    )
+    reportCommandResult(cfg, cmd.id, ok ? 'done' : 'error', `exit ${code}`)
+    log(`■ ai_chat ${sessionId} приключи (code ${code})`)
+  })
+}
+
+async function executeCommand(cfg, cmd, repoPath) {
+  // ai_run is long-running + streaming — launch it in the background and return
+  // so the snapshot loop keeps going. It reports its own result on exit.
+  if (cmd.type === 'ai_run') {
+    runAiCommand(cfg, cmd, repoPath)
+    return
+  }
+  // ai_chat — one interactive turn, same fire-and-forget model.
+  if (cmd.type === 'ai_chat') {
+    runAiChat(cfg, cmd, repoPath)
+    return
+  }
+
+  let result = 'ok'
+  let status = 'done'
+  const auth = cfg.auth?.[repoPath] ?? null
+  try {
+    if (cmd.type === 'commit') {
+      const msg = (cmd.payload?.message ?? 'commit').replace(/"/g, '\\"')
+      // When the UI sends a list of selected files, stage ONLY those so the
+      // resulting commit (and the push that follows) contains just the checked
+      // files. No list → stage everything (old behaviour / older UIs).
+      const files = Array.isArray(cmd.payload?.files)
+        ? cmd.payload.files.filter((f) => typeof f === 'string' && f.trim())
+        : []
+      if (files.length) {
+        const quoted = files.map((f) => `"${f.replace(/"/g, '\\"')}"`).join(' ')
+        git(`git add -- ${quoted}`, repoPath)
+      } else {
+        git('git add -A', repoPath)
+      }
+      result = git(`git commit -m "${msg}"`, repoPath) || 'committed'
+    } else if (cmd.type === 'push' || cmd.type === 'pull') {
+      result = pushOrPull(cmd.type, repoPath, auth)
+    } else if (cmd.type === 'discard') {
+      result = discardFile(repoPath, cmd.payload?.file)
+    }
+    log(`✓ ${cmd.type} @ ${repoPath}: ${redact(result, auth?.token)}`)
+  } catch (err) {
+    status = 'error'
+    result = redact(err.message, auth?.token)
+    // Cached token rejected (e.g. rotated/expired on the server) → drop it so
+    // the next snapshot reports hasGithubAuth:false and the server reissues one.
+    if (auth && AUTH_FAIL.test(err.message)) {
+      delete cfg.auth[repoPath]
+      writeConfig(cfg)
+      result += ' — токенът е изчистен, пробвай командата пак'
+    }
+    log(`✗ ${cmd.type} failed @ ${repoPath}: ${result}`)
+  }
+  await reportCommandResult(cfg, cmd.id, status, result)
+}
+
+// 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,
+    agentVersion: AGENT_VERSION,
+    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,
+    // Tells the server whether we already hold a push token for this repo.
+    // Always a boolean → marks us as a token-capable agent.
+    hasGithubAuth: !!cfg.auth?.[repo.path],
+    ...snapshot,
+  })
+  // Server issued a (fresh) push token — cache it on disk so we ask only once.
+  if (data.githubAuth?.token && data.githubAuth?.repo) {
+    cfg.auth = cfg.auth ?? {}
+    cfg.auth[repo.path] = { token: data.githubAuth.token, repo: data.githubAuth.repo }
+    writeConfig(cfg)
+  }
+  for (const cmd of data.commands ?? []) {
+    await executeCommand(cfg, cmd, repo.path)
+  }
+  return snapshot
+}
+
+// ─── Main ────────────────────────────────────────────────────────────────────
+
+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)'}`)
+
+  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}`)
+    }
+  }
+
+  await tick()
+  setInterval(tick, cfg.interval * 1000)
+}
+
+async function main() {
+  const args = parseArgs()
+
+  if (args.doctor) {
+    runDoctor()
+    process.exit(0)
+  }
+
+  if (args.uninstall) {
+    uninstallStartup()
+    process.exit(0)
+  }
+
+  // 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
+  }
+
+  // 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()