cozyclay 2.1.1 → 3.0.1

package/tools/demo-worker/api-client.mjs

@@ -1,233 +0,0 @@
-/**
- * Outbound-only client for the Workers demo queue.
- *
- * Every request is signed immediately before fetch. No server, socket, or
- * long-lived connection is created here; the worker only opens connections
- * initiated by fetch().
- */
-
-import { bodyBytes, randomNonce, signedHeaders } from "./sign-core.mjs";
-
-class DemoApiError extends Error {
-	constructor(status, code, body = null) {
-		super(`demo API ${status}${code ? ` ${code}` : ""}`);
-		this.name = "DemoApiError";
-		this.status = status;
-		this.code = code || `http_${status}`;
-		this.body = body;
-	}
-}
-
-function pathFor(url) {
-	return `${url.pathname}${url.search}`;
-}
-
-function normalizeBase(value) {
-	if (!value) throw new TypeError("CC_DEMO_API_BASE is required");
-	const base = new URL(String(value));
-	// URL(base, path) treats a pathless URL as a file. A trailing slash makes
-	// both `https://host` and an explicitly configured `/api/` prefix behave
-	// predictably.
-	if (!base.pathname.endsWith("/")) base.pathname += "/";
-	return base;
-}
-
-async function responseBody(response) {
-	if (response.status === 204) return null;
-	if (typeof response.text !== "function") {
-		if (typeof response.json === "function") return response.json();
-		return null;
-	}
-	const text = await response.text();
-	if (!text) return null;
-	try {
-		return JSON.parse(text);
-	} catch {
-		return text;
-	}
-}
-
-function errorCode(body, status) {
-	if (body && typeof body === "object") return body.error ?? body.code ?? body.reason ?? `http_${status}`;
-	if (typeof body === "string" && body) return body;
-	return `http_${status}`;
-}
-
-function asJob(body) {
-	if (!body || typeof body !== "object") return body;
-	const jobId = body.jobId ?? body.job_id;
-	const leaseToken = body.leaseToken ?? body.lease_token;
-	const leaseExpiresAt = body.leaseExpiresAt ?? body.lease_expires_at;
-	const duration = body.duration ?? body.durationS ?? body.duration_s;
-	return {
-		...body,
-		jobId,
-		job_id: body.job_id ?? jobId,
-		leaseToken,
-		lease_token: body.lease_token ?? leaseToken,
-		leaseExpiresAt,
-		lease_expires_at: body.lease_expires_at ?? leaseExpiresAt,
-		duration,
-		durationS: body.durationS ?? duration,
-	};
-}
-
-/**
- * The API surface is intentionally small and mirrors the four Worker routes.
- * `fetchImpl`, `now`, and `nonceFactory` are injectable to make protocol tests
- * deterministic without changing production behavior.
- */
-class DemoApiClient {
-	constructor({
-		baseUrl = process.env.CC_DEMO_API_BASE,
-		base,
-		secret,
-		workerId = process.env.CC_WORKER_ID,
-		fetchImpl = globalThis.fetch,
-		fetch: fetchOverride,
-		now = () => Date.now(),
-		nonceFactory = randomNonce,
-	} = {}) {
-		this.baseUrl = normalizeBase(baseUrl ?? base);
-		this.secret = secret ?? process.env.CC_WORKER_SECRET;
-		this.workerId = workerId;
-		this.fetchImpl = fetchOverride || fetchImpl;
-		this.now = typeof now === "function" ? now : () => Number(now);
-		this.nonceFactory = typeof nonceFactory === "function" ? nonceFactory : () => String(nonceFactory);
-		if (typeof this.fetchImpl !== "function") throw new TypeError("global fetch is unavailable");
-		if (!this.secret) throw new TypeError("CC_WORKER_SECRET is required");
-		if (!this.workerId) throw new TypeError("CC_WORKER_ID is required");
-	}
-
-	urlFor(path) {
-		const value = String(path || "/");
-		return new URL(value.startsWith("/") ? value.slice(1) : value, this.baseUrl);
-	}
-
-	signRequest({ method = "GET", path = "/", body = new Uint8Array(), jobId = "", leaseToken = "", ts, nonce } = {}) {
-		return signedHeaders({
-			secret: this.secret,
-			workerId: this.workerId,
-			method,
-			path,
-			jobId,
-			leaseToken,
-			body,
-			ts: ts ?? this.now(),
-			nonce: nonce ?? this.nonceFactory(),
-		});
-	}
-
-	async request(method, path, {
-		jobId = "",
-		leaseToken = "",
-		body = new Uint8Array(),
-		contentType = null,
-		signal,
-	} = {}) {
-		const url = this.urlFor(path);
-		const bytes = bodyBytes(body);
-		const headers = this.signRequest({
-			method,
-			path: pathFor(url),
-			jobId,
-			leaseToken,
-			body: bytes,
-		});
-		if (contentType) headers["Content-Type"] = contentType;
-		if (bytes.byteLength > 0 || method !== "GET") headers["Content-Length"] = String(bytes.byteLength);
-		const init = {
-			method: String(method).toUpperCase(),
-			headers,
-			signal,
-		};
-		// Undici rejects a GET/HEAD request with a body. An empty POST is valid
-		// without an explicit body and still hashes as SHA-256(empty).
-		if (bytes.byteLength > 0) init.body = Buffer.from(bytes);
-		const response = await this.fetchImpl(url.toString(), init);
-		const bodyValue = await responseBody(response);
-		const ok = response.ok ?? (response.status >= 200 && response.status < 300);
-		if (!ok) throw new DemoApiError(response.status, errorCode(bodyValue, response.status), bodyValue);
-		return bodyValue;
-	}
-
-	async next({ signal } = {}) {
-		const body = await this.request("GET", "/worker/next", { signal });
-		return body == null ? null : asJob(body);
-	}
-
-	async complete(jobId, leaseToken, npzBuffer, { signal } = {}) {
-		if (!jobId || !leaseToken) throw new TypeError("jobId and leaseToken are required");
-		const bytes = bodyBytes(npzBuffer);
-		return this.request("POST", "/worker/complete", {
-			jobId,
-			leaseToken,
-			body: bytes,
-			contentType: "application/octet-stream",
-			signal,
-		});
-	}
-
-	async fail(jobId, leaseToken, reason = "worker_failed", { signal } = {}) {
-		if (!jobId || !leaseToken) throw new TypeError("jobId and leaseToken are required");
-		const body = Buffer.from(JSON.stringify({ reason: String(reason || "worker_failed") }));
-		return this.request("POST", "/worker/fail", {
-			jobId,
-			leaseToken,
-			body,
-			contentType: "application/json",
-			signal,
-		});
-	}
-
-	async heartbeat(jobId, leaseToken, { jobsDone10m = 0, signal } = {}) {
-		if (!jobId || !leaseToken) throw new TypeError("jobId and leaseToken are required");
-		// The route accepts an empty body. Keeping it empty makes the canonical
-		// request-target/body hash unambiguous while still allowing an optional
-		// throughput counter for operators that use it.
-		const body = jobsDone10m
-			? Buffer.from(JSON.stringify({ jobs_done_10m: Number(jobsDone10m) }))
-			: new Uint8Array();
-		return this.request("POST", "/worker/heartbeat", {
-			jobId,
-			leaseToken,
-			body,
-			contentType: body.byteLength ? "application/json" : null,
-			signal,
-		});
-	}
-}
-
-export function createApiClient(options = {}) {
-	return new DemoApiClient(options);
-}
-
-let defaultClient = null;
-function envClient() {
-	if (!defaultClient) defaultClient = createApiClient();
-	return defaultClient;
-}
-
-function next(options) {
-	return envClient().next(options);
-}
-
-function complete(jobId, leaseToken, npzBuffer, options) {
-	return envClient().complete(jobId, leaseToken, npzBuffer, options);
-}
-
-function fail(jobId, leaseToken, reason, options) {
-	return envClient().fail(jobId, leaseToken, reason, options);
-}
-
-function heartbeat(jobId, leaseToken, options) {
-	return envClient().heartbeat(jobId, leaseToken, options);
-}
-
-function signRequest(secretOrOptions, maybeOptions) {
-	if (typeof secretOrOptions === "string") {
-		return signedHeaders({ ...(maybeOptions || {}), secret: secretOrOptions });
-	}
-	return signedHeaders(secretOrOptions);
-}
-

