cursedops 0.12.0 → 0.12.1

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "cursedops",
-	"version": "0.12.0",
+	"version": "0.12.1",
 	"description": "The build-and-ops answers this generation's apps wrote independently and identically: finding a generation's roots — and printing a command that runs when pasted — without knowing a path, the generation's whole-tree laws run over one repo from a checkout or a worktree, macOS launchd agent install/replace/remove and the live port a job serves, the scaffolding and verdicts of a deployed smoke (origin probe, the smoke's own environment, a network that lies about DNS, a settled version), the static-serving helpers eight apps copied — the path-traversal guard among them — the API floor that keeps an unmatched /api/... from ever being answered with the app shell, the commit and dirty flag a checkout-served process reports, the Cloudflare Worker deploy toolkit four apps copied (the deploy sequence, exact-set secrets over a pipe, origin-first rollback, the curl edge fetch, the row-for-row D1 import proof, the billed-CPU tail check around a deploy's walk and smoke, and each app's worker:secrets and worker:smoke main as one function of its data), the relay a Worker fronts a Mac-bound app with (the Durable Object, the frames, the Mac's dialer and key rotation — lifted from station for roms — and the signed-in stage walk's skeleton and the relay app's whole worker:deploy), the Worker import-graph and await-port checks every Worker app's suite runs over its own source, and the public-surface ratchet three published libraries each carried a forked copy of. Mechanism only — no app knows its name from here. Bun, zero runtime dependencies (typescript is an optional peer, for public-surface only), ships source.",
 	"type": "module",
 	"scripts": {

package/src/workerDeploy.ts

@@ -530,6 +530,34 @@ export function schemaApplyArgv(databaseName: string, commands: readonly string[
 	return commands.map((command) => ["bunx", "wrangler", "d1", "execute", databaseName, "--remote", "--command", command, "--json", "-y", ...envArgs]);
 }
 
+/**
+ * The reason a non-zero `wrangler … --json` gave, or `null` when it printed no error document.
+ *
+ * With `--json`, wrangler writes its failure to STDOUT as `{"error":{"text":…,"notes":[{"text":…}],
+ * "kind":"error","name":"APIError","code":7403}}` (task 2427: vault's production deploy stopped on
+ * 2026-10-01 with only "wrangler exited 1", and the ship batch rebuilt the call by hand to learn it
+ * was a transient 7403). `api` is whether it is a Cloudflare API error — worth one retry, since the
+ * schema is idempotent and the same commands applied minutes later.
+ */
+export function wranglerError(stdout: string): { reason: string; api: boolean } | null {
+	const start = stdout.search(/\{\s*"error"\s*:/);
+	if (start < 0) return null;
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(stdout.slice(start, stdout.lastIndexOf("}") + 1));
+	} catch {
+		return null;
+	}
+	const error = (parsed as { error?: unknown } | null)?.error;
+	if (!error || typeof error !== "object") return null;
+	const { text, notes, name, kind } = error as { text?: unknown; notes?: unknown; name?: unknown; kind?: unknown };
+	const parts = [typeof text === "string" ? text.trim() : ""];
+	if (Array.isArray(notes)) for (const note of notes) if (typeof (note as { text?: unknown })?.text === "string") parts.push((note as { text: string }).text.trim());
+	const reason = parts.filter(Boolean).join(" — ");
+	if (!reason) return null;
+	return { reason, api: name === "APIError" || (kind === "error" && /cloudflare api/i.test(reason)) };
+}
+
 /**
  * Did one schema chunk APPLY? Its exit code alone does not say.
  *
@@ -544,22 +572,26 @@ export function schemaApplyArgv(databaseName: string, commands: readonly string[
  * one result per statement, every one `success: true`. Anything else — no JSON, an empty array,
  * a failed result — is not applied. Pure, so its failure path is tested without wrangler.
  */
-export function judgeSchemaApply(code: number, stdout: string): { applied: boolean; line: string } {
-	if (code !== 0) return { applied: false, line: `wrangler exited ${code}` };
+export function judgeSchemaApply(code: number, stdout: string): { applied: boolean; line: string; retry: boolean } {
+	if (code !== 0) {
+		const failure = wranglerError(stdout);
+		if (!failure) return { applied: false, line: `wrangler exited ${code}`, retry: false };
+		return { applied: false, line: `wrangler exited ${code}: ${failure.reason}`, retry: failure.api };
+	}
 	// the first `[` that opens a JSON array, never the `[ERROR]`/`[WARNING]` of a banner — as `wranglerRows`
 	const start = stdout.search(/\[\s*[{\]]/);
 	const banner = stdout.trim().slice(0, 160).replace(/\s+/g, " ") || "(nothing)";
-	if (start < 0) return { applied: false, line: `wrangler exited 0 and printed no JSON result — it did not run the query. It printed: ${banner}` };
+	if (start < 0) return { applied: false, retry: true, line: `wrangler exited 0 and printed no JSON result — it did not run the query. It printed: ${banner}` };
 	let parsed: unknown;
 	try {
 		parsed = JSON.parse(stdout.slice(start));
 	} catch (cause) {
-		return { applied: false, line: `wrangler's JSON result did not parse (${(cause as Error).message})` };
+		return { applied: false, retry: true, line: `wrangler's JSON result did not parse (${(cause as Error).message})` };
 	}
-	if (!Array.isArray(parsed) || parsed.length === 0) return { applied: false, line: "wrangler printed an empty result — no statement ran" };
+	if (!Array.isArray(parsed) || parsed.length === 0) return { applied: false, retry: true, line: "wrangler printed an empty result — no statement ran" };
 	const failed = parsed.filter((result) => (result as { success?: unknown } | null)?.success !== true);
-	if (failed.length > 0) return { applied: false, line: `${failed.length} of ${parsed.length} result(s) did not report success` };
-	return { applied: true, line: `applied — ${parsed.length} result(s), every one success` };
+	if (failed.length > 0) return { applied: false, retry: true, line: `${failed.length} of ${parsed.length} result(s) did not report success` };
+	return { applied: true, retry: false, line: `applied — ${parsed.length} result(s), every one success` };
 }
 
 /**
@@ -792,16 +824,16 @@ export function runWorkerDeploy(spec: WorkerDeploySpec, deps: DeployDeps): Deplo
 			return stop("schema", `${schema} could not be read as statements (${(cause as Error).message}) — nothing was deployed.`);
 		}
 		for (const argv of schemaApplyArgv(spec.databaseName, commands, envArgs)) {
-			// a silent exit 0 is intermittent and the schema is idempotent, so ONE retry; a real
-			// failure (non-zero) is not retried — it would fail the same way
-			const attempt = (): { code: number; verdict: ReturnType<typeof judgeSchemaApply> } => {
+			// a silent exit 0 and a Cloudflare API error are intermittent and the schema is idempotent,
+			// so ONE retry; any other failure is not retried — it would fail the same way
+			const attempt = (): ReturnType<typeof judgeSchemaApply> => {
 				const { code, stdout } = deps.capture(argv, spec.credential);
-				return { code, verdict: judgeSchemaApply(code, stdout) };
+				return judgeSchemaApply(code, stdout);
 			};
-			let { code, verdict } = attempt();
-			if (!verdict.applied && code === 0) {
+			let verdict = attempt();
+			if (!verdict.applied && verdict.retry) {
 				error(`  🟡 ${verdict.line} — retrying once`);
-				({ code, verdict } = attempt());
+				verdict = attempt();
 			}
 			if (!verdict.applied) return stop("schema", `the schema did not apply (${verdict.line}) — nothing was deployed.`);
 			log(`  ${verdict.line}`);