@kubb/studio 5.3.3 → 5.3.5

package/dist/index.cjs

@@ -614,18 +614,41 @@ async function createJob({ studioUrl, token, type, agentId, name, version, confi
 	return job;
 }
 /**
-* Polls `GET /api/jobs/{id}` until the job reaches `success` or `failed`.
+* A job runs a generation and packs a tarball, so it is never done the instant it is queued.
+*/
+const INITIAL_POLL_DELAY_MS = 2e3;
+/**
+* Slowest the poll backs off to. Requests per run are roughly `timeoutMs` divided by this, and
+* every concurrent run on the same organization key draws on one budget.
+*/
+const MAX_POLL_INTERVAL_MS = 3e4;
+/**
+* Polls `GET /api/jobs/{id}` until the job reaches `success` or `failed`, waiting
+* {@link INITIAL_POLL_DELAY_MS} first and doubling up to {@link MAX_POLL_INTERVAL_MS} so a long
+* job stays inside the API key's rate limit.
 *
 * A `failed` job resolves normally. Check `job.status` and `job.error`. Throws only when the
 * deadline passes before Studio finishes.
 */
 async function waitForJob({ studioUrl, token, id, timeoutMs = 6e4 }) {
 	const deadline = Date.now() + timeoutMs;
+	let interval = INITIAL_POLL_DELAY_MS;
 	for (;;) {
-		const { job } = await (0, ofetch.ofetch)(`${studioUrl}/api/jobs/${id}`, { headers: { "x-api-key": token } });
-		if (job.status === "success" || job.status === "failed") return job;
+		await new Promise((resolve) => setTimeout(resolve, Math.max(Math.min(interval, deadline - Date.now()), 0)));
 		if (Date.now() >= deadline) throw new Error("Timed out waiting for the Studio job");
-		await new Promise((resolve) => setTimeout(resolve, 1e3));
+		interval = Math.min(interval * 2, MAX_POLL_INTERVAL_MS);
+		try {
+			const { job } = await (0, ofetch.ofetch)(`${studioUrl}/api/jobs/${id}`, {
+				headers: { "x-api-key": token },
+				retry: false
+			});
+			if (job.status === "success" || job.status === "failed") return job;
+		} catch (error) {
+			const response = error.response;
+			if (response?.status !== 429) throw error;
+			const retryAfter = response._data?.data?.tryAgainIn;
+			interval = Math.max(interval, typeof retryAfter === "number" && Number.isFinite(retryAfter) && retryAfter > 0 ? retryAfter : MAX_POLL_INTERVAL_MS);
+		}
 	}
 }
 /**
@@ -655,7 +678,7 @@ async function createAgent({ studioUrl, token, name, machineToken }) {
 }
 //#endregion
 //#region package.json
-var version = "5.3.3";
+var version = "5.3.5";
 //#endregion
 //#region src/hooks.ts
 /**
@@ -1718,12 +1741,6 @@ async function createSnapshotPackage(files, packageInfo) {
 //#endregion
 //#region src/ws.ts
 /**
-* How many generated files are read from storage at once when building the
-* `kubb:generation:end` payload. A spec producing thousands of files would otherwise fire one
-* `storage.readItem` per file simultaneously.
-*/
-const FILE_READ_CONCURRENCY = 50;
-/**
 * How long the initial handshake may take before the socket is closed and the reconnect loop
 * takes over.
 */
@@ -1739,6 +1756,12 @@ const require$1 = (0, node_module.createRequire)(require("url").pathToFileURL(__
 function relativeStoragePath(root, filePath) {
 	return ((0, node_path.isAbsolute)(filePath) ? (0, node_path.relative)((0, node_path.resolve)(root), filePath) : filePath).replaceAll("\\", "/");
 }
+/**
+* Inverse of {@link relativeStoragePath}: rebuilds the storage key a relative path came from.
+*/
+function absoluteStoragePath(root, relativePath) {
+	return (0, node_path.resolve)(root, relativePath);
+}
 async function resolvePeerDependencies(names) {
 	const uniqueNames = [...new Set(names.map(toPackageName))];
 	const peerDependencies = {};
@@ -1856,12 +1879,12 @@ function setupEventsStream(ws$5, hooks, jobId, options = {}) {
 			}]
 		});
 	});
