gitdone-agent 0.8.4 → 0.8.6

package/index.js

@@ -16,7 +16,7 @@ import {
   mkdirSync, copyFileSync, appendFileSync, readdirSync, rmSync, statSync,
   openSync, writeSync, fsyncSync, closeSync, readSync,
 } from 'node:fs'
-import { resolve, join } from 'node:path'
+import { resolve, join, extname } from 'node:path'
 import { homedir, hostname, tmpdir } from 'node:os'
 import { randomUUID, createHash } from 'node:crypto'
 
@@ -27,9 +27,9 @@ import { randomUUID, createHash } from 'node:crypto'
 // 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.8.4'
+// Keep in lockstep with packages/agent/package.json. The server's offline
+// fallback is bumped only after this release has actually reached npm.
+const AGENT_VERSION = '0.8.6'
 
 const AGENT_DIR = join(homedir(), '.gitdone-agent')
 const CONFIG_PATH = join(AGENT_DIR, 'config.json')
@@ -999,19 +999,32 @@ function scanRepos(roots, maxDepth = 5) {
 
 // ─── Server sync + commands ─────────────────────────────────────────────────────
 
+// Keep the deadline below the server-side session stall window. Without a
+// deadline, a proxy/network connection that never completes can block the
+// event-posting loop forever, so no heartbeat reaches the server and the
+// watchdog incorrectly declares a live AI turn stalled.
+const API_REQUEST_TIMEOUT_MS = 10_000
+
 async function apiOnce(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(() => '')
-    const err = new Error(`HTTP ${res.status} ${path}: ${text}`)
-    err.status = res.status
-    throw err
+  const controller = new AbortController()
+  const timer = setTimeout(() => controller.abort(), API_REQUEST_TIMEOUT_MS)
+  try {
+    const res = await fetch(`${cfg.url}${path}`, {
+      method: 'POST',
+      headers: { Authorization: `Bearer ${cfg.key}`, 'Content-Type': 'application/json' },
+      body: JSON.stringify(body),
+      signal: controller.signal,
+    })
+    if (!res.ok) {
+      const text = await res.text().catch(() => '')
+      const err = new Error(`HTTP ${res.status} ${path}: ${text}`)
+      err.status = res.status
+      throw err
+    }
+    return res.json().catch(() => ({}))
+  } finally {
+    clearTimeout(timer)
   }
-  return res.json().catch(() => ({}))
 }
 
 // gd-514: statuses where the app server demonstrably never processed the body,
@@ -1840,39 +1853,99 @@ function runAiCommand(cfg, cmd, repoPath) {
   })
 }
 
