cozyclay 1.1.0 → 1.3.0

package/tools/generation/providers/runway.mjs

@@ -0,0 +1,101 @@
+const API = "https://api.dev.runwayml.com/v1";
+const VERSION = "2024-11-06";
+
+export const RUNWAY_MODELS = Object.freeze([
+  { id: "gen4_turbo", label: "Runway Gen-4 Turbo", endpoint: "image_to_video", durations: [2, 3, 4, 5, 6, 7, 8, 9, 10], costPerSecondUsd: 0.05, capabilities: { prompt: true, startFrame: true, endFrame: false, referenceVideo: false, audio: false } },
+  { id: "gen4.5", label: "Runway Gen-4.5", endpoint: "image_to_video", durations: [2, 3, 4, 5, 6, 7, 8, 9, 10], costPerSecondUsd: 0.12, capabilities: { prompt: true, startFrame: true, endFrame: false, referenceVideo: false, audio: false } },
+  { id: "seedance2", label: "Seedance 2.0 via Runway", endpoint: "image_to_video", durations: [2, 3, 4, 5, 6, 7, 8, 9, 10], costPerSecondUsd: 0.36, capabilities: { prompt: true, startFrame: true, endFrame: false, referenceVideo: false, audio: true } },
+  { id: "veo3.1", label: "Google Veo 3.1 via Runway", endpoint: "image_to_video", durations: [4, 6, 8], costPerSecondUsd: 0.4, capabilities: { prompt: true, startFrame: true, endFrame: false, referenceVideo: false, audio: true } },
+]);
+
+const RETRYABLE = new Set([429, 502, 503, 504]);
+
+async function runwayFetch(url, options, { fetchImpl, signal, timeoutMs = 15000, retries = 3, sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)), random = Math.random }) {
+  let response;
+  for (let attempt = 0; attempt <= retries; attempt += 1) {
+    const timeout = AbortSignal.timeout(timeoutMs);
+    const attemptSignal = signal ? AbortSignal.any([signal, timeout]) : timeout;
+    try {
+      response = await fetchImpl(url, { ...options, signal: attemptSignal });
+    } catch (error) {
+      if (signal?.aborted || attempt === retries) throw error;
+      await sleep(250 * (2 ** attempt) * (1 + random() * 0.5));
+      continue;
+    }
+    if (!RETRYABLE.has(response.status) || attempt === retries) return response;
+    await response.body?.cancel().catch(() => {});
+    await sleep(250 * (2 ** attempt) * (1 + random() * 0.5));
+  }
+  return response;
+}
+
+function headers(apiKey) {
+  return { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json", "X-Runway-Version": VERSION };
+}
+
+function modelOf(id) {
+  if (typeof id !== "string" || !id) throw new Error("model is required");
+  const model = RUNWAY_MODELS.find((candidate) => candidate.id === id);
+  if (!model) throw new Error(`unsupported Runway model: ${id}`);
+  return model;
+}
+
+export function estimateRunwayCost(spec) {
+  const model = modelOf(spec.model);
+  return Number((model.costPerSecondUsd * spec.durationSeconds).toFixed(2));
+}
+
+export function validateRunwaySpec(spec) {
+  const model = modelOf(spec.model);
+  const errors = [];
+  const warnings = [];
+  if (!spec.prompt?.trim()) errors.push("prompt is required");
+  if (spec.prompt?.length > 1000) errors.push("Runway prompt must be at most 1000 UTF-16 code units");
+  if (!model.durations.includes(spec.durationSeconds)) errors.push(`${model.label} duration must be ${model.durations.join(" or ")} seconds`);
+  if (!spec.conditioning?.startFrame) errors.push(`${model.label} requires a start frame`);
+  if (spec.conditioning?.startFrame?.startsWith("data:") && spec.conditioning.startFrame.length > 5 * 1024 * 1024) errors.push("Runway data URI images must be at most 5 MB encoded");
+  if (spec.conditioning?.endFrame && !model.capabilities.endFrame) warnings.push("end frame is not supported by this adapter and will not be sent");
+  if (spec.conditioning?.referenceVideo && !model.capabilities.referenceVideo) warnings.push("reference video is not supported by this adapter and will not be sent");
+  return { ok: errors.length === 0, errors, warnings, model };
+}
+
+export async function submitRunway(spec, { apiKey = process.env.RUNWAYML_API_SECRET, fetchImpl = fetch, signal, ...retryOptions } = {}) {
+  if (!apiKey) throw new Error("RUNWAYML_API_SECRET is not configured");
+  const verdict = validateRunwaySpec(spec);
+  if (!verdict.ok) throw new Error(verdict.errors[0]);
+  const body = {
+    model: spec.model,
+    promptText: spec.prompt,
+    promptImage: spec.conditioning.startFrame,
+    ratio: spec.aspectRatio === "9:16" ? "720:1280" : "1280:720",
+    duration: spec.durationSeconds,
+  };
+  if (Number.isInteger(spec.seed)) body.seed = spec.seed;
+  const response = await runwayFetch(`${API}/${verdict.model.endpoint}`, { method: "POST", headers: headers(apiKey), body: JSON.stringify(body) }, { fetchImpl, signal, ...retryOptions });
+  const payload = await response.json().catch(() => ({}));
+  if (!response.ok) throw new Error(`Runway submit failed (HTTP ${response.status})`);
+  if (!payload.id) throw new Error("Runway submit response has no task id");
+  return { providerJobId: payload.id, warnings: verdict.warnings };
+}
+
+export async function pollRunway(providerJobId, { apiKey = process.env.RUNWAYML_API_SECRET, fetchImpl = fetch, signal, ...retryOptions } = {}) {
+  if (!apiKey) throw new Error("RUNWAYML_API_SECRET is not configured");
+  const response = await runwayFetch(`${API}/tasks/${encodeURIComponent(providerJobId)}`, { headers: headers(apiKey) }, { fetchImpl, signal, ...retryOptions });
+  const payload = await response.json().catch(() => ({}));
+  if (!response.ok) throw new Error(`Runway poll failed (HTTP ${response.status})`);
+  const state = String(payload.status || "").toUpperCase();
+  const status = state === "SUCCEEDED" ? "succeeded" : state === "FAILED" || state === "CANCELED" ? "failed" : "processing";
+  return { status, progress: payload.progress ?? null, outputUrl: status === "succeeded" ? payload.output?.[0] ?? null : null, failure: status === "failed" ? payload.failure || payload.failureCode || "generation failed" : null, raw: payload };
+}
+
+export const runwayProvider = Object.freeze({
+  id: "runway",
+  label: "Runway",
+  auth: { type: "bearer-env", env: "RUNWAYML_API_SECRET" },
+  available: () => Boolean(process.env.RUNWAYML_API_SECRET),
+  models: RUNWAY_MODELS,
+  validate: validateRunwaySpec,
+  estimateCost: estimateRunwayCost,
+  submit: submitRunway,
+  poll: pollRunway,
+});

package/tools/generation/providers/seedance.mjs

@@ -0,0 +1,87 @@
+import { fetchProviderJson, findModel, noKnownUsdEstimate } from "./shared.mjs";
+
+const API = "https://ark.ap-southeast.bytepluses.com/api/v3/contents/generations/tasks";
+
+export const SEEDANCE_MODELS = Object.freeze([
+  {
+    id: "dreamina-seedance-2-0-260128",
+    label: "Seedance 2.0",
+    durations: Array.from({ length: 12 }, (_, index) => index + 4),
+    resolutions: ["480p", "720p", "1080p", "4k"],
+    capabilities: { prompt: true, startFrame: true, endFrame: true, referenceVideo: true, cameraControl: false, audio: true },
+  },
+]);
+
+const authHeaders = (apiKey) => ({ Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" });
+const modelOf = (id) => findModel(SEEDANCE_MODELS, id, "Seedance");
+
+export function validateSeedanceSpec(spec) {
+  const model = modelOf(spec.model);
+  const errors = [];
+  const warnings = [];
+  if (!spec.prompt?.trim()) errors.push("prompt is required");
+  if (!model.durations.includes(spec.durationSeconds)) errors.push(`${model.label} duration must be an integer from 4 to 15 seconds`);
+  if (!model.resolutions.includes(spec.resolution)) errors.push(`${model.label} resolution must be ${model.resolutions.join(", ")}`);
+  if (!spec.conditioning?.startFrame && !spec.conditioning?.referenceVideo) errors.push(`${model.label} requires a staged start frame or reference video`);
+  if (spec.conditioning?.referenceVideo && (spec.conditioning?.startFrame || spec.conditioning?.endFrame)) errors.push("Seedance first/last-frame and reference-video modes cannot be mixed");
+  if (spec.conditioning?.referenceVideo && !/^https?:\/\/|^asset:\/\//.test(spec.conditioning.referenceVideo)) errors.push("Seedance reference video must be a public URL or ModelArk asset URI");
+  if (spec.seed !== null && spec.seed !== undefined) warnings.push("Seedance 2.0 does not support seed; it will not be sent");
+  if (spec.camera) warnings.push("Seedance 2.0 has no verified camera-trajectory field; staged frames and composed prompt will carry the camera direction");
+  return { ok: errors.length === 0, errors, warnings, model };
+}
+
+export function mapSeedanceRequest(spec) {
+  const verdict = validateSeedanceSpec(spec);
+  if (!verdict.ok) throw new Error(verdict.errors[0]);
+  const content = [{ type: "text", text: spec.prompt }];
+  if (spec.conditioning.startFrame) content.push({ type: "image_url", image_url: { url: spec.conditioning.startFrame }, role: "first_frame" });
+  if (spec.conditioning.endFrame) content.push({ type: "image_url", image_url: { url: spec.conditioning.endFrame }, role: "last_frame" });
+  if (spec.conditioning.referenceVideo) content.push({ type: "video_url", video_url: { url: spec.conditioning.referenceVideo }, role: "reference_video" });
+  return {
+    model: verdict.model.id,
+    content,
+    resolution: spec.resolution,
+    ratio: spec.aspectRatio,
+    duration: spec.durationSeconds,
+    generate_audio: true,
+    watermark: false,
+  };
+}
+
+export async function submitSeedance(spec, { apiKey = process.env.ARK_API_KEY, fetchImpl = fetch, signal, ...retryOptions } = {}) {
+  if (!apiKey) throw new Error("ARK_API_KEY is not configured");
+  const verdict = validateSeedanceSpec(spec);
+  if (!verdict.ok) throw new Error(verdict.errors[0]);
+  const { response, payload } = await fetchProviderJson(API, { method: "POST", headers: authHeaders(apiKey), body: JSON.stringify(mapSeedanceRequest(spec)) }, { fetchImpl, signal, ...retryOptions });
+  if (!response.ok) throw new Error(`Seedance submit failed (HTTP ${response.status})`);
+  if (!payload.id) throw new Error("Seedance submit response has no task id");
+  return { providerJobId: payload.id, warnings: verdict.warnings };
+}
+
+export async function pollSeedance(providerJobId, { apiKey = process.env.ARK_API_KEY, fetchImpl = fetch, signal, ...retryOptions } = {}) {
+  if (!apiKey) throw new Error("ARK_API_KEY is not configured");
+  const { response, payload } = await fetchProviderJson(`${API}/${encodeURIComponent(providerJobId)}`, { headers: authHeaders(apiKey) }, { fetchImpl, signal, ...retryOptions });
+  if (!response.ok) throw new Error(`Seedance poll failed (HTTP ${response.status})`);
+  const remote = String(payload.status || "").toLowerCase();
+  const status = remote === "succeeded" ? "succeeded" : ["failed", "expired", "canceled", "cancelled"].includes(remote) ? "failed" : "processing";
+  return { status, progress: null, outputUrl: status === "succeeded" ? payload.content?.video_url ?? null : null, failure: status === "failed" ? payload.error?.message || `generation ${remote || "failed"}` : null, raw: payload };
+}
+
+export async function cancelSeedance(providerJobId, { apiKey = process.env.ARK_API_KEY, fetchImpl = fetch, signal, ...retryOptions } = {}) {
+  if (!apiKey) throw new Error("ARK_API_KEY is not configured");
+  const { response } = await fetchProviderJson(`${API}/${encodeURIComponent(providerJobId)}`, { method: "DELETE", headers: authHeaders(apiKey) }, { fetchImpl, signal, ...retryOptions });
+  if (!response.ok) throw new Error(`Seedance cancel failed (HTTP ${response.status})`);
+}
+
+export const seedanceProvider = Object.freeze({
+  id: "seedance",
+  label: "Seedance / BytePlus ModelArk",
+  auth: { type: "bearer-env", env: "ARK_API_KEY" },
+  available: () => Boolean(process.env.ARK_API_KEY),
+  models: SEEDANCE_MODELS,
+  validate: validateSeedanceSpec,
+  estimateCost: noKnownUsdEstimate,
+  submit: submitSeedance,
+  poll: pollSeedance,
+  cancel: cancelSeedance,
+});

package/tools/generation/providers/shared.mjs

@@ -0,0 +1,49 @@
+const RETRYABLE = new Set([429, 500, 502, 503, 504]);
+
+export function findModel(models, id, providerLabel) {
+  if (typeof id !== "string" || !id) throw new Error("model is required");
+  const model = models.find((candidate) => candidate.id === id);
+  if (!model) throw new Error(`unsupported ${providerLabel} model: ${id}`);
+  return model;
+}
+
+export async function fetchProviderJson(url, options, {
+  fetchImpl = fetch,
+  signal,
+  timeoutMs = 15000,
+  retries = 3,
+  sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+  random = Math.random,
+} = {}) {
+  let response;
+  for (let attempt = 0; attempt <= retries; attempt += 1) {
+    const timeout = AbortSignal.timeout(timeoutMs);
+    const attemptSignal = signal ? AbortSignal.any([signal, timeout]) : timeout;
+    try {
+      response = await fetchImpl(url, { ...options, signal: attemptSignal });
+    } catch (error) {
+      if (signal?.aborted || attempt === retries) throw error;
+      await sleep(250 * (2 ** attempt) * (1 + random() * 0.5));
+      continue;
+    }
+    if (!RETRYABLE.has(response.status) || attempt === retries) break;
+    await response.body?.cancel().catch(() => {});
+    await sleep(250 * (2 ** attempt) * (1 + random() * 0.5));
+  }
+  const payload = await response.json().catch(() => ({}));
+  return { response, payload };
+}
+
+export function imageForVertex(value) {
+  if (typeof value !== "string" || !value) return null;
+  const data = value.match(/^data:(image\/(?:jpeg|png|webp));base64,([A-Za-z0-9+/=]+)$/);
+  if (data) return { bytesBase64Encoded: data[2], mimeType: data[1] };
+  if (value.startsWith("gs://")) {
+    const extension = value.match(/\.(png|webp|jpe?g)(?:$|[?#])/i)?.[1]?.toLowerCase();
+    const mimeType = extension === "png" ? "image/png" : extension === "webp" ? "image/webp" : "image/jpeg";
+    return { gcsUri: value, mimeType };
+  }
+  throw new Error("Veo conditioning images must be data URIs or gs:// Cloud Storage URIs");
+}
+
+export const noKnownUsdEstimate = () => null;

package/tools/generation/providers/veo.mjs

@@ -0,0 +1,84 @@
+import { fetchProviderJson, findModel, imageForVertex, noKnownUsdEstimate } from "./shared.mjs";
+
+export const VEO_MODELS = Object.freeze([
+  { id: "veo-3.1-generate-001", label: "Google Veo 3.1", durations: [4, 6, 8], resolutions: ["720p", "1080p"], capabilities: { prompt: true, startFrame: true, endFrame: true, referenceVideo: false, cameraControl: false, audio: true } },
+  { id: "veo-3.1-fast-generate-001", label: "Google Veo 3.1 Fast", durations: [4, 6, 8], resolutions: ["720p", "1080p"], capabilities: { prompt: true, startFrame: true, endFrame: true, referenceVideo: false, cameraControl: false, audio: true } },
+]);
+
+const modelOf = (id) => findModel(VEO_MODELS, id, "Veo");
+const authHeaders = (token) => ({ Authorization: `Bearer ${token}`, "Content-Type": "application/json; charset=utf-8" });
+const endpoint = ({ project, location, model }) => `https://${location}-aiplatform.googleapis.com/v1/projects/${encodeURIComponent(project)}/locations/${encodeURIComponent(location)}/publishers/google/models/${encodeURIComponent(model)}`;
+
+export function validateVeoSpec(spec) {
+  const model = modelOf(spec.model);
+  const errors = [];
+  const warnings = [];
+  if (!spec.prompt?.trim()) errors.push("prompt is required");
+  if (!model.durations.includes(spec.durationSeconds)) errors.push(`${model.label} duration must be 4, 6, or 8 seconds`);
+  if (!model.resolutions.includes(spec.resolution)) errors.push(`${model.label} resolution must be 720p or 1080p`);
+  if (!spec.conditioning?.startFrame) errors.push(`${model.label} requires a staged start frame`);
+  for (const frame of [spec.conditioning?.startFrame, spec.conditioning?.endFrame].filter(Boolean)) {
+    try { imageForVertex(frame); } catch (error) { errors.push(error.message); }
+  }
+  if (spec.conditioning?.referenceVideo) warnings.push("Veo 3.1 reference-video input is not supported by this adapter and will not be sent");
+  if (spec.camera) warnings.push("Veo has no camera-trajectory field; staged frames and composed prompt will carry the authored camera move");
+  return { ok: errors.length === 0, errors, warnings, model };
+}
+
+export function mapVeoRequest(spec) {
+  const verdict = validateVeoSpec(spec);
+  if (!verdict.ok) throw new Error(verdict.errors[0]);
+  const instance = { prompt: spec.prompt, image: imageForVertex(spec.conditioning.startFrame) };
+  if (spec.conditioning.endFrame) instance.lastFrame = imageForVertex(spec.conditioning.endFrame);
+  const parameters = { aspectRatio: spec.aspectRatio, durationSeconds: spec.durationSeconds, resolution: spec.resolution, sampleCount: 1, generateAudio: true };
+  if (Number.isInteger(spec.seed)) parameters.seed = spec.seed;
+  return { instances: [instance], parameters };
+}
+
+function config(options) {
+  return {
+    token: options.token ?? process.env.GOOGLE_CLOUD_ACCESS_TOKEN,
+    project: options.project ?? process.env.GOOGLE_CLOUD_PROJECT,
+    location: options.location ?? process.env.GOOGLE_CLOUD_LOCATION ?? "us-central1",
+  };
+}
+
+export async function submitVeo(spec, { fetchImpl = fetch, signal, ...options } = {}) {
+  const cfg = config(options);
+  if (!cfg.token || !cfg.project) throw new Error("GOOGLE_CLOUD_ACCESS_TOKEN and GOOGLE_CLOUD_PROJECT are required");
+  const verdict = validateVeoSpec(spec);
+  if (!verdict.ok) throw new Error(verdict.errors[0]);
+  const url = `${endpoint({ ...cfg, model: spec.model })}:predictLongRunning`;
+  const { response, payload } = await fetchProviderJson(url, { method: "POST", headers: authHeaders(cfg.token), body: JSON.stringify(mapVeoRequest(spec)) }, { fetchImpl, signal, ...options });
+  if (!response.ok) throw new Error(`Veo submit failed (HTTP ${response.status})`);
+  if (!payload.name) throw new Error("Veo submit response has no operation name");
+  return { providerJobId: payload.name, warnings: verdict.warnings };
+}
+
+export async function pollVeo(providerJobId, { model = "veo-3.1-generate-001", fetchImpl = fetch, signal, ...options } = {}) {
+  const cfg = config(options);
+  if (!cfg.token || !cfg.project) throw new Error("GOOGLE_CLOUD_ACCESS_TOKEN and GOOGLE_CLOUD_PROJECT are required");
+  modelOf(model);
+  const url = `${endpoint({ ...cfg, model })}:fetchPredictOperation`;
+  const { response, payload } = await fetchProviderJson(url, { method: "POST", headers: authHeaders(cfg.token), body: JSON.stringify({ operationName: providerJobId }) }, { fetchImpl, signal, ...options });
+  if (!response.ok) throw new Error(`Veo poll failed (HTTP ${response.status})`);
+  if (!payload.done) return { status: "processing", progress: null, outputUrl: null, failure: null, raw: payload };
+  if (payload.error) return { status: "failed", progress: null, outputUrl: null, failure: payload.error.message || "generation failed", raw: payload };
+  const video = payload.response?.videos?.[0];
+  const outputUrl = video?.bytesBase64Encoded ? `data:${video.mimeType || "video/mp4"};base64,${video.bytesBase64Encoded}` : video?.gcsUri ?? null;
+  if (!outputUrl) return { status: "failed", progress: null, outputUrl: null, failure: "Veo completed without a video result", raw: payload };
+  if (outputUrl.startsWith("gs://")) return { status: "failed", progress: null, outputUrl: null, failure: "Veo returned a private gs:// result; omit storageUri so the bridge can save returned video bytes locally", raw: payload };
+  return { status: "succeeded", progress: 1, outputUrl, failure: null, raw: payload };
+}
+
+export const veoProvider = Object.freeze({
+  id: "veo",
+  label: "Google Veo / Vertex AI",
+  auth: { type: "oauth-env", env: "GOOGLE_CLOUD_ACCESS_TOKEN", projectEnv: "GOOGLE_CLOUD_PROJECT" },
+  available: () => Boolean(process.env.GOOGLE_CLOUD_ACCESS_TOKEN && process.env.GOOGLE_CLOUD_PROJECT),
+  models: VEO_MODELS,
+  validate: validateVeoSpec,
+  estimateCost: noKnownUsdEstimate,
+  submit: submitVeo,
+  poll: (providerJobId, options) => pollVeo(providerJobId, options),
+});

package/tools/metrics/archive-traffic.mjs

@@ -0,0 +1,138 @@
+#!/usr/bin/env node
+// Archive GitHub repository traffic into .metrics/.
+//
+// GitHub keeps traffic for 14 days. That is shorter than the time it takes to
+// tell whether a launch worked, so this snapshots the numbers and merges them
+// into a permanent time series.
+//
+// The traffic endpoints need repository admin rights, which the Actions
+// GITHUB_TOKEN does not have. So this runs wherever a real credential lives:
+// pass one in GITHUB_TOKEN / GH_TOKEN, or let it fall back to the token git
+// already stores for github.com.
+
+import { writeFile, readFile, mkdir } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { spawn } from "node:child_process";
+import path from "node:path";
+
+const REPO = process.env.TRAFFIC_REPO ?? "HaD0Yun/CozyClay";
+const OUT = path.resolve(process.env.TRAFFIC_OUT ?? ".metrics");
+
+async function resolveToken() {
+	const fromEnv = process.env.GITHUB_TOKEN ?? process.env.GH_TOKEN;
+	if (fromEnv) return fromEnv;
+
+	// git credential fill speaks a key=value protocol on stdin/stdout, and it
+	// blocks until stdin is closed — so the request has to be written and the
+	// pipe ended explicitly.
+	const stdout = await new Promise((resolve) => {
+		const child = spawn("git", ["credential", "fill"], { stdio: ["pipe", "pipe", "ignore"] });
+		let out = "";
+		const done = (value) => resolve(value);
+		const timer = setTimeout(() => {
+			child.kill();
+			done("");
+		}, 10_000);
+		child.stdout.on("data", (chunk) => (out += chunk));
+		child.on("error", () => {
+			clearTimeout(timer);
+			done("");
+		});
+		child.on("close", () => {
+			clearTimeout(timer);
+			done(out);
+		});
+		child.stdin.end(`protocol=https\nhost=github.com\npath=${REPO}.git\n\n`);
+	});
+
+	const line = stdout.split("\n").find((l) => l.startsWith("password="));
+	if (!line) throw new Error("no GitHub token: set GITHUB_TOKEN or sign in to git");
+	return line.slice("password=".length);
+}
+
+async function api(token, endpoint) {
+	const res = await fetch(`https://api.github.com/repos/${REPO}/traffic/${endpoint}`, {
+		headers: {
+			authorization: `Bearer ${token}`,
+			accept: "application/vnd.github+json",
+			"x-github-api-version": "2022-11-28",
+		},
+	});
+	if (!res.ok) {
+		const body = await res.text();
+		throw new Error(`${endpoint} -> ${res.status}: ${body.slice(0, 200)}`);
+	}
+	return res.json();
+}
+
+async function readJson(file, fallback) {
+	const p = path.join(OUT, file);
+	if (!existsSync(p)) return fallback;
+	try {
+		return JSON.parse(await readFile(p, "utf8"));
+	} catch {
+		return fallback;
+	}
+}
+
+const sortKeys = (obj) => Object.fromEntries(Object.entries(obj).sort(([a], [b]) => a.localeCompare(b)));
+
+async function writeJson(file, data) {
+	await writeFile(path.join(OUT, file), JSON.stringify(sortKeys(data), null, 2) + "\n");
+}
+
+const token = await resolveToken();
+await mkdir(OUT, { recursive: true });
+
+const [views, clones, referrers, paths] = await Promise.all([
+	api(token, "views"),
+	api(token, "clones"),
+	api(token, "popular/referrers"),
+	api(token, "popular/paths"),
+]);
+
+// Daily counts are keyed by date, so re-running the same day corrects the row
+// instead of appending a duplicate.
+const daily = await readJson("daily.json", {});
+for (const [kind, payload] of [
+	["views", views],
+	["clones", clones],
+]) {
+	for (const row of payload[kind] ?? []) {
+		const day = row.timestamp.slice(0, 10);
+		daily[day] ??= {};
+		daily[day][kind] = row.count;
+		daily[day][`${kind}_uniques`] = row.uniques;
+	}
+}
+await writeJson("daily.json", daily);
+
+// Referrers and paths are 14-day rollups on GitHub's side, not per-day values,
+// so they are kept as dated snapshots rather than merged.
+const today = new Date().toISOString().slice(0, 10);
+for (const [file, payload] of [
+	["referrers.json", referrers],
+	["paths.json", paths],
+]) {
+	const history = await readJson(file, {});
+	history[today] = payload;
+	await writeJson(file, history);
+}
+
+const rows = Object.entries(daily).sort(([a], [b]) => a.localeCompare(b));
+await writeFile(
+	path.join(OUT, "daily.csv"),
+	["date,views,views_uniques,clones,clones_uniques"]
+		.concat(
+			rows.map(([day, v]) =>
+				[day, v.views ?? "", v.views_uniques ?? "", v.clones ?? "", v.clones_uniques ?? ""].join(","),
+			),
+		)
+		.join("\n") + "\n",
+);
+
+const totalViews = rows.reduce((sum, [, v]) => sum + (v.views ?? 0), 0);
+console.log(
+	`archived ${rows.length} days (${totalViews} views total) · top referrer: ` +
+		`${referrers[0]?.referrer ?? "none"} (${referrers[0]?.uniques ?? 0} uniques)`,
+);