gitdone-agent 0.6.15 → 0.6.17

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.6.15'
+const AGENT_VERSION = '0.6.17'
 
 const AGENT_DIR = join(homedir(), '.gitdone-agent')
 const CONFIG_PATH = join(AGENT_DIR, 'config.json')
@@ -186,10 +186,52 @@ function findClaude() {
   return { path: 'claude', shell: true, found: false }
 }
 
+// ─── Single instance (gd-407) ─────────────────────────────────────────────────
+// Two agents on one machine (an old one surviving an update, or a manual
+// `npx gitdone-agent` next to the autostarted one) flap the machine's online
+// state and race dispatches. The running agent claims the machine via a pid
+// file; a newcomer that finds a LIVE agent behind it exits with EXIT_DUPLICATE,
+// which the supervisor treats as "do not restart me". First one wins.
+// 86 is outside node's own exit-code range (1-13) — keep in lockstep with the
+// run-agent.cmd template in installStartup().
+const EXIT_DUPLICATE = 86
+const PID_PATH = join(AGENT_DIR, 'agent.pid')
+
+// Command line of a live process, '' when unreadable (dead process, no rights).
+function processCmdline(pid) {
+  try {
+    if (process.platform === 'win32') {
+      return execSync(
+        `powershell -NoProfile -NonInteractive -Command "(Get-CimInstance Win32_Process -Filter 'ProcessId=${pid}').CommandLine"`,
+        { encoding: 'utf8' },
+      ).trim()
+    }
+    return execSync(`ps -p ${pid} -o command=`, { encoding: 'utf8' }).trim()
+  } catch { return '' }
+}
+
+function ensureSingleInstance() {
+  try {
+    const pid = parseInt(readFileSync(PID_PATH, 'utf8'), 10)
+    if (pid && pid !== process.pid) {
+      process.kill(pid, 0) // throws when that pid is no longer alive
+      // PID reuse guard: only defer to a process that really looks like an
+      // agent (stable copy agent.mjs, or any gitdone-agent npx/global run).
+      if (/gitdone-agent|agent\.mjs/i.test(processCmdline(pid))) {
+        log(`✗ друг gitdone-agent вече върви (PID ${pid}) — този процес излиза, за да няма два агента на машината`)
+        process.exit(EXIT_DUPLICATE)
+      }
+    }
+  } catch { /* no/stale pid file → the machine is free, we take over */ }
+  try { ensureAgentDir(); writeFileSync(PID_PATH, String(process.pid)) } catch { /* best-effort */ }
+}
+
 // 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.
