gitdone-agent 0.2.1 → 0.5.0

package/index.js

@@ -24,6 +24,11 @@ import { randomUUID } from 'node:crypto'
 // 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.0'
+
 const AGENT_DIR = join(homedir(), '.gitdone-agent')
 const CONFIG_PATH = join(AGENT_DIR, 'config.json')
 const STABLE_AGENT = join(AGENT_DIR, 'agent.mjs')
@@ -102,10 +107,52 @@ function getNodePath() {
   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.
@@ -171,6 +218,49 @@ function git(cmd, cwd) {
   }
 }
 
+// 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
@@ -271,23 +361,208 @@ 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}`))
+}
+
+// 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) {
+  let ev
+  try { ev = JSON.parse(line) } catch { return }
+  if (ev.type === 'system') {
+    if (ev.subtype === 'init') push('SYSTEM', `Сесия стартирана${ev.model ? ` (${ev.model})` : ''}.`)
+    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
+}
+
+// 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 ?? ''
+  if (!runId || !prompt) {
+    reportCommandResult(cfg, cmd.id, 'error', 'invalid ai_run payload')
+    return
+  }
+
+  const { path: claudePath, shell } = findClaude()
+  // shell:true (claude.cmd) can't carry raw newlines on the command line.
+  const promptArg = shell ? prompt.replace(/\r?\n/g, '  ') : prompt
+
+  let settingsPath
+  try { settingsPath = ensureAiHookFiles() } catch (e) { log(`✗ ai hook setup failed: ${e.message}`) }
+
+  const args = [
+    '-p', promptArg,
+    '--output-format', 'stream-json',
+    '--verbose',
+    '--permission-mode', 'acceptEdits',
+    '--allowedTools', 'Read,Edit,Write,Bash,mcp__gitdone__*',
+    '--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
+  }
+
+  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})`)
+  })
+}
+
 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
+  }
+
   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') {
-      result = git('git push', repoPath) || 'pushed'
-    } else if (cmd.type === 'pull') {
-      result = git('git pull', repoPath) || 'pulled'
+    } else if (cmd.type === 'push' || cmd.type === 'pull') {
+      result = pushOrPull(cmd.type, repoPath, auth)
     }
-    log(`✓ ${cmd.type} @ ${repoPath}: ${result}`)
+    log(`✓ ${cmd.type} @ ${repoPath}: ${redact(result, auth?.token)}`)
   } catch (err) {
     status = 'error'
-    result = err.message
+    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)
@@ -298,6 +573,7 @@ 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,
   })
@@ -311,8 +587,17 @@ async function pushSnapshot(cfg, repo) {
     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)
   }

package/package.json

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