@botlearn-course/daemon 0.0.17-beta.1 → 0.0.17-beta.3

package/dist/input-attachments.js

@@ -3,6 +3,11 @@ import { chmod, mkdir, open, readFile, rename, rm, stat } from "node:fs/promises
 import path from "node:path";
 const MAX_ATTACHMENTS = 5;
 const MAX_ATTACHMENT_BYTES = 10 * 1024 * 1024;
+// Abort a stalled transfer without rejecting a slow cross-cloud source while verified bytes
+// continue to arrive. The absolute cap prevents a trickle response from holding a daemon turn
+// indefinitely. These are daemon compatibility invariants, not environment tuning knobs.
+const ATTACHMENT_DOWNLOAD_IDLE_TIMEOUT_MS = 60_000;
+const ATTACHMENT_DOWNLOAD_MAX_DURATION_MS = 10 * 60_000;
 const ATTACHMENT_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 const SHA256 = /^[0-9a-f]{64}$/i;
 const CONTENT_TYPE_EXTENSIONS = {
@@ -126,7 +131,7 @@ async function verifyExisting(filePath, attachment) {
         throw error;
     }
 }
-async function writeResponseToFile(response, partPath, attachment, signal) {
+async function writeResponseToFile(response, partPath, attachment, signal, onDownloadProgress) {
     if (!response.body)
         throw new Error("input attachment response has no body");
     const declaredLength = response.headers.get("content-length");
@@ -146,13 +151,17 @@ async function writeResponseToFile(response, partPath, attachment, signal) {
     try {
         const reader = response.body.getReader();
         while (true) {
-            if (signal.aborted)
+            if (signal.aborted) {
+                if (signal.reason instanceof Error)
+                    throw signal.reason;
                 throw new Error("input attachment download aborted");
+            }
             const { done, value } = await reader.read();
             if (done)
                 break;
             const chunk = Buffer.from(value);
             received += chunk.length;
+            onDownloadProgress?.();
             if (received > attachment.size_bytes || received > MAX_ATTACHMENT_BYTES) {
                 throw new Error("input attachment response exceeds declared size");
             }
@@ -183,6 +192,36 @@ async function writeResponseToFile(response, partPath, attachment, signal) {
         await file.close();
     }
 }
+function startAttachmentDownloadBudget(parentSignal) {
+    const controller = new AbortController();
+    const abortFromParent = () => controller.abort(parentSignal.reason);
+    const abortStalledDownload = () => controller.abort(new Error("input attachment download stalled for 60s"));
+    const abortOverlongDownload = () => controller.abort(new Error("input attachment download exceeded the 600s maximum duration"));
+    if (parentSignal.aborted) {
+        abortFromParent();
+    }
+    else {
+        parentSignal.addEventListener("abort", abortFromParent, { once: true });
+    }
+    const maxDurationTimer = setTimeout(abortOverlongDownload, ATTACHMENT_DOWNLOAD_MAX_DURATION_MS);
+    let idleTimer;
+    const recordProgress = () => {
+        if (idleTimer !== undefined)
+            clearTimeout(idleTimer);
+        idleTimer = setTimeout(abortStalledDownload, ATTACHMENT_DOWNLOAD_IDLE_TIMEOUT_MS);
+    };
+    recordProgress();
+    return {
+        signal: controller.signal,
+        recordProgress,
+        dispose: () => {
+            if (idleTimer !== undefined)
+                clearTimeout(idleTimer);
+            clearTimeout(maxDurationTimer);
+            parentSignal.removeEventListener("abort", abortFromParent);
+        },
+    };
+}
 export async function materializeInputAttachments(workspaceDir, attachments, grant, signal) {
     if (attachments.length > MAX_ATTACHMENTS) {
         throw new Error("too many input attachments");
@@ -215,20 +254,22 @@ export async function materializeInputAttachments(workspaceDir, attachments, gra
             const partPath = `${filePath}.part`;
             await rm(partPath, { force: true });
             const downloadUrl = downloadUrls.get(attachment.attachment_id);
-            const response = await fetch(downloadUrl, {
-                headers: { "accept-encoding": "identity" },
-                redirect: "error",
-                signal,
-            });
-            if (!response.ok) {
-                throw new Error(`input attachment download failed with HTTP ${response.status}`);
-            }
+            const budget = startAttachmentDownloadBudget(signal);
             try {
-                await writeResponseToFile(response, partPath, attachment, signal);
+                const response = await fetch(downloadUrl, {
+                    headers: { "accept-encoding": "identity" },
+                    redirect: "error",
+                    signal: budget.signal,
+                });
+                if (!response.ok) {
+                    throw new Error(`input attachment download failed with HTTP ${response.status}`);
+                }
+                await writeResponseToFile(response, partPath, attachment, budget.signal, budget.recordProgress);
                 await rename(partPath, filePath);
                 await chmod(filePath, 0o640);
             }
             finally {
+                budget.dispose();
                 await rm(partPath, { force: true });
             }
         }

package/dist/run-dispatcher.js

@@ -446,17 +446,7 @@ export class RunDispatcher {
                 if (!persistentTurn?.inputAttachmentGrant) {
                     throw new Error("input attachment download authorization is unavailable");
                 }
-                const attachmentController = new AbortController();
-                const abortAttachmentDownload = () => attachmentController.abort();
-                controller.signal.addEventListener("abort", abortAttachmentDownload, { once: true });
-                const attachmentTimer = setTimeout(abortAttachmentDownload, 60_000);
-                try {
-                    inputAttachments = await materializeInputAttachments(workspaceDir, requestedAttachments, persistentTurn.inputAttachmentGrant, attachmentController.signal);
-                }
-                finally {
-                    clearTimeout(attachmentTimer);
-                    controller.signal.removeEventListener("abort", abortAttachmentDownload);
-                }
+                inputAttachments = await materializeInputAttachments(workspaceDir, requestedAttachments, persistentTurn.inputAttachmentGrant, controller.signal);
             }
             const missingCapabilities = missingRunCapabilities(payload, workspaceDir);
             if (missingCapabilities.length > 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botlearn-course/daemon",
-  "version": "0.0.17-beta.1",
+  "version": "0.0.17-beta.3",
   "description": "Lightweight BotLearn Course daemon: run course tasks on your own machine with your own agent runtime (BYOA).",
   "type": "module",
   "bin": {