gitdone-agent 0.8.5 → 0.8.7

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.5'
+// 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.7'
 
 const AGENT_DIR = join(homedir(), '.gitdone-agent')
 const CONFIG_PATH = join(AGENT_DIR, 'config.json')
@@ -547,6 +547,77 @@ function uninstallStartup() {
 
 // ─── Doctor ────────────────────────────────────────────────────────────────────
 
+// Each sync heartbeat returns the version, URL and SHA-256 of the exact agent
+// script deployed on the server. A supervised stable install downloads it,
+// verifies both checksum and embedded version, atomically replaces itself, and
+// exits; run-agent.cmd then starts the new version within about ten seconds.
+function compareVersions(a, b) {
+  const pa = String(a).split('.').map((n) => parseInt(n, 10) || 0)
+  const pb = String(b).split('.').map((n) => parseInt(n, 10) || 0)
+  const len = Math.max(pa.length, pb.length)
+  for (let i = 0; i < len; i++) {
+    const difference = (pa[i] ?? 0) - (pb[i] ?? 0)
+    if (difference !== 0) return difference > 0 ? 1 : -1
+  }
+  return 0
+}
+
+const UPDATE_RETRY_MS = 60 * 60 * 1000
+let updateInFlight = false
+let lastUpdateAttempt = { version: null, at: 0 }
+
+async function selfUpdate(cfg, latestVersion, downloadUrl, expectedSha256) {
+  if (updateInFlight || !latestVersion || !downloadUrl) return
+  if (compareVersions(latestVersion, AGENT_VERSION) <= 0) return
+  if (lastUpdateAttempt.version === latestVersion && Date.now() - lastUpdateAttempt.at < UPDATE_RETRY_MS) return
+
+  // A foreground/dev invocation has no supervisor to bring it back after the
+  // swap. Announce the update there, but only self-replace a stable install.
+  const runningStable = resolve(process.argv[1] || '') === STABLE_AGENT
+  const supervised = existsSync(join(AGENT_DIR, 'run-agent.cmd'))
+  if (!runningStable || !supervised) {
+    log(`↑ налична е нова версия ${latestVersion} (текуща ${AGENT_VERSION}) — пусни „gitdone-agent --install“ еднократно, за да включиш автообновяването`)
+    lastUpdateAttempt = { version: latestVersion, at: Date.now() }
+    return
+  }
+
+  updateInFlight = true
+  lastUpdateAttempt = { version: latestVersion, at: Date.now() }
+  const url = downloadUrl.startsWith('http') ? downloadUrl : `${cfg.url}${downloadUrl}`
+  const tmp = STABLE_AGENT + '.next'
+  log(`↑ автообновяване ${AGENT_VERSION} → ${latestVersion}`)
+  try {
+    if (!/^[a-f0-9]{64}$/i.test(String(expectedSha256 || ''))) {
+      throw new Error('сървърът не върна валиден sha256')
+    }
+    const response = await fetch(url, { headers: { Authorization: `Bearer ${cfg.key}` } })
+    if (!response.ok) throw new Error(`HTTP ${response.status}`)
+    const buffer = Buffer.from(await response.arrayBuffer())
+    if (buffer.length < 1000) throw new Error(`подозрително малък файл (${buffer.length} B)`)
+
+    const actualSha256 = createHash('sha256').update(buffer).digest('hex')
+    if (actualSha256.toLowerCase() !== String(expectedSha256).toLowerCase()) {
+      throw new Error(`sha256 несъвпадение (очаквано ${expectedSha256}, получено ${actualSha256})`)
+    }
+    const embeddedVersion = buffer
+      .subarray(0, 12_000)
+      .toString('utf8')
+      .match(/const AGENT_VERSION\s*=\s*['"]([^'"]+)['"]/)?.[1]
+    if (embeddedVersion !== latestVersion) {
+      throw new Error(`файлът е v${embeddedVersion || '?'}, а сървърът обяви v${latestVersion}`)
+    }
+
+    writeFileSync(tmp, buffer)
+    renameSync(tmp, STABLE_AGENT)
+    log(`✓ обновено до ${latestVersion} — supervisor-ът ще рестартира агента`)
+    process.exit(0)
+  } catch (err) {
+    updateInFlight = false
+    try { if (existsSync(tmp)) unlinkSync(tmp) } catch { /* best-effort cleanup */ }
+    log(`✗ автообновяването се провали: ${err?.message || err} — оставам на ${AGENT_VERSION}, ще опитам пак до 1 час`)
+  }
+}
+
 function runDoctor() {
   const cfg = readConfig()
   console.log('gitdone-agent doctor')
@@ -1853,39 +1924,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}]`
 }
 
@@ -2226,14 +2357,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
   }
@@ -2255,13 +2387,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,
@@ -2294,14 +2426,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
@@ -2328,7 +2460,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).
@@ -2734,7 +2866,12 @@ async function sync(cfg, discovered) {
   })
   if (full) { syncRepoSig = sig; syncFullCountdown = SYNC_FULL_TICKS }
   else syncFullCountdown--
-  return data.tracked ?? []
+  return {
+    tracked: data.tracked ?? [],
+    latestVersion: data.latestVersion,
+    downloadUrl: data.downloadUrl,
+    downloadSha256: data.downloadSha256,
+  }
 }
 
 // Per-repo cache of the last snapshot we actually SENT, so an idle repo whose
@@ -2908,7 +3045,11 @@ async function runLoop(cfg) {
   async function tick() {
     try {
       const discovered = scanRepos(cfg.roots)
-      const tracked = await sync(cfg, discovered)
+      const state = await sync(cfg, discovered)
+      // A successful update exits here; the supervisor starts the new stable
+      // script before any more repo work is performed.
+      await selfUpdate(cfg, state.latestVersion, state.downloadUrl, state.downloadSha256)
+      const tracked = state.tracked
       let pushed = 0
       let skipped = 0
       for (const repo of tracked) {

package/package.json

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