insta 0.0.81 → 0.0.83

package/dist/build-logs.js

@@ -6,6 +6,11 @@ const terminal = new Set(['succeeded', 'failed', 'canceled', 'unknown', 'live'])
 const entryKey = (step, entry) => createHash('sha256').update(JSON.stringify([step, entry.timestamp, entry.message])).digest('hex');
 class LogsNotReady extends Error {
 }
+// Compute emits UTC RFC3339Nano; Date.parse discards submillisecond ordering.
+function completionKey(value) {
+    const [seconds, fraction = ''] = value.slice(0, -1).split('.');
+    return `${seconds}.${fraction.padEnd(9, '0')}`;
+}
 export async function readBuildLogs(api, projectId, source, buildId, signal = AbortSignal.timeout(30_000), follow) {
     let bytes = 0;
     let requests = 0;
@@ -19,7 +24,20 @@ export async function readBuildLogs(api, projectId, source, buildId, signal = Ab
             if (++requests > 200)
                 throw new Error('build logs exceed the per-read page limit');
             const params = new URLSearchParams({ ...(step ? { step } : {}), ...(cursor ? { cursor } : {}) });
-            const { body } = await api.rawRequest('GET', `/projects/${projectId}/builds/${source}/${encodeURIComponent(buildId)}/logs?${params}`, undefined, { signal });
+            signal.throwIfAborted();
+            const request = new AbortController();
+            const abort = () => request.abort(signal.reason);
+            signal.addEventListener('abort', abort, { once: true });
+            const timeout = setTimeout(() => request.abort(new DOMException('build log request timed out', 'TimeoutError')), 20_000);
+            let body;
+            try {
+                const response = await api.rawRequest('GET', `/projects/${projectId}/builds/${source}/${encodeURIComponent(buildId)}/logs?${params}`, undefined, { signal: request.signal });
+                body = response.body;
+            }
+            finally {
+                clearTimeout(timeout);
+                signal.removeEventListener('abort', abort);
+            }
             if (!body || !['ready', 'pending', 'unsupported', 'unavailable'].includes(body.state) || !Array.isArray(body.steps) || !Array.isArray(body.entries))
                 throw new Error('invalid build log response');
             bytes += Buffer.byteLength(JSON.stringify(body));
@@ -60,7 +78,18 @@ export async function readBuildLogs(api, projectId, source, buildId, signal = Ab
     const first = stepPages[0];
     if (stepPages.some((page) => page.state !== first.state))
         throw new LogsNotReady('build steps are temporarily unavailable');
-    const steps = stepPages.flatMap((page) => page.steps);
+    const byDigest = new Map();
+    for (const step of stepPages.flatMap((page) => page.steps)) {
+        const previous = byDigest.get(step.digest);
+        if (!previous) {
+            byDigest.set(step.digest, step);
+            continue;
+        }
+        const [older, newer] = previous.completedAt && (!step.completedAt || completionKey(previous.completedAt) > completionKey(step.completedAt))
+            ? [step, previous] : [previous, step];
+        byDigest.set(step.digest, { ...older, ...newer, hasLogs: older.hasLogs || newer.hasLogs, error: newer.error });
+    }
+    const steps = [...byDigest.values()];
     follow?.emit({ ...first, steps, output: [] });
     const output = [];
     for (const step of steps) {
@@ -127,20 +156,24 @@ export function archiveLogWatcher(api, projectId, write, wait = sleep) {
     const follow = { tails: new Map(), emit: snapshot => printer.print(snapshot, write) };
     let warned = '';
     let unavailable = false;
-    return async (buildId, finished, remainingMs = 30_000) => {
+    return async (buildId, finished, remainingMs = 30_000, cancelSignal) => {
         if (unavailable)
             return;
-        const deadline = Date.now() + Math.min(remainingMs, finished ? 18_000 : 3000);
+        const started = Date.now();
+        const deadline = started + remainingMs;
+        const refreshDeadline = started + Math.min(remainingMs, finished ? 18_000 : remainingMs);
         for (let attempt = 0; attempt < (finished ? 6 : 1); attempt++) {
             if (attempt > 0)
-                await wait(Math.min(3000, Math.max(0, deadline - Date.now())));
-            const remaining = deadline - Date.now();
+                await wait(Math.min(3000, Math.max(0, refreshDeadline - Date.now())));
+            const finalRead = finished && (attempt === 5 || Date.now() >= refreshDeadline);
+            const remaining = Math.min(deadline - Date.now(), finalRead ? 30_000 : refreshDeadline - Date.now());
             if (remaining <= 0)
                 return;
-            if (finished && (attempt === 0 || attempt === 5))
+            if (finished && (attempt === 0 || finalRead))
                 follow.tails.clear();
+            const signal = cancelSignal ?? AbortSignal.timeout(remaining);
             try {
-                const snapshot = await readBuildLogs(api, projectId, 'archive', buildId, AbortSignal.timeout(remaining), follow);
+                const snapshot = await readBuildLogs(api, projectId, 'archive', buildId, signal, follow);
                 if (snapshot.state === 'unsupported') {
                     printer.finishLine(write);
                     write('Build logs are not supported for this build provider.\n');
@@ -152,14 +185,21 @@ export function archiveLogWatcher(api, projectId, write, wait = sleep) {
                 warned = '';
             }
             catch (error) {
+                if (cancelSignal?.aborted)
+                    return;
+                if (finished && signal.aborted && !finalRead && Date.now() < deadline)
+                    continue;
                 if (error instanceof ApiError && error.status === 400)
                     follow.tails.clear();
                 printer.finishLine(write);
-                const message = `Could not read build logs. Retry with: insta build-logs ${buildId}\n`;
+                const reason = signal.aborted || (error instanceof Error && error.name === 'TimeoutError') ? ' (timed out)' : error instanceof ApiError ? ` (HTTP ${error.status})` : '';
+                const message = `Could not read build logs${reason}. Retry with: insta build-logs ${buildId}\n`;
                 if (warned !== message)
                     write(message);
                 warned = message;
             }
+            if (finalRead)
+                return;
         }
     };
 }

package/dist/deploy-archive.js

@@ -1,3 +1,4 @@
+import { setTimeout as delay } from 'node:timers/promises';
 import { handleApproval } from './util.js';
 export function archiveBuildSpec(hasDockerfile) {
     return hasDockerfile ? { type: 'dockerfile' } : { type: 'nixpacks' };
@@ -84,64 +85,72 @@ export async function deployArchive(api, projectId, ref, branch, opts, now = Dat
         log('resuming the deploy this archive already started');
     const deadline = now() + DEPLOY_DEADLINE_MS;
     const overdue = () => new Error(`the deploy did not finish within ${Math.round(DEPLOY_DEADLINE_MS / 60000)} minutes — check \`insta status\` or re-run`);
-    let last = '';
-    for (;;) {
-        // The deadline bounds the wall clock, not the number of answers: it is checked before each poll,
-        // and each poll is itself bounded by what remains, so a stalled endpoint cannot hold the CLI
-        // past it, and an answer that would arrive after it is not waited for.
-        const remaining = deadline - now();
-        if (remaining <= 0)
-            throw overdue();
-        const res = await api.rawRequest('GET', `/projects/${projectId}/archive-deploys/${encodeURIComponent(operationId)}`, undefined, {
-            signal: AbortSignal.timeout(Math.min(remaining, POLL_REQUEST_TIMEOUT_MS)),
-        }).catch((e) => {
-            if (!isAbort(e))
-                throw e;
-            throw remaining <= POLL_REQUEST_TIMEOUT_MS ? overdue() : new Error(`the platform did not answer a status poll within ${POLL_REQUEST_TIMEOUT_MS / 1000}s — check \`insta status\` or re-run`);
-        });
-        const state = res.body?.state;
-        await watchLogs?.(operationId, state === 'failed' || state === 'live', Math.max(0, deadline - now()));
-        // A failed operation is an ANSWER, not a transport error: the poll worked, and the sentence
-        // it carries (usually the gateway's own, e.g. "no Dockerfile at ./api") is the one to show.
-        if (state === 'failed') {
-            // `||` would let a non-string through and the CLI would print "[object Object]" for the one
-            // sentence that explains the failure. Only a non-empty string is a message.
-            const error = res.body?.error;
-            return { failed: typeof error === 'string' && error ? error : 'the deploy failed' };
+    const logController = new AbortController();
+    const logTask = watchLogs ? (async () => {
+        while (!logController.signal.aborted && now() < deadline) {
+            await watchLogs(operationId, false, Math.max(0, deadline - now()), logController.signal);
+            await delay(Math.min(POLL_MS, Math.max(0, deadline - now())), undefined, { signal: logController.signal });
         }
-        if (state === 'live') {
-            const image = res.body?.imageRef;
-            const url = res.body?.url;
-            if (typeof image !== 'string' || !image || typeof url !== 'string' || !url) {
-                throw new Error('the deploy finished but the platform returned no image or URL for it — check `insta status`');
+    })().catch(() => {
+        if (!logController.signal.aborted)
+            log(`Could not follow build logs. Retry with: insta build-logs ${operationId}`);
+    }) : undefined;
+    let last = '';
+    try {
+        for (;;) {
+            const remaining = deadline - now();
+            if (remaining <= 0)
+                throw overdue();
+            const res = await api.rawRequest('GET', `/projects/${projectId}/archive-deploys/${encodeURIComponent(operationId)}`, undefined, {
+                signal: AbortSignal.timeout(Math.min(remaining, POLL_REQUEST_TIMEOUT_MS)),
+            }).catch((e) => {
+                if (!isAbort(e))
+                    throw e;
+                throw remaining <= POLL_REQUEST_TIMEOUT_MS ? overdue() : new Error(`the platform did not answer a status poll within ${POLL_REQUEST_TIMEOUT_MS / 1000}s — check \`insta status\` or re-run`);
+            });
+            const state = res.body?.state;
+            if (state === 'failed' || state === 'live') {
+                logController.abort();
+                await logTask;
+                await watchLogs?.(operationId, true, Math.max(0, deadline - now()));
             }
-            // Optional strings, validated as such. String() would have coerced a protocol error into a
-            // plausible-looking branch or group and reported a target the deploy never named. An omitted
-            // field falls back to what was requested; a field of the wrong type is a broken contract.
-            const optionalString = (field, v) => {
-                if (v === undefined || v === null)
-                    return undefined;
-                if (typeof v !== 'string')
-                    throw new Error(`the platform returned a non-string ${field} for the deploy — upgrade with \`insta upgrade\``);
-                return v;
-            };
-            return {
-                image, url,
-                branch: optionalString('branch', res.body.branch) ?? branch,
-                group: optionalString('group', res.body.group) ?? opts.group ?? '',
-                machineId: optionalString('machineId', res.body.machineId),
-            };
-        }
-        // Only the platform's own in-flight states keep the loop going. An absent or unknown state
-        // would otherwise spend the whole deadline looking like a slow build.
-        if (state !== 'queued' && state !== 'building' && state !== 'deploying') {
-            throw new Error(`the platform reported an unknown deploy state (${JSON.stringify(state)}) — upgrade with \`insta upgrade\``);
-        }
-        if (state !== last) {
-            log(state === 'deploying' ? 'image built, deploying it' : `${state}…`);
-            last = state;
+            if (state === 'failed') {
+                const error = res.body?.error;
+                return { failed: typeof error === 'string' && error ? error : 'the deploy failed' };
+            }
+            if (state === 'live') {
+                const image = res.body?.imageRef;
+                const url = res.body?.url;
+                if (typeof image !== 'string' || !image || typeof url !== 'string' || !url) {
+                    throw new Error('the deploy finished but the platform returned no image or URL for it — check `insta status`');
+                }
+                const optionalString = (field, v) => {
+                    if (v === undefined || v === null)
+                        return undefined;
+                    if (typeof v !== 'string')
+                        throw new Error(`the platform returned a non-string ${field} for the deploy — upgrade with \`insta upgrade\``);
+                    return v;
+                };
+                return {
+                    image, url,
+                    branch: optionalString('branch', res.body.branch) ?? branch,
+                    group: optionalString('group', res.body.group) ?? opts.group ?? '',
+                    machineId: optionalString('machineId', res.body.machineId),
+                };
+            }
+            if (state !== 'queued' && state !== 'building' && state !== 'deploying') {
+                throw new Error(`the platform reported an unknown deploy state (${JSON.stringify(state)}) — upgrade with \`insta upgrade\``);
+            }
+            if (state !== last) {
+                log(state === 'deploying' ? 'image built, deploying it' : `${state}…`);
+                last = state;
+            }
+            await wait(POLL_MS);
         }
-        await wait(POLL_MS);
+    }
+    finally {
+        logController.abort();
+        await logTask;
     }
 }
 //# sourceMappingURL=deploy-archive.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "insta",
-  "version": "0.0.81",
+  "version": "0.0.83",
   "type": "module",
   "description": "InstaCloud CLI — a thin client of the platform control-plane API.",
   "keywords": [