@kubb/studio 5.9.3 → 5.9.5

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { t as __name } from "./rolldown-runtime-CRm0XQPb.js";
-import { L as SnapshotUploadMetadata, a as AgentConnectInfo, c as ConfigEdit, j as PublishedSnapshot, l as ConfigEditOutcome, o as AgentPermissions, w as InstalledExtensions } from "./protocol-gXoAXvT3.js";
+import { M as PublishedSnapshot, V as SnapshotUploadMetadata, a as AgentConnectInfo, c as ConfigEdit, l as ConfigEditOutcome, o as AgentPermissions, w as InstalledExtensions } from "./protocol-ixLkhvRJ.js";
 import { Config, Hookable, KubbHooks } from "@kubb/core";
 //#region src/connect.d.ts
 /**
@@ -46,7 +46,7 @@ declare global {
        * A finished command and what it did, such as `applied 2/3 edits to kubb.config.ts`.
        */
       'studio:command': [ctx: {
-        command: 'generate' | 'saveConfig' | 'readFiles';
+        command: 'generate' | 'saveConfig' | 'readFiles' | 'readInput';
         info: string;
       }];
       /**

package/dist/index.js

@@ -1,5 +1,5 @@
 import "./rolldown-runtime-CRm0XQPb.js";
-import { AGENT_INSTANCE_HEADER, AGENT_SOCKET_PATH, AgentCloseCode, GENERATION_GONE_MESSAGE, MAX_PAGE_LINES, MAX_SNAPSHOT_BYTES, generationEventTypes } from "./protocol.js";
+import { AGENT_INSTANCE_HEADER, AGENT_SOCKET_PATH, AgentCloseCode, GENERATION_GONE_MESSAGE, MAX_PAGE_LINES, MAX_SNAPSHOT_BYTES, NO_INPUT_MESSAGE, READ_NOT_ALLOWED_MESSAGE, generationEventTypes } from "./protocol.js";
 import { createRequire } from "node:module";
 import { createHash, hash, randomUUID } from "node:crypto";
 import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
@@ -12,9 +12,10 @@ import { existsSync } from "node:fs";
 import { Diagnostics, Hookable, cacheStorage, createKubb, fsStorage, getInputKind, isPackageName, memoryStorage, readInstalledPackages, resolveCacheDir, resolveMeta } from "@kubb/core";
 import { RpcTarget, newWebSocketRpcSession } from "capnweb";
 import { detectCodeFormat, parseExpression, parseModule } from "magicast";
-import { promisify, stripVTControlCharacters } from "node:util";
+import { stripVTControlCharacters } from "node:util";
+import { ast } from "@kubb/ast";
 import { ofetch } from "ofetch";
-import { gzip } from "node:zlib";
+import { gzipSync } from "node:zlib";
 //#region ../../internals/utils/src/casing.ts
 /**
 * Shared implementation for camelCase and PascalCase conversion.
@@ -152,10 +153,18 @@ function getElapsedMs(hrStart) {
 }
 //#endregion
 //#region package.json
-var version = "5.9.3";
+var version = "5.9.5";
 //#endregion
 //#region src/resolveConfig.ts
 /**
+* Turns the JSON config Studio sends back into live Kubb objects.
+*
+* A plugin or adapter instance carries closures (`parse`, `getImports`, ...) that cannot survive
+* JSON, so both sides pass options over the wire and the factory is re-invoked here with the merged
+* result. Only packages {@link isAllowedPlugin} accepts are resolved this way, never an arbitrary
+* module the payload names.
+*/
+/**
 * Imports a package, falling back to how the user's project would resolve it.
 *
 * `import()` resolves from this file, so a linked or globally installed Studio (`pnpm link`,
@@ -234,8 +243,9 @@ function isAllowedPlugin({ packageName, extensions }) {
 	return KUBB_PLUGIN_SPECIFIER.test(packageName) || extensions.get(packageName)?.manifest.kind === "plugin";
 }
 /**
-* Dynamically imports a plugin package and returns its factory. Only packages
-* {@link isAllowedPlugin} accepts reach `import()`.
+* Dynamically imports an extension package and returns its factory. Callers check
+* {@link isAllowedPlugin} or derive the package from a disk instance first, so an arbitrary module
+* never reaches `import()`.
 *
 * Packages must be pre-installed in the Docker image at build time via the `KUBB_PACKAGES`
 * build ARG, no runtime installation is possible in the distroless container.
@@ -243,13 +253,9 @@ function isAllowedPlugin({ packageName, extensions }) {
 * Resolution order: the manifest's `export`, else the camelCase named export the package name
 * implies (e.g. `pluginTs`), then the default export.
 *
-* @throws if the package is not allowed, cannot be imported, or exports no callable factory.
+* @throws if the package cannot be imported or exports no callable factory.
 */
