cursedops 0.10.14 → 0.10.16

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "cursedops",
-	"version": "0.10.14",
+	"version": "0.10.16",
 	"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/d1Import.ts

@@ -176,8 +176,13 @@ export const D1_READ_PAGE_ROWS = 500;
  * back flix's 9,296 `films` EMPTY or cut mid-string (`JSON Parse error: Unterminated string`) and
  * music's tracks cut mid-property, so both apps' `worker:rollback --check` — whose one job is to
  * print what a rollback would lose — crashed before printing it. Every app's `worker-import.ts`
- * read that way. A `WITHOUT ROWID` table has no rowid to page on; `read` then throws D1's
- * `no such column: rowid`, loudly.
+ * read that way.
+ *
+ * 🔴 And no FIXED page is small enough for every table: desk's sheet rows cut 500 at a time the
+ * same way. So a page that fails is asked again at half the size, and every page that succeeds
+ * doubles back toward `pageRows` (`cursedbelt-server`'s `pullD1ToSqlite` learned the second half
+ * the same week). Only a failure at ONE row throws — with the read's own error. A `WITHOUT ROWID`
+ * table has no rowid to page on, so it throws D1's `no such column: rowid` that way, loudly.
  */
 export function readD1Table(
 	read: (sql: string) => Array<Record<string, unknown>>,
@@ -187,11 +192,20 @@ export function readD1Table(
 ): Array<Record<string, unknown>> {
 	const rows: Array<Record<string, unknown>> = [];
 	let after: number | null = null;
+	let limit = pageRows;
 	for (;;) {
 		const where = after === null ? "" : ` WHERE rowid > ${after}`;
-		const page = read(`SELECT rowid AS "__page_key", ${select} FROM "${table}"${where} ORDER BY rowid LIMIT ${pageRows}`);
+		let page: Array<Record<string, unknown>>;
+		try {
+			page = read(`SELECT rowid AS "__page_key", ${select} FROM "${table}"${where} ORDER BY rowid LIMIT ${limit}`);
+		} catch (error) {
+			if (limit === 1) throw error;
+			limit = Math.max(1, Math.floor(limit / 2));
+			continue;
+		}
 		for (const { __page_key, ...row } of page) rows.push(row);
-		if (page.length < pageRows) return rows;
+		if (page.length < limit) return rows;
 		after = Number(page[page.length - 1]?.__page_key);
+		limit = Math.min(pageRows, limit * 2);
 	}
 }

package/src/workerDeploy.ts

@@ -292,6 +292,11 @@ export interface WorkerDeploySpec {
 export interface DeployDeps {
 	/** Run a command, inheriting stdio; returns its exit code. */
 	run: (argv: readonly string[], env: Record<string, string>) => number;
+	/**
+	 * Run a command with its STDOUT captured (stderr inherited) — for a step whose exit code alone
+	 * proves nothing: the schema step reads wrangler's `--json` answer back ({@link judgeSchemaApply}).
+	 */
+	capture: (argv: readonly string[], env: Record<string, string>) => { code: number; stdout: string };
 	/** `git <args>` in the checkout; trimmed stdout, `""` on failure. */
 	git: (args: readonly string[]) => string;
 	/** A file in the checkout, as text — the schema. Default: `readFileSync` against the process's cwd. */
@@ -316,12 +321,25 @@ export interface DeployResult {
 
 /** The real {@link DeployDeps}, rooted at the app's checkout. */
 export function workerDeployDeps(cwd: string): DeployDeps {
+	// a schema `--command` is kilobytes of DDL — the echo names it, it does not reprint it
+	const echo = (argv: readonly string[]): void =>
+		console.log(`  $ ${argv.map((arg) => (arg.length > 160 ? `${arg.slice(0, 120)}… (${arg.length} chars)` : arg)).join(" ")}`);
 	return {
 		run: (argv, env) => {
-			// a schema `--command` is kilobytes of DDL — the echo names it, it does not reprint it
-			console.log(`  $ ${argv.map((arg) => (arg.length > 160 ? `${arg.slice(0, 120)}… (${arg.length} chars)` : arg)).join(" ")}`);
+			echo(argv);
 			return spawnSync(argv[0] as string, argv.slice(1), { cwd, stdio: "inherit", env: { ...process.env, ...env } }).status ?? 1;
 		},
+		capture: (argv, env) => {
+			echo(argv);
+			const r = spawnSync(argv[0] as string, argv.slice(1), {
+				cwd,
+				stdio: ["inherit", "pipe", "inherit"],
+				encoding: "utf8",
+				maxBuffer: 64 * 1024 * 1024,
+				env: { ...process.env, ...env },
+			});
+			return { code: r.status ?? 1, stdout: r.stdout ?? "" };
+		},
 		git: (args) => (spawnSync("git", [...args], { cwd, encoding: "utf8" }).stdout ?? "").trim(),
 		read: (path) => readFileSync(join(cwd, path), "utf8"),
 	};
@@ -433,7 +451,39 @@ export function schemaCommands(text: string, maxBytes: number = SCHEMA_COMMAND_B
  * `workerDeploy.test.ts` pins that no argv here ever carries `--file`.
  */
 export function schemaApplyArgv(databaseName: string, commands: readonly string[], envArgs: readonly string[]): string[][] {
-	return commands.map((command) => ["bunx", "wrangler", "d1", "execute", databaseName, "--remote", "--command", command, "-y", ...envArgs]);
+	return commands.map((command) => ["bunx", "wrangler", "d1", "execute", databaseName, "--remote", "--command", command, "--json", "-y", ...envArgs]);
+}
+
+/**
+ * Did one schema chunk APPLY? Its exit code alone does not say.
+ *
+ * Measured 2026-09-26 (task 2173): this Mac has no `node` on a non-interactive PATH, so `bunx
+ * wrangler` runs wrangler under Bun — and under Bun it sometimes exits 0 part-way through its
+ * first API request, having printed nothing but its banner. `binary-server`'s edge deploy did it
+ * twice in a row and deployed nothing. For this step that is a schema that "passed" without
+ * running: the new code ships, and the first request touching the new column 500s in production
+ * while the smoke's census of existing routes stays green.
+ *
+ * So the step asks for `--json` and requires what wrangler prints when a query ran: an array with
+ * 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}` };
+	// 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}` };
+	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})` };
+	}
+	if (!Array.isArray(parsed) || parsed.length === 0) return { applied: false, 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` };
 }
 
 /**
@@ -505,7 +555,19 @@ 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)) {
-			if (deps.run(argv, spec.credential) !== 0) return stop("schema", "the schema did not apply — nothing was deployed.");
+			// 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> } => {
+				const { code, stdout } = deps.capture(argv, spec.credential);
+				return { code, verdict: judgeSchemaApply(code, stdout) };
+			};
+			let { code, verdict } = attempt();
+			if (!verdict.applied && code === 0) {
+				error(`  🟡 ${verdict.line} — retrying once`);
+				({ code, verdict } = attempt());
+			}
+			if (!verdict.applied) return stop("schema", `the schema did not apply (${verdict.line}) — nothing was deployed.`);
+			log(`  ${verdict.line}`);
 		}
 	}
 	step(`deploy ${spec.workerName} @ ${commit.slice(0, 8)}${dirty ? " (dirty — stage only)" : ""}`);