package/tools/demo-worker/generate.mjs

@@ -1,301 +0,0 @@
-/**
- * Generate one demo result with the existing local ARDY runner.
- *
- * This module owns the child process boundary. The poller never shells out
- * directly: createLocalRunner() builds the same argv/env contract used by the
- * bridge, and this file only supervises that command, reads its npz, and
- * enforces the absolute hard timeout.
- */
-
-import { mkdtempSync, readFileSync, rmSync, statSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { spawn } from "node:child_process";
-import { createConnection } from "node:net";
-import { createLocalRunner } from "../ardy/runners/local.mjs";
-import { killGroup, track } from "../ardy/runners/proc.mjs";
-import { POLICY } from "../../workers/api/src/policy.js";
-
-const JOB_HARD_TIMEOUT_MS = POLICY.JOB_HARD_TIMEOUT_MS;
-const DEFAULT_TIMEOUT_ENV = ["CC_JOB_HARD_TIMEOUT_MS", "JOB_HARD_TIMEOUT_MS"];
-let sharedRunner = null;
-
-function defaultRunner() {
-	if (!sharedRunner) sharedRunner = createLocalRunner();
-	return sharedRunner;
-}
-
-function localWorkerReady(timeoutMs = 3000) {
-	const port = Number(process.env.CCLAY_ARDY_WORKER_PORT) || 9552;
-	return new Promise((resolvePromise) => {
-		const socket = createConnection({ host: "127.0.0.1", port });
-		let settled = false;
-		const finish = (ready) => {
-			if (settled) return;
-			settled = true;
-			socket.destroy();
-			resolvePromise(ready);
-		};
-		socket.setTimeout(timeoutMs, () => finish(false));
-		socket.once("error", () => finish(false));
-		socket.once("close", () => finish(false));
-		socket.once("connect", () => socket.write('{"mode":"ping"}\n'));
-		socket.on("data", (chunk) => {
-			if (String(chunk).includes("worker: pong")) finish(true);
-		});
-	});
-}
-
-function configuredTimeout(value) {
-	if (value != null) {
-		const numeric = Number(value);
-		if (Number.isFinite(numeric) && numeric > 0) return numeric;
-	}
-	for (const name of DEFAULT_TIMEOUT_ENV) {
-		const numeric = Number(process.env[name]);
-		if (Number.isFinite(numeric) && numeric > 0) return numeric;
-	}
-	return JOB_HARD_TIMEOUT_MS;
-}
-
-function abortError(signal) {
-	const error = signal?.reason instanceof Error ? signal.reason : new Error("generation aborted");
-	if (!signal?.reason || error.name === "Error") error.name = "AbortError";
-	return error;
-}
-
-function commandError(command, code, stderr, stdout) {
-	const detail = String(stderr || stdout || "no output").trim().split("\n").slice(-1)[0];
-	const error = new Error(`${command?.label || "ARDY"} failed (exit ${code}): ${detail}`);
-	error.code = "GENERATION_FAILED";
-	return error;
-}
-
-function outputMarker(command, stdout) {
-	if (!command?.doneRe) return null;
-	const lines = String(stdout || "").split(/\r?\n/u);
-	for (let index = lines.length - 1; index >= 0; index -= 1) {
-		const match = command.doneRe.exec(lines[index]);
-		if (match) return { path: match[1], bytes: Number(match[2]) };
-	}
-	return null;
-}
-
-function spawnCommand(command, spawnImpl = spawn) {
-	const child = spawnImpl(command.command, command.args || [], {
-		cwd: command.cwd || process.cwd(),
-		detached: true,
-		stdio: ["ignore", "pipe", "pipe"],
-		env: command.env,
-	});
-	track(child);
-	return child;
-}
-
-function waitForChild(child) {
-	return new Promise((resolvePromise, reject) => {
-		let stdout = "";
-		let stderr = "";
-		let settled = false;
-		const finish = (fn, value) => {
-			if (settled) return;
-			settled = true;
-			fn(value);
-		};
-		child.stdout?.setEncoding?.("utf8");
-		child.stderr?.setEncoding?.("utf8");
-		child.stdout?.on("data", (chunk) => {
-			stdout += chunk.toString();
-		});
-		child.stderr?.on("data", (chunk) => {
-			stderr += chunk.toString();
-		});
-		child.once("error", (error) => finish(reject, error));
-		child.once("close", (code, signal) => finish(resolvePromise, { code, signal, stdout, stderr }));
-	});
-}
-
-/**
- * Supervise a runner command and return its output as a Buffer.
- *
- * `runner` is injectable so loop tests can use a tiny fixture command without
- * installing ARDY. Production callers leave it unset and get
- * createLocalRunner().
- */
-async function generate(prompt, durationS, options = {}) {
-	// Accept both generate(prompt, duration, options) and generate({prompt,
-	// duration}, options). The latter is convenient for queue adapters and does
-	// not change the public positional contract.
-	if (prompt && typeof prompt === "object") {
-		const job = prompt;
-		const suppliedOptions = durationS && typeof durationS === "object" ? durationS : {};
-		prompt = job.prompt ?? job.prompt_text;
-		durationS = job.durationS ?? job.duration_s ?? job.duration;
-		options = { ...suppliedOptions, ...(options && typeof options === "object" ? options : {}) };
-	}
-	const {
-		runner = null,
-		timeoutMs,
-		signal,
-		outputPath = null,
-		tempRoot = tmpdir(),
-		spawnImpl = spawn,
-		keepOutput = false,
-	} = options || {};
-	if (typeof prompt !== "string" || !prompt.trim()) throw new TypeError("prompt is required");
-	if (!Number.isFinite(Number(durationS)) || Number(durationS) <= 0) throw new TypeError("duration must be positive");
-	if (signal?.aborted) throw abortError(signal);
-
-	const backend = runner || defaultRunner();
-	let tempDir = null;
-	let output = outputPath;
-	if (!output) {
-		tempDir = mkdtempSync(join(tempRoot, "cozyclay-demo-worker-"));
-		output = join(tempDir, "result.npz");
-	}
-
-	let child = null;
-	let timer = null;
-	let timedOut = false;
-	let aborted = false;
-	const timeout = configuredTimeout(timeoutMs);
-	const abortHandler = () => {
-		aborted = true;
-		if (child) killGroup(child);
-	};
-	signal?.addEventListener?.("abort", abortHandler, { once: true });
-	try {
-		if (typeof backend.singleCommand !== "function") {
-			throw new TypeError("local runner does not provide singleCommand()");
-		}
-		const command = await backend.singleCommand({
-			poseFroms: [],
-			prompt,
-			durationS: Number(durationS),
-			output,
-		});
-		if (!command || typeof command.command !== "string") throw new TypeError("runner returned an invalid command");
-		if (aborted || signal?.aborted) throw abortError(signal);
-		child = spawnCommand(command, spawnImpl);
-		const childDone = waitForChild(child);
-		timer = setTimeout(() => {
-			timedOut = true;
-			killGroup(child);
-		}, timeout);
-		timer.unref?.();
-		const result = await childDone;
-		if (timedOut) {
-			const error = new Error(`generation exceeded JOB_HARD_TIMEOUT_MS (${timeout} ms)`);
-			error.name = "TimeoutError";
-			error.code = "JOB_HARD_TIMEOUT";
-			throw error;
-		}
-		if (aborted || signal?.aborted) throw abortError(signal);
-		if (result.code !== 0) throw commandError(command, result.code, result.stderr, result.stdout);
-		let size;
-		try {
-			size = statSync(output).size;
-		} catch {
-			throw new Error("generator exited successfully but produced no npz output");
-		}
-		if (!Number.isSafeInteger(size) || size <= 0) throw new Error("generator produced an empty npz output");
-		const marker = outputMarker(command, result.stdout);
-		if (marker && (marker.path !== output || marker.bytes !== size)) {
-			throw new Error(`generator output marker mismatch for ${output}`);
-		}
-		return readFileSync(output);
-	} finally {
-		if (timer) clearTimeout(timer);
-		signal?.removeEventListener?.("abort", abortHandler);
-		if (tempDir && !keepOutput) {
-			try {
-				rmSync(tempDir, { recursive: true, force: true });
-			} catch {
-				// A failed cleanup must not mask generation/lease errors.
-			}
-		}
-	}
-}
-
-/**
- * Return a service object for index.mjs. `prepare()` is intentionally
- * idempotent for injected runners and, for createLocalRunner(), waits for the
- * actual generation worker rather than merely probing device/encoder health.
- */
-export function createGenerator({ runner = null, workerReady = localWorkerReady, ...defaults } = {}) {
-	const backend = runner || defaultRunner();
-	const workerIdleMs = Number(process.env.CCLAY_ARDY_WORKER_IDLE_S) > 0
-		? Number(process.env.CCLAY_ARDY_WORKER_IDLE_S) * 1000
-		: 3600 * 1000;
-	let warmedAt = 0;
-	let warming = null;
-	const warmWithCommand = async () => {
-		const warmDir = mkdtempSync(join(tmpdir(), "cozyclay-demo-prewarm-"));
-		try {
-			const command = await backend.singleCommand({
-				poseFroms: [],
-				prompt: "cozyclay demo worker prewarm",
-				durationS: 0.2,
-				output: join(warmDir, "discarded.npz"),
-			});
-			if (!command) throw new Error("local runner did not return a warm command");
-			if (backend.mode === "local" && typeof backend.probeHealth === "function" && !(await workerReady())) {
-				throw new Error("local generation worker did not become warm");
-			}
-			warmedAt = Date.now();
-			return { ok: true, warm: true };
-		} finally {
-			try {
-				rmSync(warmDir, { recursive: true, force: true });
-			} catch {
-				// A failed cleanup must not turn a warm worker into a false
-				// negative.
-			}
-		}
-	};
-	return {
-		runner: backend,
-		async prepare({ force = false } = {}) {
-			if (typeof backend.prepare === "function") return backend.prepare();
-			if (typeof backend.prewarm === "function") return backend.prewarm();
-			if (typeof backend.ensureWorker === "function") return backend.ensureWorker();
-			// createLocalRunner() intentionally keeps its warm-worker helper
-			// private. Calling singleCommand() with a throwaway output path
-			// exercises that same ensureBackends(false) path and, crucially,
-			// does not spawn a generation child. Its promise resolves only after
-			// workerStatus() confirms the loopback worker is accepting work.
-			if (typeof backend.singleCommand === "function") {
-				if (!force && warmedAt && Date.now() - warmedAt < workerIdleMs) {
-					if (backend.mode !== "local" || await workerReady()) {
-						return { ok: true, warm: true, cached: true };
-					}
-					warmedAt = 0;
-				}
-				if (!warming) {
-					warming = warmWithCommand()
-						.catch((error) => {
-							warmedAt = 0;
-							throw error;
-						})
-						.finally(() => {
-							warming = null;
-						});
-				}
-				return warming;
-			}
-			return {
-				ok: false,
-				ready: false,
-				reason: "warm_worker_unconfirmed: runner exposes no awaitable warm-worker hook",
-			};
-		},
-		invalidateWarm() {
-			warmedAt = 0;
-		},
-		generate(prompt, durationS, options = {}) {
-			return generate(prompt, durationS, { ...defaults, ...options, runner: backend });
-		},
-	};
-}
-
-