-async function loadPluginFactory({ packageName, extensions }) {
-	if (!isAllowedPlugin({
-		packageName,
-		extensions
-	})) throw new Error(`Plugin "${packageName}" is not an installed Kubb plugin. Studio loads @kubb/plugin-* packages and installed packages that ship a kubb-extension.json with kind "plugin".`);
+async function loadFactory({ packageName, extensions }) {
 	let mod;
 	try {
 		mod = await importFromProject(packageName);
@@ -268,7 +274,7 @@ async function loadPluginFactory({ packageName, extensions }) {
 }
 /**
 * Resolves each plugin entry by dynamically importing its package and calling its factory with the
-* provided options. See {@link loadPluginFactory} for which packages are allowed.
+* provided options. Only packages {@link isAllowedPlugin} accepts are loaded.
 *
 * @example
 * ```ts
@@ -282,7 +288,11 @@ async function loadPluginFactory({ packageName, extensions }) {
 */
 async function resolvePlugins({ plugins, extensions = /* @__PURE__ */ new Map() }) {
 	return Promise.all(plugins.map(async ({ name, options }) => {
-		return (await loadPluginFactory({
+		if (!isAllowedPlugin({
+			packageName: name,
+			extensions
+		})) throw new Error(`Plugin "${name}" is not an installed Kubb plugin. Studio loads @kubb/plugin-* packages and installed packages that ship a kubb-extension.json with kind "plugin".`);
+		return (await loadFactory({
 			packageName: name,
 			extensions
 		}))(options ?? {});
@@ -430,13 +440,12 @@ async function mergePlugins({ diskPlugins, studioPlugins, extensions = /* @__PUR
 async function rebuildExtension({ disk, studioOptions, kind, extensions }) {
 	if (!studioOptions || !Object.keys(studioOptions).length) return disk;
 	const { name } = resolveMeta(disk);
-	const installed = [...extensions.values()].find(({ manifest }) => manifest.kind === kind && manifest.name === name);
-	const packageName = installed?.package ?? `@kubb/${kind}-${name}`;
-	const factory = await importFromProject(packageName).then((mod) => mod[installed?.manifest.export ?? toExportName(packageName)]).catch((cause) => {
+	return (await loadFactory({
+		packageName: [...extensions.values()].find(({ manifest }) => manifest.kind === kind && manifest.name === name)?.package ?? `@kubb/${kind}-${name}`,
+		extensions
+	}).catch((cause) => {
 		throw new Error(`The ${kind} "${name}" is not an installed Kubb extension, so Studio cannot change its options. Edit it in the config file.`, { cause });
-	});
-	if (typeof factory !== "function") throw new Error(`The ${kind} "${name}" is not an installed Kubb extension, so Studio cannot change its options. Edit it in the config file.`);
-	return factory(mergeOptions(disk.options ?? {}, studioOptions));
+	}))(mergeOptions(disk.options ?? {}, studioOptions));
 }
 /**
 * Merges Studio-provided adapter option overrides into the disk config's adapter, see {@link rebuildExtension}.
@@ -1075,7 +1084,10 @@ function relativeStoragePath({ root, filePath }) {
 * The content fingerprint Studio compares snapshots by. Agent runs and CI uploads must agree on it.
 */
 const hashOf = (content) => createHash("sha1").update(content).digest("hex").slice(0, 16);
-const totalBytes = (entries) => entries.reduce((sum, { output, disk }) => sum + output.bytes + (disk?.bytes ?? 0), 0);
+/**
+* The bytes `entries` keep on disk: output, written files, and kept input.
+*/
+const totalBytes = (entries) => entries.reduce((sum, { output, disk, inputBytes }) => sum + output.bytes + (disk?.bytes ?? 0) + (inputBytes ?? 0), 0);
 function positiveNumber(value) {
 	const parsed = Number(value);
 	return value && Number.isFinite(parsed) && parsed > 0 ? parsed : void 0;
@@ -1118,7 +1130,11 @@ async function generate({ config, hooks, signal, allowExec }) {
 		hooks,
 		signal
 	});
-	const result = await kubb.generate();
+	let input = null;
+	const unhook = kubb.hooks.hook("kubb:build:end", (ctx) => {
+		if (ctx.config === kubb.config) input = kubb.driver.inputNode;
+	});
+	const result = await kubb.generate().finally(unhook);
 	if (!result.success) throw generationFailure(result.diagnostics);
 	const { storage, root } = kubb.config;
 	return {
@@ -1127,7 +1143,8 @@ async function generate({ config, hooks, signal, allowExec }) {
 		paths: new Set(result.files.map((file) => relativeStoragePath({
 			root,
 			filePath: file.path
-		})))
+		}))),
+		input
 	};
 }
 /**
@@ -1208,6 +1225,33 @@ function createGenerationStore({ storage, maxCount, maxMb, ttlMs, now = Date.now
 	return {
 		keep,
 		drop,
+		/**
+		* Keeps the `InputNode` of `jobId` and returns its size in bytes, or 0 when it keeps none. A ref schema loses
+		* the copy of its target, which `input.schemas` holds: with it, a large spec outgrows what `JSON.stringify` can return.
+		*/
+		async keepInput({ jobId, input, maxSetMb }) {
+			if (!input) return 0;
+			let json;
+			try {
+				json = JSON.stringify(ast.transform(input, { schema: (node) => node.type === "ref" && node.schema ? {
+					...node,
+					schema: void 0
+				} : void 0 }));
+			} catch {
+				return 0;
+			}
+			const bytes = Buffer.byteLength(json);
+			if (bytes > maxSetMb * MB) return 0;
+			await storage.writeItem(`${dirOf(jobId)}input.json`, json);
+			return bytes;
+		},
+		/**
+		* The input `keepInput` kept for `jobId`, or `undefined` when there is none.
+		*/
+		async readInput(jobId) {
+			const stored = await storage.readItem(`${dirOf(jobId)}input.json`);
+			return stored === null ? void 0 : JSON.parse(stored);
+		},
 		get: async (jobId) => (await load()).find((generation) => generation.jobId === jobId && isLive(generation)),
 		async add(generation) {
 			const current = await load();
@@ -1431,7 +1475,6 @@ function createGenerationStream(hooks, jobId) {
 	return {
 		stream,
 		close,
-		dispose: () => fail(),
 		fail
 	};
 }
@@ -1564,29 +1607,29 @@ var Agent = class extends RpcTarget {
 		});
 		throw new Error(message);
 	}
-	async #command({ command, run }) {
+	#assertConnected() {
 		if (!this.#session.info) throw new Error("Studio must call connect() before any other command");
-		const { value, info } = await run();
-		if (info !== void 0) await emit(this.#options.hooks, "studio:command", {
+	}
+	#logCommand(command, info) {
+		return emit(this.#options.hooks, "studio:command", {
 			command,
 			info
 		});
-		return value;
 	}
-	async #readConfigFileView() {
+	async #readConfigFileView(source) {
 		if (!this.#permissions.allowConfigEdit) return void 0;
 		try {
-			return readConfig(await read(this.#options.configFile));
+			return readConfig(await source);
 		} catch (error) {
 			await this.#warn({ message: `Could not read ${this.#options.configFile}: ${getErrorMessage(error)}` });
 			return;
 		}
 	}
-	async #installedExtensions() {
-		const source = await read(this.#options.configFile).catch(() => "");
+	async #installedExtensions(source = read(this.#options.configFile)) {
+		const imports = await source.then(readImports, () => []);
 		const installed = await readInstalledPackages({
 			root: this.#options.root,
-			packages: [...readImports(source), ...BUILT_IN_PACKAGES],
+			packages: [...imports, ...BUILT_IN_PACKAGES],
 			resolveFrom: ["kubb"]
 		});
 		return new Map(installed.flatMap(({ package: name, version, manifest }) => version !== void 0 && manifest ? [[name, {
@@ -1597,11 +1640,12 @@ var Agent = class extends RpcTarget {
 	}
 	async connect(info) {
 		this.#session.info = info;
-		const { configPath, root, version: version$1, loadConfig } = this.#options;
+		const { configPath, root, version: version$1, loadConfig, configFile } = this.#options;
+		const source = read(configFile);
 		const [config, file, extensions] = await Promise.all([
 			loadConfig(),
-			this.#readConfigFileView(),
-			this.#installedExtensions()
+			this.#readConfigFileView(source),
+			this.#installedExtensions(source)
 		]);
 		this.#session.connected.resolve(info);
 		return {
@@ -1654,11 +1698,13 @@ var Agent = class extends RpcTarget {
 			result,
 			stop: () => {
 				controller.abort(/* @__PURE__ */ new Error("Generation canceled"));
-				stream.dispose();
+				stream.fail();
 			}
 		});
 	}
+	/** Runs one job and keeps its output, and its input with `allowRead`, for later reads. */
 	async #runGeneration(input, controller) {
+		this.#assertConnected();
 		if (this.#session.closed) throw new Error("Connection is closed");
 		if (this.#session.active) return this.#refuse({ message: "A generation is already in progress, please wait for it to finish" });
 		const settled = Promise.withResolvers();
@@ -1670,13 +1716,10 @@ var Agent = class extends RpcTarget {
 		let root = this.#options.root;
 		try {
 			if (this.#sandbox) root = await mkdtemp(path.join(tmpdir(), "kubb-job-"));
-			return await this.#command({
-				command: "generate",
-				run: () => this.#generate({
-					input,
-					root,
-					signal: controller.signal
-				})
+			return await this.#generate({
+				input,
+				root,
+				signal: controller.signal
 			});
 		} finally {
 			if (root !== this.#options.root) await Promise.all([rm(root, {
@@ -1747,37 +1790,36 @@ var Agent = class extends RpcTarget {
 			files,
 			maxSetMb: this.#limits.maxMb
 		});
+		const inputBytes = await this.#generations.keepInput({
+			jobId,
+			input: this.#permissions.allowRead ? files.input : null,
+			maxSetMb: this.#limits.maxMb
+		});
 		if (!output.paths.length && Object.keys(output.hashes).length) await this.#warn({ message: "Kept only the hashes of this generation: its output is too large to keep" });
 		await this.#generations.add({
 			jobId,
 			output,
-			disk
+			disk,
+			inputBytes
 		});
+		await this.#logCommand("generate", `${activePlugins.length} plugin${activePlugins.length === 1 ? "" : "s"}, ${this.#permissions.allowWrite ? "written to disk" : "in memory"}${studioInput !== void 0 ? ", from a Studio spec" : ""}`);
 		return {
-			value: {
-				status: "success",
-				files: [...files.paths],
-				fileCount: files.paths.size,
-				hashes: output.hashes,
-				disk: disk ? { hashes: disk.hashes } : void 0
-			},
-			info: `${activePlugins.length} plugin${activePlugins.length === 1 ? "" : "s"}, ${this.#permissions.allowWrite ? "written to disk" : "in memory"}${studioInput !== void 0 ? ", from a Studio spec" : ""}`
+			status: "success",
+			files: [...files.paths],
+			fileCount: files.paths.size,
+			hashes: output.hashes,
+			disk: disk ? { hashes: disk.hashes } : void 0
 		};
 	}
-	saveConfig(input) {
-		return this.#command({
-			command: "saveConfig",
-			run: () => this.#saveConfig(input)
-		});
-	}
-	async #saveConfig(input) {
+	async saveConfig(input) {
+		this.#assertConnected();
 		const { configPath, configFile } = this.#options;
 		if (!Array.isArray(input.edits)) {
 			await this.#warn({ message: "Ignored save: the message carried no edits" });
-			return { value: {
+			return {
 				outcomes: [],
 				changed: false
-			} };
+			};
 		}
 		const edits = input.edits;
 		const refuse = (reason) => ({
@@ -1790,9 +1832,9 @@ var Agent = class extends RpcTarget {
 		});
 		if (!this.#permissions.allowConfigEdit) {
 			await this.#warn({ message: "Ignored save: editing kubb.config.ts was not granted" });
-			return { value: refuse("the agent was not granted permission to edit kubb.config.ts") };
+			return refuse("the agent was not granted permission to edit kubb.config.ts");
 		}
-		if (this.#session.active) return { value: refuse("a generation is in progress") };
+		if (this.#session.active) return refuse("a generation is in progress");
 		try {
 			const { outcomes, changed } = await writeConfigEdits({
 				filePath: configFile,
@@ -1800,27 +1842,40 @@ var Agent = class extends RpcTarget {
 				extensions: await this.#installedExtensions()
 			});
 			const applied = outcomes.filter((outcome) => outcome.applied).length;
+			await this.#logCommand("saveConfig", `applied ${applied}/${outcomes.length} edits to ${configPath}`);
 			return {
-				value: {
-					outcomes,
-					changed
-				},
-				info: `applied ${applied}/${outcomes.length} edits to ${configPath}`
+				outcomes,
+				changed
 			};
 		} catch (error) {
 			await emit(this.#options.hooks, "studio:error", { error: toError(error) });
-			return { value: refuse(getErrorMessage(error)) };
+			return refuse(getErrorMessage(error));
 		}
 	}
-	readFiles(input) {
-		return this.#command({
-			command: "readFiles",
-			run: () => this.#readFiles(input)
+	/**
+	* Returns the Kubb AST a kept job parsed its spec into. Refused without `allowRead`.
+	*/
+	async readInput(input) {
+		this.#assertConnected();
+		if (!this.#permissions.allowRead) return this.#refuse({
+			message: READ_NOT_ALLOWED_MESSAGE,
+			permission: "allowRead"
 		});
+		if (typeof input.jobId !== "string" || !input.jobId) return this.#refuse({ message: "The request must name a job" });
+		const generation = await this.#generations.get(input.jobId);
+		if (!generation) return this.#refuse({ message: GENERATION_GONE_MESSAGE });
+		const kept = generation.inputBytes ? await this.#generations.readInput(input.jobId) : void 0;
+		if (!kept) return this.#refuse({ message: NO_INPUT_MESSAGE });
+		await this.#logCommand("readInput", "read the API input");
+		return { input: kept };
 	}
-	async #readFiles(input) {
+	/**
+	* Returns the requested files of a kept job, one page of lines at a time. Refused without `allowRead`.
+	*/
+	async readFiles(input) {
+		this.#assertConnected();
 		if (!this.#permissions.allowRead) return this.#refuse({
-			message: "The agent was not granted permission to read generated files",
+			message: READ_NOT_ALLOWED_MESSAGE,
 			permission: "allowRead"
 		});
 		if (!Array.isArray(input.paths) || typeof input.jobId !== "string" || !input.jobId) return this.#refuse({ message: "The request must name a job and carry paths" });
@@ -1838,10 +1893,8 @@ var Agent = class extends RpcTarget {
 			cursor: input.cursor,
 			limit: input.limit
 		});
-		return {
-			value: result,
-			info: `read ${Object.keys(result.files).length}/${paths.length} requested file${paths.length === 1 ? "" : "s"}`
-		};
+		await this.#logCommand("readFiles", `read ${Object.keys(result.files).length}/${paths.length} requested file${paths.length === 1 ? "" : "s"}`);
+		return result;
 	}
 };
 const openWebSocketRpc = ({ url, token, instanceId, agent }) => {
@@ -2132,7 +2185,6 @@ async function pairAgent({ onCode, onRetry, maxAttempts = 1, ...options }) {
 }
 //#endregion
 //#region src/snapshot.ts
-const gzipAsync = promisify(gzip);
 const UPLOAD_TIMEOUT_MS = 12e4;
 const BUNDLED_DEPENDENCIES = ["@kubb/plugin-barrel"];
 /**
@@ -2252,7 +2304,7 @@ async function createSnapshotPackage({ files, packageInfo }) {
 				Buffer.alloc((512 - bytes.length % 512) % 512)
 			];
 		});
-		return await gzipAsync(Buffer.concat([...chunks, Buffer.alloc(1024)]));
+		return gzipSync(Buffer.concat([...chunks, Buffer.alloc(1024)]));
 	} finally {
 		await rm(root, {
 			recursive: true,