+// Windows re-login. Targets node processes that look like a gitdone agent —
+// both the stable copy in ~/.gitdone-agent AND one running straight from the
+// npx cache / global install (its command line contains "gitdone-agent") —
+// excluding ourselves and our parent (the npx wrapper that launched us).
+// Best-effort; failures are non-fatal.
 function stopRunningAgents() {
   // Kill the supervisor loops (cmd.exe running run-agent.cmd) FIRST, then the
   // agents — the other order lets a still-alive supervisor immediately respawn
@@ -200,7 +242,7 @@ function stopRunningAgents() {
     "  Where-Object { $_.CommandLine -like '*run-agent.cmd*' } |",
     '  ForEach-Object { Stop-Process -Id $_.ProcessId -Force }',
     "Get-CimInstance Win32_Process -Filter \"Name='node.exe'\" |",
-    `  Where-Object { $_.CommandLine -like '*.gitdone-agent*' -and $_.ProcessId -ne ${process.pid} } |`,
+    `  Where-Object { ($_.CommandLine -like '*gitdone-agent*' -or $_.CommandLine -like '*agent.mjs*') -and $_.ProcessId -ne ${process.pid} -and $_.ProcessId -ne ${process.ppid || 0} } |`,
     '  ForEach-Object { Stop-Process -Id $_.ProcessId -Force }',
   ].join('\n')
   try {
@@ -254,12 +296,16 @@ function installStartup() {
     `"%NODE%" "${agentPath}" 2>> "${crashLog}"`,
     'set CODE=%errorlevel%',
     `echo [%date% %time%] agent exited (code %CODE%) - restart in 10s >> "${crashLog}"`,
+    'if "%CODE%"=="86" goto duplicate',
     'if "%CODE%"=="-1073741502" goto dead',
     'if "%CODE%"=="-1073741515" goto dead',
     'ping -n 11 127.0.0.1 >nul 2>nul || goto dead',
     'goto loop',
     ':dead',
     `echo [%date% %time%] node cannot start (code %CODE%) - supervisor giving up until next login >> "${crashLog}"`,
+    'exit /b',
+    ':duplicate',
+    `echo [%date% %time%] another agent already runs this machine (code 86) - this supervisor exits >> "${crashLog}"`,
   ].join('\r\n')
   const cmdPath = join(AGENT_DIR, 'run-agent.cmd')
   writeFileSync(cmdPath, cmd, 'utf8')
@@ -713,20 +759,24 @@ async function reportCommandResult(cfg, id, status, result) {
 
 // Post a batch of console events (and optional lifecycle status) for an AiRun.
 // `usage` is sent once on the final (done/error) post so the server can record
-// how many tokens the run cost.
-async function postRunEvents(cfg, runId, events, status, result, usage) {
+// how many tokens the run cost. `streamingText` / `activityText` (gd-419) carry
+// the live "being typed" preview and the latest thinking snippet — explicit ''
+// clears them; `undefined` leaves them untouched.
+async function postRunEvents(cfg, runId, events, status, result, usage, streamingText, activityText) {
   await api(cfg, '/api/v1/agent/ai-run/events', {
     runId,
     events,
     ...(status ? { status } : {}),
     ...(result !== undefined ? { result } : {}),
     ...(usage ? { usage } : {}),
+    ...(streamingText !== undefined ? { streamingText } : {}),
+    ...(activityText !== undefined ? { activityText } : {}),
   }).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, streamingText) {
+async function postSessionEvents(cfg, sessionId, events, status, claudeSessionId, streamingText, activityText) {
   await api(cfg, '/api/v1/agent/ai-session/events', {
     sessionId,
     events,
@@ -734,6 +784,8 @@ async function postSessionEvents(cfg, sessionId, events, status, claudeSessionId
     ...(claudeSessionId ? { claudeSessionId } : {}),
     // Explicit '' clears the live preview; `undefined` leaves it untouched.
     ...(streamingText !== undefined ? { streamingText } : {}),
+    // Same semantics for the live thinking snippet (gd-419).
+    ...(activityText !== undefined ? { activityText } : {}),
   }).catch((e) => log(`✗ ai-session events post failed: ${e.message}`))
 }
 
@@ -764,13 +816,18 @@ function parseStreamLine(line, push, onInit, onDelta, onMeta) {
     }
     return
   }
-  // Partial-message stream: only the model's visible text deltas feed the live
-  // preview. Tool-input JSON deltas and thinking deltas are ignored here — the
-  // full block still arrives as a normal `assistant` event below.
+  // Partial-message stream: the model's visible text deltas feed the live
+  // preview, its thinking deltas feed the gray "какво прави АИ-то" snippet
+  // (gd-419). Tool-input JSON deltas stay ignored — the full block still
+  // arrives as a normal `assistant` event below.
   if (ev.type === 'stream_event' && typeof onDelta === 'function') {
     const e = ev.event
-    if (e?.type === 'content_block_delta' && e.delta?.type === 'text_delta' && e.delta.text) {
-      onDelta(e.delta.text)
+    if (e?.type === 'content_block_delta') {
+      if (e.delta?.type === 'text_delta' && e.delta.text) onDelta(e.delta.text, 'text')
+      else if (e.delta?.type === 'thinking_delta' && e.delta.thinking) onDelta(e.delta.thinking, 'thinking')
+    } else if (e?.type === 'content_block_start' && e.content_block?.type === 'thinking') {
+      // A fresh thought begins — reset the snippet so old and new don't blend.
+      onDelta('', 'thinking-start')
     }
     return
   }
@@ -997,6 +1054,9 @@ function runAiCommand(cfg, cmd, repoPath) {
     '-p',
     '--output-format', 'stream-json',
     '--verbose',
+    // Stream text token-by-token + thinking deltas so the terminal shows the
+    // reply being written live, ред по ред, not in whole-block batches (gd-419).
+    '--include-partial-messages',
     // Model chosen in gitDone (project default / task); omitted → machine default (gd-354).
     ...(model ? ['--model', model] : []),
     '--permission-mode', 'acceptEdits',
@@ -1014,15 +1074,39 @@ function runAiCommand(cfg, cmd, repoPath) {
   // Batch events on a timer so we don't hammer the server per token/line.
   let pending = []
   let flushing = false
+  let liveText = '' // in-progress text of the current assistant block (live preview)
+  let sentLive = '' // last streamingText we posted — only push on change
+  let liveActivity = '' // latest thinking snippet — "какво прави АИ-то" (gd-419)
+  let sentActivity = ''
   const flush = async () => {
-    if (flushing || pending.length === 0) return
+    if (flushing) return
+    const liveChanged = liveText !== sentLive
+    const activityChanged = liveActivity !== sentActivity
+    if (pending.length === 0 && !liveChanged && !activityChanged) return
     flushing = true
     const batch = pending; pending = []
-    await postRunEvents(cfg, runId, batch)
+    const streamingText = liveChanged ? liveText : undefined
+    const activityText = activityChanged ? liveActivity : undefined
+    sentLive = liveText
+    sentActivity = liveActivity
+    await postRunEvents(cfg, runId, batch, undefined, undefined, undefined, streamingText, activityText)
     flushing = false
   }
-  const push = (kind, text) => { if (text != null && String(text) !== '') pending.push({ kind, text: String(text) }) }
-  const timer = setInterval(flush, 800)
+  const push = (kind, text) => {
+    if (text == null || String(text) === '') return
+    // A completed text block becomes a real event — drop its live preview; any
+    // new event also supersedes the last thinking snippet.
+    if (kind === 'TEXT') liveText = ''
+    liveActivity = ''
+    pending.push({ kind, text: String(text) })
+  }
+  const onDelta = (chunk, type) => {
+    if (type === 'thinking-start') { liveActivity = ''; return }
+    // Keep only the tail — the freshest thought is what the gray line shows.
+    if (type === 'thinking') { liveActivity = (liveActivity + chunk).slice(-4000); return }
+    liveText += chunk
+  }
+  const timer = setInterval(flush, 500)
 
   // Accumulate model + token usage across the stream (model from init, usage
   // from the final result event) to report once on exit (gd-334).
@@ -1061,14 +1145,16 @@ function runAiCommand(cfg, cmd, repoPath) {
     while ((nl = buf.indexOf('\n')) >= 0) {
       const line = buf.slice(0, nl).trim()
       buf = buf.slice(nl + 1)
-      if (line) parseStreamLine(line, push, undefined, undefined, onMeta)
+      if (line) parseStreamLine(line, push, undefined, onDelta, onMeta)
     }
   })
   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, undefined, undefined, onMeta)
+    if (buf.trim()) parseStreamLine(buf.trim(), push, undefined, onDelta, onMeta)
+    liveText = '' // run is over — drop any lingering live preview / thought
+    liveActivity = ''
     await flush()
     const ok = code === 0
     // Build the usage payload + a console summary line from what we saw.
@@ -1192,32 +1278,44 @@ async function runAiChat(cfg, cmd, repoPath) {
   let flushing = false
   let liveText = '' // in-progress text of the current assistant block (live preview)
   let sentLive = '' // last streamingText we posted — so we only push on change
+  let liveActivity = '' // latest thinking snippet — "какво прави АИ-то" (gd-419)
+  let sentActivity = ''
   let lastPostAt = 0 // Date.now() of the last post, for the keep-alive heartbeat
   const flush = async () => {
     if (flushing) return
     const hasEvents = pending.length > 0
     const liveChanged = liveText !== sentLive
+    const activityChanged = liveActivity !== sentActivity
     // Heartbeat: with nothing new for a while, still post (bumps lastActivityAt)
     // so the console shows honest "still working" and can spot a real stall.
-    const heartbeat = !hasEvents && !liveChanged && Date.now() - lastPostAt > 2500
-    if (!hasEvents && !liveChanged && !heartbeat) return
+    const heartbeat = !hasEvents && !liveChanged && !activityChanged && Date.now() - lastPostAt > 2500
+    if (!hasEvents && !liveChanged && !activityChanged && !heartbeat) return
     flushing = true
     const batch = pending.map((e) => ({ role: roleFor(e.kind), text: e.text })); pending = []
     const streamingText = liveChanged ? liveText : undefined
+    const activityText = activityChanged ? liveActivity : undefined
     sentLive = liveText
-    await postSessionEvents(cfg, sessionId, batch, 'running', capturedSession || undefined, streamingText)
+    sentActivity = liveActivity
+    await postSessionEvents(cfg, sessionId, batch, 'running', capturedSession || undefined, streamingText, activityText)
     lastPostAt = Date.now()
     flushing = false
   }
   const push = (kind, text) => {
     if (text == null || String(text) === '') return
     // A completed text block becomes a real event — drop its live preview so the
-    // finalised bubble and the cleared preview swap in on the same flush.
+    // finalised bubble and the cleared preview swap in on the same flush. Any
+    // new event also supersedes the last thinking snippet (gd-419).
     if (kind === 'TEXT') liveText = ''
+    liveActivity = ''
     pending.push({ kind, text: String(text) })
   }
   const onInit = (sid) => { if (sid && !claudeSessionId) capturedSession = sid }
-  const onDelta = (chunk) => { liveText += chunk }
+  const onDelta = (chunk, type) => {
+    if (type === 'thinking-start') { liveActivity = ''; return }
+    // Keep only the tail — the freshest thought is what the gray line shows.
+    if (type === 'thinking') { liveActivity = (liveActivity + chunk).slice(-4000); return }
+    liveText += chunk
+  }
   const timer = setInterval(flush, 500)
 
   // Fetch any attached images locally and fold their paths into the prompt so
@@ -1273,7 +1371,8 @@ async function runAiChat(cfg, cmd, repoPath) {
     chatChildren.delete(sessionId)
     if (imgDir) { try { rmSync(imgDir, { recursive: true, force: true }) } catch { /* best-effort */ } }
     if (buf.trim()) parseStreamLine(buf.trim(), push, onInit, onDelta)
-    liveText = '' // turn is over — drop any lingering live preview
+    liveText = '' // turn is over — drop any lingering live preview / thought
+    liveActivity = ''
     await flush()
     // User-initiated stop (gd-303): land on idle with a friendly note, not an
     // "exited with code N" error — the kill's non-zero code is expected here.
@@ -1281,7 +1380,7 @@ async function runAiChat(cfg, cmd, repoPath) {
       await postSessionEvents(
         cfg, sessionId,
         [{ role: 'SYSTEM', text: '⏹ Спряно. Напиши още нещо, за да продължим разговора.' }],
-        'idle', capturedSession || undefined, '',
+        'idle', capturedSession || undefined, '', '',
       )
       reportCommandResult(cfg, cmd.id, 'done', 'stopped by user')
       log(`⏹ ai_chat ${sessionId} спряно от потребителя`)
@@ -1294,6 +1393,7 @@ async function runAiChat(cfg, cmd, repoPath) {
       ok ? 'idle' : 'error',
       capturedSession || undefined,
       '', // clear the live preview on the terminal post
+      '', // …and the thinking snippet (gd-419)
     )
     reportCommandResult(cfg, cmd.id, ok ? 'done' : 'error', `exit ${code}`)
     log(`■ ai_chat ${sessionId} приключи (code ${code})`)
@@ -1308,7 +1408,7 @@ function stopAiChat(cfg, cmd) {
   const sessionId = cmd.payload?.sessionId
   const child = sessionId ? chatChildren.get(sessionId) : null
   if (!child) {
-    if (sessionId) postSessionEvents(cfg, sessionId, [], 'idle', undefined, '')
+    if (sessionId) postSessionEvents(cfg, sessionId, [], 'idle', undefined, '', '')
     reportCommandResult(cfg, cmd.id, 'done', 'no active turn')
     return
   }
@@ -1603,6 +1703,7 @@ async function streamCommands(cfg) {
 // ─── Main ────────────────────────────────────────────────────────────────────
 
 async function runLoop(cfg) {
+  ensureSingleInstance()
   log(`gitdone-agent started — machine: ${cfg.hostname}, server: ${cfg.url}, interval: ${cfg.interval}s`)
   log(`  roots: ${cfg.roots.join(', ') || '(none — add one with --root)'}`)
 

package/package.json

@@ -1,15 +1,15 @@
-{
-    "name":  "gitdone-agent",
-    "version":  "0.6.15",
-    "description":  "Local git agent for gitdone — watches a local repo and sends snapshots to gitdone.eu",
-    "type":  "module",
-    "bin":  {
-                "gitdone-agent":  "index.js"
-            },
-    "scripts":  {
-                    "start":  "node index.js"
-                },
-    "engines":  {
-                    "node":  "\u003e=18"
-                }
-}
+{
+    "name":  "gitdone-agent",
+    "version":  "0.6.17",
+    "description":  "Local git agent for gitdone — watches a local repo and sends snapshots to gitdone.eu",
+    "type":  "module",
+    "bin":  {
+                "gitdone-agent":  "index.js"
+            },
+    "scripts":  {
+                    "start":  "node index.js"
+                },
+    "engines":  {
+                    "node":  "\u003e=18"
+                }
+}