@haystackeditor/cli 0.22.2 → 0.23.0

package/dist/commands/verify-precompute.js

@@ -8,7 +8,7 @@ import chalk from 'chalk';
 import { NotLoggedInError, resolveAuthContext } from '../utils/auth.js';
 import { findGitRoot, parseRemoteUrl, } from '../utils/git.js';
 import { resolveVerifyBaseSha } from '../utils/verify-base.js';
-import { HaystackApiError, haystackJson, REPO_NOT_ENTITLED_CODE, SUBSCRIPTION_REQUIRED_CODE, } from '../utils/haystack-api.js';
+import { HaystackApiError, haystackFetch, haystackJson, REPO_NOT_ENTITLED_CODE, SUBSCRIPTION_REQUIRED_CODE, } from '../utils/haystack-api.js';
 import { trackPrecomputeEvent } from '../utils/telemetry.js';
 import { findSecretsInPatch, isSecretBearingPath } from '../utils/secret-paths.js';
 import { startPrecomputeDelivery } from './precompute-delivery.js';
@@ -313,13 +313,45 @@ function precomputeResult(response) {
         return { outcome: 'existing', ...reported };
     throw new PrecomputeFailure('The precompute service returned an invalid response.');
 }
+/** The captured change as the service takes it (CRAWL-V1 amendment 14): uploaded once, content-addressed by its sha256 in
+ * the repository's scope (a HEAD finds an earlier upload; a PUT only when it is missing), and named in the front-half
+ * request by digest and size instead of carried inline. Nothing on the way holds a size limit of its own: tldraw's 13.8 MB
+ * capture was refused at the 8 MiB inline bound (2026-10-02). `force` uploads even when the HEAD found it (a 409 says the
+ * service no longer has it). */
+async function uploadSourcePatch(request, token, signal, force = false) {
+    const gzipped = Buffer.from(request.patchGzBase64, 'base64');
+    const path = `/api/agent/cloud-verifier/source-patches/${request.patchSha256}`
+        + `?owner=${encodeURIComponent(request.owner)}&repository=${encodeURIComponent(request.repository)}`;
+    const found = force ? null : await haystackFetch(path, token, { method: 'HEAD', signal }, [404]);
+    if (found === null || found.status === 404) {
+        await haystackFetch(path, token, { method: 'PUT', headers: { 'Content-Type': 'application/gzip' }, body: gzipped, signal });
+    }
+    return gzipped.byteLength;
+}
+/** One front-half submission of a captured request: the change uploaded (uploadSourcePatch), then the request naming it. A
+ * 409 (the service has no such upload: it expired between the HEAD and the POST) uploads it again and submits once more. */
+async function submitCapture(request, token, signal) {
+    const { patchGzBase64: _inline, ...named } = request;
+    const submit = async (force) => {
+        const patchBytes = await uploadSourcePatch(request, token, signal, force);
+        return haystackJson('/api/agent/cloud-verifier/front-half', token, { method: 'POST',
+            headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ ...named, patchBytes }), signal });
+    };
+    try {
+        return await submit(false);
+    }
+    catch (error) {
+        if (!(error instanceof HaystackApiError && error.status === 409))
+            throw error;
+        return submit(true);
+    }
+}
 /** One authenticated submission of the already captured request. No source reads or retries. */
 export const deliverPrecomputeRequest = async (request, signal) => {
     signal.throwIfAborted();
     const auth = await resolveAuthContext({ owner: request.owner, repo: request.repository });
     signal.throwIfAborted();
-    return precomputeResult(await haystackJson('/api/agent/cloud-verifier/front-half', auth.token, { method: 'POST', headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify(request), signal }));
+    return precomputeResult(await submitCapture(request, auth.token, signal));
 };
 function readWalkerStatus(value) {
     if (value && typeof value === 'object' && !Array.isArray(value)) {
@@ -506,12 +538,7 @@ export async function postPrecomputeCapture(capture, token, deadline) {
     const fetchTimer = setTimeout(() => controller.abort(), remainingMs(deadline));
     let response;
     try {
-        response = await haystackJson('/api/agent/cloud-verifier/front-half', token, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify(capture.derivation.request),
-            signal: controller.signal,
-        });
+        response = await submitCapture(capture.derivation.request, token, controller.signal);
     }
     finally {
         clearTimeout(fetchTimer);

package/dist/utils/haystack-api.js

@@ -183,6 +183,11 @@ export async function classifyHttpError(response, context) {
     return new HaystackApiError(response.status, `${context}: unexpected response (HTTP ${response.status})${suffix}.`);
 }
 export async function haystackJson(path, token, init = {}, acceptedStatuses = []) {
+    const response = await haystackFetch(path, token, init, acceptedStatuses);
+    return response.json();
+}
+/** An authenticated request whose response is not JSON (a HEAD, an upload): the response itself, or the classified error. */
+export async function haystackFetch(path, token, init = {}, acceptedStatuses = []) {
     const response = await fetch(haystackApiUrl(path), {
         ...init,
         headers: headers(token, init.headers),
@@ -190,7 +195,7 @@ export async function haystackJson(path, token, init = {}, acceptedStatuses = []
     if (!response.ok && !acceptedStatuses.includes(response.status)) {
         throw await classifyHttpError(response, `Haystack API ${path}`);
     }
-    return response.json();
+    return response;
 }
 export async function fetchCliIdentity(token) {
     return haystackJson('/api/cli/me', token);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@haystackeditor/cli",
-  "version": "0.22.2",
+  "version": "0.23.0",
   "description": "haystack verify: run your app with and without a change, and see what the change broke",
   "type": "module",
   "bin": {