cursedops 0.10.22 → 0.10.23

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "cursedops",
-	"version": "0.10.22",
+	"version": "0.10.23",
 	"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

@@ -923,6 +923,46 @@ export function judgeTailCapture(text: string, opts: JudgeOpts): TailVerdict {
 	return { ok: failures.length === 0, failures, report, recorded, traces: traces.length };
 }
 
+/** What `wrangler tail --format json` says a request did besides spend CPU. */
+interface TailTraceLike {
+	scriptName?: string;
+	outcome?: string;
+	event?: { request?: { url?: string; method?: string } };
+	logs?: Array<{ level?: string; message?: unknown }>;
+	exceptions?: Array<{ name?: string; message?: string }>;
+}
+
+/**
+ * Every `console.*` line, exception and non-`ok` outcome this Worker produced in a capture, one line
+ * each, prefixed with the request that produced it. Pure.
+ *
+ * 🔴 Why it exists (task 2224): vault's stage walk went red with `callback → 302, NO cookie` while
+ * this tail was attached, and the consumer's own `console.warn` naming the cause was IN the capture —
+ * then thrown away, because only CPU was read out of it. Neither suspected cause reproduced after the
+ * fact. A failed command now prints what the Worker said while it failed.
+ */
+export function workerTailEvents(traces: readonly unknown[], scriptName: string): string[] {
+	const out: string[] = [];
+	for (const raw of traces as TailTraceLike[]) {
+		if (!raw || raw.scriptName !== scriptName) continue;
+		const req = raw.event?.request;
+		let where = "(no request)";
+		if (req?.url) {
+			const url = new URL(req.url);
+			// A path, never a query: a grant or a token rides there, and this goes to a log file.
+			where = `${req.method ?? "GET"} ${url.pathname}`;
+		}
+		for (const log of raw.logs ?? []) {
+			const parts = Array.isArray(log.message) ? log.message : [log.message];
+			const text = parts.map((p) => (typeof p === "string" ? p : JSON.stringify(p))).join(" ");
+			out.push(`${where} — ${log.level ?? "log"}: ${text}`);
+		}
+		for (const ex of raw.exceptions ?? []) out.push(`${where} — exception ${ex.name ?? "Error"}: ${ex.message ?? ""}`);
+		if (raw.outcome && raw.outcome !== "ok") out.push(`${where} — outcome ${raw.outcome}`);
+	}
+	return out;
+}
+
 /** The verdict in words, for the deploy log. */
 export function formatTailVerdict(verdict: TailVerdict, bench: Pick<TailBench, "formatCpuBudgetReport">, scriptName: string): string {
 	const r = verdict.recorded;
@@ -1134,7 +1174,15 @@ export async function runWorkerCpuTail(spec: WorkerCpuTailSpec, deps: WorkerCpuD
 	deps.log(`\n${formatTailVerdict(verdict, spec.bench, spec.workerName)}`);
 	if (!drained) deps.error(`🔴 ${tag} the end marker never came back — the capture may be missing the command's last requests.`);
 
-	if (ran !== 0) return { code: ran, step: "command", verdict };
+	if (ran !== 0) {
+		const said = workerTailEvents(spec.bench.parseTailLines(tail.captured()), spec.workerName);
+		deps.error(
+			said.length > 0
+				? `\n${tag} what ${spec.workerName} logged while \`${spec.command.join(" ")}\` failed:\n${said.map((s) => `  ${s}`).join("\n")}`
+				: `\n${tag} ${spec.workerName} logged nothing while \`${spec.command.join(" ")}\` failed — no console line, exception or failed outcome.`,
+		);
+		return { code: ran, step: "command", verdict };
+	}
 	if (!drained) return { code: 1, step: "drain", verdict };
 	return verdict.ok ? { code: 0, step: "done", verdict } : { code: 1, step: "budget", verdict };
 }