@tapi-dev/sdk 0.1.29 → 0.1.30

package/dist/cli.d.ts

@@ -125,7 +125,9 @@ export declare function chooseStudioPort(preferred?: number, options?: {
     portAvailable?: StudioPortAvailable;
     reapBlockedPorts?: StudioPortReaper;
 }): Promise<number>;
-export declare function downloadAndVerify(url: string, destination: string, expectedSha256: string, label?: string): Promise<void>;
+export declare function downloadAndVerify(url: string, destination: string, expectedSha256: string, label?: string, options?: {
+    stallTimeoutMs?: number;
+}): Promise<void>;
 export declare function studioInstanceRecordPathForOptions(options: StudioCliOptions): string;
 export declare function findPortableStudioServerExe(releaseDir: string, manifest: StudioReleaseManifest): string | undefined;
 export declare function estimateRequiredExtractionBytes(zipBytes: number): number;

package/dist/cli.js

@@ -9,7 +9,7 @@ import { homedir } from "node:os";
 import { basename, dirname, join, resolve } from "node:path";
 import { performance } from "node:perf_hooks";
 import { emitKeypressEvents } from "node:readline";
-import { Readable } from "node:stream";
+import { Readable, Transform } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { TapiClient } from "./index.js";
@@ -23,6 +23,8 @@ const SUPPORTED_STUDIO_PLATFORM = "windows-x86_64";
 const DEFAULT_INSTALL_AUTH_TIMEOUT_MS = 120_000;
 const PORTABLE_STUDIO_SERVER_READY_TIMEOUT_MS = 30_000;
 const PORTABLE_STUDIO_SERVER_READY_INTERVAL_MS = 250;
+const DOWNLOAD_STALL_TIMEOUT_MS = 30_000;
+const DOWNLOAD_PROGRESS_LOG_BYTES = 50 * 1024 * 1024;
 const MAX_WIDE_EVENT_PROCESS_ROOTS = 5;
 const MAX_NONCURRENT_MANAGED_DOWNLOADS = 0;
 const MAX_NONCURRENT_MANAGED_RELEASES = 0;
@@ -2617,11 +2619,11 @@ async function requestStudioInstallToken(apiBaseUrl, channel, firebaseIdToken, f
         expiresAt: typeof payload?.expiresAt === "string" ? payload.expiresAt : undefined,
     };
 }
-export async function downloadAndVerify(url, destination, expectedSha256, label = "Studio installer") {
+export async function downloadAndVerify(url, destination, expectedSha256, label = "Studio installer", options = {}) {
     const partialPath = `${destination}.partial`;
     await unlinkIfExists(partialPath);
     try {
-        await downloadFile(url, partialPath, label);
+        await downloadFile(url, partialPath, label, options);
         const actualSha256 = await sha256File(partialPath);
         if (actualSha256 !== expectedSha256.toLowerCase()) {
             throw new Error(`${label} checksum mismatch. Expected ${expectedSha256}, got ${actualSha256}.`);
@@ -2634,15 +2636,97 @@ export async function downloadAndVerify(url, destination, expectedSha256, label
         throw error;
     }
 }
-async function downloadFile(url, destination, label = "download") {
-    const response = await fetch(url);
-    if (!response.ok) {
-        throw new Error(`Failed to download ${label}: HTTP ${response.status}`);
+async function downloadFile(url, destination, label = "download", options = {}) {
+    const stallTimeoutMs = normalizeDownloadTimeout(options.stallTimeoutMs);
+    const controller = new AbortController();
+    let stallTimer;
+    let stallError;
+    let source;
+    let progressStream;
+    let destinationStream;
+    let receivedBytes = 0;
+    let nextProgressLogBytes = DOWNLOAD_PROGRESS_LOG_BYTES;
+    const failIfStalled = (phase) => {
+        if (stallTimer) {
+            clearTimeout(stallTimer);
+        }
+        stallTimer = setTimeout(() => {
+            stallError = formatDownloadStallError(label, stallTimeoutMs, phase, receivedBytes);
+            controller.abort(stallError);
+            source?.destroy(stallError);
+            progressStream?.destroy(stallError);
+            destinationStream?.destroy(stallError);
+        }, stallTimeoutMs);
+    };
+    try {
+        console.log(`Downloading ${label}...`);
+        failIfStalled("connecting");
+        const response = await fetch(url, { signal: controller.signal });
+        if (!response.ok) {
+            throw new Error(`Failed to download ${label}: HTTP ${response.status}`);
+        }
+        if (!response.body) {
+            throw new Error(`${label} response did not include a body.`);
+        }
+        failIfStalled("receiving data");
+        source = Readable.fromWeb(response.body);
+        progressStream = new Transform({
+            transform(chunk, _encoding, callback) {
+                receivedBytes += downloadChunkByteLength(chunk);
+                failIfStalled("receiving data");
+                if (receivedBytes >= nextProgressLogBytes) {
+                    console.log(`Downloaded ${label}: ${formatBytes(receivedBytes)}...`);
+                    while (receivedBytes >= nextProgressLogBytes) {
+                        nextProgressLogBytes += DOWNLOAD_PROGRESS_LOG_BYTES;
+                    }
+                }
+                callback(null, chunk);
+            },
+        });
+        destinationStream = createWriteStream(destination);
+        await pipeline(source, progressStream, destinationStream);
+        console.log(`Downloaded ${label}: ${formatBytes(receivedBytes)}.`);
+    }
+    catch (error) {
+        if (stallError) {
+            throw stallError;
+        }
+        throw error;
     }
-    if (!response.body) {
-        throw new Error(`${label} response did not include a body.`);
+    finally {
+        if (stallTimer) {
+            clearTimeout(stallTimer);
+        }
+    }
+}
+function downloadChunkByteLength(chunk) {
+    if (typeof chunk === "string") {
+        return Buffer.byteLength(chunk);
+    }
+    if (Buffer.isBuffer(chunk)) {
+        return chunk.length;
+    }
+    if (chunk instanceof Uint8Array) {
+        return chunk.byteLength;
+    }
+    return 0;
+}
+function normalizeDownloadTimeout(timeoutMs) {
+    if (typeof timeoutMs !== "number" || !Number.isFinite(timeoutMs)) {
+        return DOWNLOAD_STALL_TIMEOUT_MS;
+    }
+    return Math.max(1, Math.floor(timeoutMs));
+}
+function formatDownloadStallError(label, timeoutMs, phase, receivedBytes) {
+    const progress = receivedBytes > 0 ? ` after ${formatBytes(receivedBytes)}` : "";
+    return new Error(`${label} download stalled${progress}: no data received for ${formatDuration(timeoutMs)} while ${phase}. ` +
+        "Check your network connection, VPN, or install authorization and retry.");
+}
+function formatDuration(ms) {
+    if (ms < 1000) {
+        return `${ms}ms`;
     }
-    await pipeline(Readable.fromWeb(response.body), createWriteStream(destination));
+    return `${Math.ceil(ms / 1000)}s`;
 }
 async function browserGoogleSignIn(timeoutMs = DEFAULT_INSTALL_AUTH_TIMEOUT_MS) {
     ensureWindowsHost();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tapi-dev/sdk",
-  "version": "0.1.29",
+  "version": "0.1.30",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",