-	on("kubb:build:end", ({ files, outputDir }) => {
+	on("kubb:build:end", ({ files, config, outputDir }) => {
 		sendDataMessage({
 			type: "kubb:build:end",
 			data: [{
 				files: files.map((file) => ({
-					path: file.path,
+					path: relativeStoragePath(config.root, file.path),
 					name: file.name
 				})),
 				outputDir
@@ -1915,25 +1938,18 @@ function setupEventsStream(ws$5, hooks, jobId, options = {}) {
 	});
 	on("kubb:generation:end", async ({ config, storage, diagnostics = [], status, hrStart, filesCreated }) => {
 		const { peerDependencies, missingDependencies } = await resolvePeerDependencies(config.plugins.map(({ name }) => name));
-		const paths = await storage.readKeys();
-		const files = {};
-		await inParallel({
-			items: paths,
-			limit: FILE_READ_CONCURRENCY,
-			run: async (path) => {
-				const content = await storage.readItem(path);
-				if (content !== null) files[relativeStoragePath(config.root, path)] = content;
-			}
+		const keys = await storage.readKeys();
+		const paths = new Set(keys.map((key) => relativeStoragePath(config.root, key)));
+		options.onGenerationEnd?.({
+			storage,
+			root: config.root,
+			paths,
+			peerDependencies,
+			missingDependencies
 		});
-		options.onGenerationEnd?.(files);
 		sendDataMessage({
 			type: "kubb:generation:end",
-			data: [{
-				config,
-				storage: options.skipStorage ? {} : files,
-				peerDependencies,
-				missingDependencies
-			}]
+			data: []
 		});
 		if (!hrStart) return;
 		sendDataMessage({
@@ -2011,6 +2027,11 @@ function setupEventsStream(ws$5, hooks, jobId, options = {}) {
 //#endregion
 //#region src/StudioSession.ts
 /**
+* How many files are read from storage at once when serving `studio:files` or packing a
+* `studio:snapshot`.
+*/
+const FILE_READ_CONCURRENCY = 50;
+/**
 * How long the `agent:connect` handshake may go unacknowledged before `studio:ready` is given up
 * on for this open. A Studio that predates the ack never sends one, so this only ever produces a
 * warning, not a reconnect.
@@ -2033,6 +2054,7 @@ function applyStudioDefaults(options) {
 			allowConfigEdit: false,
 			allowInput: false,
 			allowExec: false,
+			allowRead: false,
 			...options.permissions
 		},
 		retryInterval: options.retryInterval ?? agentDefaults.retryIntervalMs,
@@ -2113,6 +2135,12 @@ var StudioSession = class {
 	get #canUseInput() {
 		return this.#isSandbox || this.#options.permissions.allowInput;
 	}
+	/**
+	* A sandbox agent always allows reading its output back; a local agent only when opted in.
+	*/
+	get #canRead() {
+		return this.#isSandbox || this.#options.permissions.allowRead;
+	}
 	async connect() {
 		const { token, studioUrl, signal, heartbeatInterval, installLogger } = this.#options;
 		await installLogger?.(this.#hooks);
@@ -2206,7 +2234,8 @@ var StudioSession = class {
 					...permissions,
 					allowWrite: this.#canWrite,
 					allowInput: this.#canUseInput,
-					allowConfigEdit: this.#canEditConfig
+					allowConfigEdit: this.#canEditConfig,
+					allowRead: this.#canRead
 				}
 			}
 		});
@@ -2348,6 +2377,9 @@ var StudioSession = class {
 			case "studio:snapshot":
 				await this.#handleSnapshot(ws, data, command);
 				return;
+			case "studio:files":
+				await this.#handleFiles(ws, data, command);
+				return;
 		}
 	}
 	async #handleGenerate(ws, data, command) {
@@ -2371,13 +2403,10 @@ var StudioSession = class {
 				await this.#warn(`Ignored the spec from Studio; set ${remedy} to generate from it`);
 			}
 			const resolvedPlugins = plugins ?? config.plugins;
-			let generatedFiles;
-			const detach = [setupHookListener(this.#hooks, root), setupEventsStream(ws, this.#hooks, data.jobId, {
-				skipStorage: client?.kind === "ci",
-				onGenerationEnd: (files) => {
-					generatedFiles = files;
-				}
-			})];
+			this.#lastGeneration = void 0;
+			const detach = [setupHookListener(this.#hooks, root), setupEventsStream(ws, this.#hooks, data.jobId, { onGenerationEnd: (result) => {
+				this.#lastGeneration = result;
+			} })];
 			try {
 				await generate({
 					config: {
@@ -2398,7 +2427,6 @@ var StudioSession = class {
 				});
 			} finally {
 				for (const remove of detach) remove();
-				this.#lastGeneration = generatedFiles;
 			}
 			await this.#hooks.callHook("studio:command:end", {
 				command,
@@ -2481,23 +2509,39 @@ var StudioSession = class {
 			refuse("a sandbox agent has no project to build a package from");
 			return;
 		}
-		const { name, version, peerDependencies, uploadPath } = data.payload;
+		const { name, version, bundledDependencies, uploadPath } = data.payload;
 		if (!name || !version || !uploadPath) {
 			await this.#warn("Ignored snapshot: the message was missing required fields");
 			refuse("the message was missing required fields");
 			return;
 		}
-		const files = this.#lastGeneration;
-		if (!files) {
+		const generation = this.#lastGeneration;
+		if (!generation) {
 			await this.#warn("Ignored snapshot: no prior generation to pack");
 			refuse("no prior generation exists to pack, run a generation first");
 			return;
 		}
+		const bundled = new Set(bundledDependencies ?? []);
+		const missing = generation.missingDependencies.filter((dependency) => !bundled.has(dependency));
+		if (missing.length) {
+			await this.#warn(`Ignored snapshot: missing dependencies: ${missing.join(", ")}`);
+			refuse(`missing dependencies: ${missing.join(", ")}`);
+			return;
+		}
 		try {
+			const files = {};
+			await inParallel({
+				items: [...generation.paths],
+				limit: FILE_READ_CONCURRENCY,
+				run: async (relativePath) => {
+					const content = await generation.storage.readItem(absoluteStoragePath(generation.root, relativePath));
+					if (content !== null) files[relativePath] = content;
+				}
+			});
 			const { bytes, integrity } = await createSnapshotPackage(files, {
 				name,
 				version,
-				peerDependencies: peerDependencies ?? {}
+				peerDependencies: generation.peerDependencies
 			});
 			const { token, studioUrl } = this.#options;
 			const redirect = await fetch(new URL(uploadPath, studioUrl), {
@@ -2517,7 +2561,8 @@ var StudioSession = class {
 				jobId: data.jobId,
 				payload: {
 					status: "ok",
-					integrity
+					integrity,
+					peerDependencies: generation.peerDependencies
 				}
 			});
 			await this.#hooks.callHook("studio:command:end", {
@@ -2529,6 +2574,61 @@ var StudioSession = class {
 			refuse(getErrorMessage(error));
 		}
 	}
+	async #handleFiles(ws, data, command) {
+		const { client } = this.#options;
+		const refuse = (message) => sendAgentMessage(ws, {
+			type: "agent:files",
+			jobId: data.jobId,
+			payload: {
+				status: "error",
+				message
+			}
+		});
+		if (!this.#canRead) {
+			await this.#warn("Ignored files: reading generated files was not granted");
+			refuse(`the agent was not granted permission to read generated files; set ${client?.kind === "cli" ? "--allow-read, or answer yes when kubb studio asks," : "KUBB_AGENT_ALLOW_READ=true"} to allow it`);
+			return;
+		}
+		if (!Array.isArray(data.payload?.paths)) {
+			await this.#warn("Ignored files: the message carried no paths");
+			refuse("the message carried no paths");
+			return;
+		}
+		const { paths } = data.payload;
+		if (paths.length > 50) {
+			await this.#warn(`Ignored files: requested ${paths.length} paths, more than the 50 allowed per request`);
+			refuse(`at most 50 paths may be requested at once`);
+			return;
+		}
+		const generation = this.#lastGeneration;
+		if (!generation) {
+			await this.#warn("Ignored files: no prior generation to read from");
+			refuse("no prior generation to read from, run a generation first");
+			return;
+		}
+		const requested = paths.filter((path) => generation.paths.has(path));
+		const files = {};
+		await inParallel({
+			items: requested,
+			limit: FILE_READ_CONCURRENCY,
+			run: async (path) => {
+				const content = await generation.storage.readItem(absoluteStoragePath(generation.root, path));
+				if (content !== null) files[path] = content;
+			}
+		});
+		sendAgentMessage(ws, {
+			type: "agent:files",
+			jobId: data.jobId,
+			payload: {
+				status: "ok",
+				files
+			}
+		});
+		await this.#hooks.callHook("studio:command:end", {
+			command,
+			info: `read ${Object.keys(files).length}/${paths.length} requested file${paths.length === 1 ? "" : "s"}`
+		});
+	}
 };
 //#endregion
 //#region src/client.ts