-// Download the images attached to a chat turn to a per-session temp dir and
-// return their local paths. `claude -p` can't take image URLs on stdin, so we
-// fetch them locally and point Claude at the files (its Read tool renders
-// images). Best-effort: a failed download is skipped, not fatal.
-async function downloadSessionImages(sessionId, urls) {
+const ATTACHMENT_EXTENSIONS = new Map([
+  ['application/pdf', '.pdf'],
+  ['application/json', '.json'],
+  ['application/ld+json', '.json'],
+  ['application/rtf', '.rtf'],
+  ['application/msword', '.doc'],
+  ['application/vnd.ms-excel', '.xls'],
+  ['application/vnd.ms-powerpoint', '.ppt'],
+  ['application/vnd.openxmlformats-officedocument.wordprocessingml.document', '.docx'],
+  ['application/vnd.openxmlformats-officedocument.spreadsheetml.sheet', '.xlsx'],
+  ['application/vnd.openxmlformats-officedocument.presentationml.presentation', '.pptx'],
+  ['application/vnd.oasis.opendocument.text', '.odt'],
+  ['application/vnd.oasis.opendocument.spreadsheet', '.ods'],
+  ['application/epub+zip', '.epub'],
+  ['application/zip', '.zip'],
+  ['application/x-7z-compressed', '.7z'],
+  ['application/gzip', '.gz'],
+  ['text/plain', '.txt'],
+  ['text/csv', '.csv'],
+  ['text/markdown', '.md'],
+  ['text/html', '.html'],
+  ['text/xml', '.xml'],
+  ['application/xml', '.xml'],
+  ['application/yaml', '.yaml'],
+  ['text/yaml', '.yaml'],
+  ['image/png', '.png'],
+  ['image/jpeg', '.jpg'],
+  ['image/gif', '.gif'],
+  ['image/webp', '.webp'],
+  ['image/bmp', '.bmp'],
+  ['image/svg+xml', '.svg'],
+])
+
+function safeAttachmentName(value, contentType, index) {
+  let name = typeof value === 'string' ? value.trim() : ''
+  try { name = decodeURIComponent(name) } catch { /* keep the original */ }
+  name = name.replace(/\\/g, '/').split('/').pop()
+  name = name
+    .replace(/[<>:"/\\|?*\x00-\x1f]/g, '-')
+    .replace(/^\.+/, '')
+    .trim()
+    .slice(0, 140)
+  if (!name) name = `file-${index + 1}`
+  if (!extname(name)) name += ATTACHMENT_EXTENSIONS.get(contentType?.split(';', 1)[0].toLowerCase()) ?? '.bin'
+  return `${index + 1}-${name}`
+}
+
+function attachmentUrlInfo(rawUrl) {
+  try {
+    const parsed = new URL(rawUrl)
+    const name = new URLSearchParams(parsed.hash.slice(1)).get('gd-name') || ''
+    parsed.hash = ''
+    return { downloadUrl: parsed.toString(), name }
+  } catch {
+    return { downloadUrl: rawUrl.split('#', 1)[0], name: '' }
+  }
+}
+
+// Download files attached to a chat turn to a per-session temp dir and return
+// their local paths. Neither AI CLI consumes remote attachment URLs directly,
+// so the prompt points it at these files. Best-effort: one failed download does
+// not prevent the remaining attachments or message from reaching the AI.
+async function downloadSessionAttachments(sessionId, urls) {
   const dir = join(tmpdir(), `gitdone-ai-${sessionId}`)
   mkdirSync(dir, { recursive: true })
   const paths = []
   for (let i = 0; i < urls.length; i++) {
     try {
-      const res = await fetch(urls[i])
-      if (!res.ok) { log(`✗ image download HTTP ${res.status}: ${urls[i]}`); continue }
+      const info = attachmentUrlInfo(urls[i])
+      const res = await fetch(info.downloadUrl)
+      if (!res.ok) { log(`✗ attachment download HTTP ${res.status}: ${info.downloadUrl}`); continue }
       const buf = Buffer.from(await res.arrayBuffer())
-      const m = /\.(png|jpe?g|gif|webp|bmp)(?:\?|$)/i.exec(urls[i])
-      const ext = m ? m[1].toLowerCase() : 'png'
-      const file = join(dir, `image-${i + 1}.${ext}`)
+      let sourceName = info.name
+      if (!sourceName) {
+        try { sourceName = new URL(info.downloadUrl).pathname.split('/').pop() || '' } catch { /* use fallback */ }
+      }
+      const file = join(dir, safeAttachmentName(sourceName, res.headers.get('content-type'), i))
       writeFileSync(file, buf)
       paths.push(file)
     } catch (e) {
-      log(`✗ image download failed (${urls[i]}): ${e.message}`)
+      log(`✗ attachment download failed (${urls[i]}): ${e.message}`)
     }
   }
   return { dir, paths }
 }
 
-// Point the AI at the images the user attached: neither CLI renders an image URL
-// off stdin, so they're downloaded locally and referenced by path for its Read
-// tool. Returns the prompt unchanged when nothing was attached (or every
-// download failed), so an image-only turn still says something.
-function withImageNote(prompt, paths) {
+// Point the AI at every locally downloaded attachment. The exact analysis tool
+// depends on the file type (Read for text/images/PDFs, or another available
+// local tool for structured/binary documents).
+function withAttachmentNote(prompt, paths) {
   if (!paths || paths.length === 0) return prompt
   const list = paths.map((p) => `- ${p}`).join('\n')
-  const note = `Потребителят прикачи ${paths.length} изображени${paths.length === 1 ? 'е' : 'я'}. Прегледай ги с Read tool от следните локални пътища:\n${list}`
+  const note = `Потребителят прикачи ${paths.length} файл${paths.length === 1 ? '' : 'а'}. Прегледай и анализирай прикачванията с наличните ти инструменти. Локални пътища:\n${list}`
   return prompt ? `${prompt}\n\n[${note}]` : `[${note}]`
 }
 
@@ -2213,14 +2286,15 @@ function runCodexChatTurn(cfg, cmd, repoPath, opts) {
 async function runAiChat(cfg, cmd, repoPath) {
   const sessionId = cmd.payload?.sessionId
   const prompt = cmd.payload?.prompt ?? ''
-  const images = Array.isArray(cmd.payload?.images) ? cmd.payload.images.filter((u) => typeof u === 'string' && u) : []
+  const attachmentPayload = Array.isArray(cmd.payload?.attachments) ? cmd.payload.attachments : cmd.payload?.images
+  const attachments = Array.isArray(attachmentPayload) ? attachmentPayload.filter((u) => typeof u === 'string' && u) : []
   const claudeSessionId = cmd.payload?.claudeSessionId || null
   const allowCommit = cmd.payload?.allowCommit === true
   const model = aiModelArg(cmd.payload?.model)
   const effort = aiEffortArg(cmd.payload?.effort)
   const provider = aiProviderArg(cmd.payload?.provider)
   // A turn may be text-only, image-only, or both — but needs at least one.
-  if (!sessionId || (!prompt && images.length === 0)) {
+  if (!sessionId || (!prompt && attachments.length === 0)) {
     reportCommandResult(cfg, cmd.id, 'error', 'invalid ai_chat payload')
     return
   }
@@ -2242,13 +2316,13 @@ async function runAiChat(cfg, cmd, repoPath) {
   }
 
   // Codex (gd-491): one process per turn, prompt on stdin at spawn — so the
-  // images have to be on disk BEFORE we start it, unlike the Claude path where
+  // Attachments have to be on disk BEFORE we start it, unlike the Claude path where
   // the message is written into an already-running process.
   if (provider === 'codex') {
-    const dl = images.length > 0 ? await downloadSessionImages(sessionId, images) : null
+    const dl = attachments.length > 0 ? await downloadSessionAttachments(sessionId, attachments) : null
     runCodexChatTurn(cfg, cmd, repoPath, {
       sessionId,
-      prompt: withImageNote(prompt, dl?.paths ?? []),
+      prompt: withAttachmentNote(prompt, dl?.paths ?? []),
       imgDir: dl?.dir ?? null,
       resumeId: claudeSessionId,
       model,
@@ -2281,14 +2355,14 @@ async function runAiChat(cfg, cmd, repoPath) {
     log(`▶ ai_chat proc за ${sessionId} @ ${repoPath} (resume=${claudeSessionId ? 'yes' : 'no'}) via ${claudePath}`)
   }
 
-  // Fetch any attached images locally and fold their paths into the prompt so
-  // the AI reads them with its Read tool (URLs on stdin don't render).
+  // Fetch attachments locally and fold their paths into the prompt; remote URLs
+  // on stdin are not enough for either CLI to inspect the file contents.
   let imgDir = null
   let fullPrompt = prompt
-  if (images.length > 0) {
-    const dl = await downloadSessionImages(sessionId, images)
+  if (attachments.length > 0) {
+    const dl = await downloadSessionAttachments(sessionId, attachments)
     imgDir = dl.dir
-    fullPrompt = withImageNote(prompt, dl.paths)
+    fullPrompt = withAttachmentNote(prompt, dl.paths)
   }
 
   // Open the turn BEFORE writing the message, so even the earliest output
@@ -2315,7 +2389,7 @@ async function runAiChat(cfg, cmd, repoPath) {
     await finishChatTurn(cfg, entry, { ok: false, code: `stdin: ${err.message}` })
     return
   }
-  log(`▶ ai_chat ход ${sessionId} (images=${images.length})`)
+  log(`▶ ai_chat ход ${sessionId} (attachments=${attachments.length})`)
 }
 
 // ai_chat_stop — interrupt a running chat turn the user asked to stop (gd-303).

package/package.json

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