gitdone-agent 0.3.1 → 0.5.1

package/index.js

@@ -27,7 +27,7 @@ import { randomUUID } from 'node:crypto'
 // Reported to the server on every sync so the web UI can flag outdated agents.
 // Keep in lockstep with packages/agent/package.json "version" AND
 // src/lib/agentVersion.ts LATEST_AGENT_VERSION.
-const AGENT_VERSION = '0.3.1'
+const AGENT_VERSION = '0.5.1'
 
 const AGENT_DIR = join(homedir(), '.gitdone-agent')
 const CONFIG_PATH = join(AGENT_DIR, 'config.json')
@@ -107,6 +107,25 @@ 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
@@ -342,7 +361,198 @@ 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()
+
+  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__*',
+    '--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})`)
+  })
+}
+
 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

package/package.json

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