gitdone-agent 0.6.3 → 0.6.5

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.3'
+const AGENT_VERSION = '0.6.5'
 
 const AGENT_DIR = join(homedir(), '.gitdone-agent')
 const CONFIG_PATH = join(AGENT_DIR, 'config.json')
@@ -675,6 +675,32 @@ function ensureAiSessionHookFiles() {
   return AI_SESSION_SETTINGS_PATH
 }
 
+// gitdone MCP config for headless sessions (gd-308). We provide it ourselves —
+// with an X-Gitdone-Machine-Id header — so the server can attribute the AI agents
+// this session registers (ai_agent_start) to THIS computer, and the „АИ Агенти"
+// panel shows one sub-panel per machine instead of a single „Локален агент".
+// Used with --strict-mcp-config so the session uses exactly this server. The
+// agent's own key (a gdo_ key) authenticates the MCP endpoint.
+const AI_MCP_CONFIG_PATH = join(AGENT_DIR, 'ai-mcp-config.json')
+
+function ensureAiMcpConfig(cfg) {
+  ensureAgentDir()
+  const config = {
+    mcpServers: {
+      gitdone: {
+        type: 'http',
+        url: `${cfg.url}/api/mcp`,
+        headers: {
+          Authorization: `Bearer ${cfg.key}`,
+          'X-Gitdone-Machine-Id': cfg.machineId,
+        },
+      },
+    },
+  }
+  writeFileSync(AI_MCP_CONFIG_PATH, JSON.stringify(config, null, 2), 'utf8')
+  return AI_MCP_CONFIG_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.
@@ -698,6 +724,8 @@ function runAiCommand(cfg, cmd, repoPath) {
 
   let settingsPath
   try { settingsPath = ensureAiHookFiles() } catch (e) { log(`✗ ai hook setup failed: ${e.message}`) }
+  let mcpConfigPath
+  try { mcpConfigPath = ensureAiMcpConfig(cfg) } catch (e) { log(`✗ ai mcp config 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
@@ -714,6 +742,8 @@ function runAiCommand(cfg, cmd, repoPath) {
     // Block git commit/push unless this repo opted in (per-repo aiAutoCommit).
     ...(allowCommit ? [] : ['--disallowedTools', 'Bash(git commit *),Bash(git push *)']),
     ...(settingsPath ? ['--settings', settingsPath] : []),
+    // Our own gitdone MCP, tagged with this machine (gd-308).
+    ...(mcpConfigPath ? ['--mcp-config', mcpConfigPath, '--strict-mcp-config'] : []),
   ]
 
   // The PostToolUse hook reads these from its env to post raw tool output.
@@ -806,6 +836,24 @@ async function downloadSessionImages(sessionId, urls) {
   return { dir, paths }
 }
 
+// Live chat turns, keyed by sessionId → their spawned `claude` child. Lets an
+// `ai_chat_stop` command find and kill the turn a user asked to interrupt
+// (gd-303). A turn registers itself on spawn and removes itself on close.
+const chatChildren = new Map()
+
+// Kill a process AND its descendants. `claude` spawns its own children (bash,
+// node hooks), so killing just the top pid would orphan them. Windows needs
+// `taskkill /T`; POSIX kills the process group, falling back to a hard kill.
+function killTree(child) {
+  const pid = child?.pid
+  if (!pid) return
+  if (process.platform === 'win32') {
+    try { spawn('taskkill', ['/PID', String(pid), '/T', '/F'], { windowsHide: true }) } catch { /* best-effort */ }
+  } else {
+    try { process.kill(-pid, 'SIGKILL') } catch { try { child.kill('SIGKILL') } catch { /* gone */ } }
+  }
+}
+
 // 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.
@@ -832,6 +880,8 @@ async function runAiChat(cfg, cmd, repoPath) {
 
   let settingsPath
   try { settingsPath = ensureAiSessionHookFiles() } catch (e) { log(`✗ ai session hook setup failed: ${e.message}`) }
+  let mcpConfigPath
+  try { mcpConfigPath = ensureAiMcpConfig(cfg) } catch (e) { log(`✗ ai mcp config setup failed: ${e.message}`) }
 
   const args = [
     '-p',
@@ -846,6 +896,9 @@ async function runAiChat(cfg, cmd, repoPath) {
     ...(allowCommit ? [] : ['--disallowedTools', 'Bash(git commit *),Bash(git push *)']),
     ...(claudeSessionId ? ['--resume', claudeSessionId] : []),
     ...(settingsPath ? ['--settings', settingsPath] : []),
+    // Our own gitdone MCP, tagged with this machine so ai_agent_start attributes
+    // the agents to this computer (gd-308). --strict = use exactly this server.
+    ...(mcpConfigPath ? ['--mcp-config', mcpConfigPath, '--strict-mcp-config'] : []),
   ]
 
   const childEnv = { ...process.env, GITDONE_URL: cfg.url, GITDONE_KEY: cfg.key, GITDONE_SESSION_ID: sessionId }
@@ -912,6 +965,9 @@ async function runAiChat(cfg, cmd, repoPath) {
     return
   }
 
+  // Track this turn so an `ai_chat_stop` command can find and kill it (gd-303).
+  chatChildren.set(sessionId, child)
+
   if (child.stdin) {
     child.stdin.on('error', () => {})
     try { child.stdin.write(fullPrompt); child.stdin.end() }
@@ -932,10 +988,23 @@ async function runAiChat(cfg, cmd, repoPath) {
   child.on('error', (err) => push('SYSTEM', `Процесна грешка: ${err.message}`))
   child.on('close', async (code) => {
     clearInterval(timer)
+    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
     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.
+    if (child.__stopped) {
+      await postSessionEvents(
+        cfg, sessionId,
+        [{ role: 'SYSTEM', text: '⏹ Спряно. Напиши още нещо, за да продължим разговора.' }],
+        'idle', capturedSession || undefined, '',
+      )
+      reportCommandResult(cfg, cmd.id, 'done', 'stopped by user')
+      log(`⏹ ai_chat ${sessionId} спряно от потребителя`)
+      return
+    }
     const ok = code === 0
     await postSessionEvents(
       cfg, sessionId,
@@ -949,6 +1018,24 @@ async function runAiChat(cfg, cmd, repoPath) {
   })
 }
 
+// ai_chat_stop — interrupt a running chat turn the user asked to stop (gd-303).
+// Kills the tracked child (its `close` handler then posts the "⏹ Спряно" note and
+// flips the session to idle). If nothing is running, just idles the session so
+// the console unlocks.
+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, '')
+    reportCommandResult(cfg, cmd.id, 'done', 'no active turn')
+    return
+  }
+  child.__stopped = true
+  killTree(child)
+  log(`⏹ ai_chat_stop ${sessionId} — kill signalled`)
+  reportCommandResult(cfg, cmd.id, 'done', 'stop signalled')
+}
+
 // deploy — run the project's deploy script (scripts/deploy.sh) in the repo.
 // Long-running (git pull + npm build + service restart), so we spawn it detached
 // from the poll loop and report the result on exit. The agent is its OWN process
@@ -993,6 +1080,12 @@ async function executeCommand(cfg, cmd, repoPath) {
     runAiChat(cfg, cmd, repoPath)
     return
   }
+  // ai_chat_stop — interrupt the running turn for a session (gd-303). Handled
+  // inline (it just signals a kill) and reports its own result.
+  if (cmd.type === 'ai_chat_stop') {
+    stopAiChat(cfg, cmd)
+    return
+  }
   // deploy — run the repo's deploy script. Long-running (pull + build + service
   // restart), so it's launched in the background and reports its own result on
   // exit, same as ai_run.

package/package.json

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