@kubb/studio 5.11.0 → 5.11.2

package/dist/index.d.cts

@@ -1,4 +1,4 @@
-import { D as InstalledExtensions, P as PublishedSnapshot, W as SnapshotUploadMetadata, a as AgentConnectInfo, c as AgentPermissions, d as ConfigEditOutcome, s as AgentPermission, u as ConfigEdit } from "./protocol-CrMJymjT.cjs";
+import { D as InstalledExtensions, P as PublishedSnapshot, W as SnapshotUploadMetadata, a as AgentConnectInfo, c as AgentPermissions, d as ConfigEditOutcome, s as AgentPermission, u as ConfigEdit } from "./protocol-BUZ91Gd4.cjs";
 import { Config, Hookable, KubbHooks } from "@kubb/core";
 //#region src/connect.d.ts
 /**

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { D as InstalledExtensions, P as PublishedSnapshot, W as SnapshotUploadMetadata, a as AgentConnectInfo, c as AgentPermissions, d as ConfigEditOutcome, s as AgentPermission, u as ConfigEdit } from "./protocol-CrMJymjT.js";
+import { D as InstalledExtensions, P as PublishedSnapshot, W as SnapshotUploadMetadata, a as AgentConnectInfo, c as AgentPermissions, d as ConfigEditOutcome, s as AgentPermission, u as ConfigEdit } from "./protocol-BUZ91Gd4.js";
 import { Config, Hookable, KubbHooks } from "@kubb/core";
 //#region src/connect.d.ts
 /**

package/dist/index.js

@@ -116,6 +116,27 @@ async function read(path) {
 	if (runtime.isBun) return Bun.file(path).text();
 	return readFile(path, { encoding: "utf8" });
 }
+/**
+* Resolves to `true` when `path` is `parent` itself or nested inside it. Both sides are resolved
+* to absolute paths first, so relative and `..`-containing inputs compare correctly.
+*
+* Guards a destructive or an out-of-tree operation: before wiping an output directory, check that
+* it does not contain the project root, and before loading a path a caller supplied, check that it
+* did not escape the directory it is allowed to read from.
+*
+* @example
+* isPathInside('./src/gen', '.')   // true  — nested inside the root
+* isPathInside('.', '.')           // true  — the same directory counts as inside
+* isPathInside('.', './src/gen')   // false — the root is not inside its own output
+* isPathInside('../other', '.')    // false — escapes the root
+*/
+function isPathInside(path, parent) {
+	const resolvedPath = resolve(path);
+	const resolvedParent = resolve(parent);
+	if (resolvedPath === resolvedParent) return true;
+	const rel = relative(resolvedParent, resolvedPath);
+	return rel !== "" && !rel.startsWith("..") && !isAbsolute(rel);
+}
 //#endregion
 //#region ../../internals/utils/src/promise.ts
 /**
@@ -154,7 +175,7 @@ function getElapsedMs(hrStart) {
 }
 //#endregion
 //#region package.json
-var version = "5.11.0";
+var version = "5.11.2";
 //#endregion
 //#region src/resolveConfig.ts
 /**
@@ -459,6 +480,33 @@ async function mergePlugins({ diskPlugins, studioPlugins, extensions = /* @__PUR
 	})];
 }
 /**
+* Throws `KUBB_PATH_TRAVERSAL` when a plugin would write outside the config's output folder to a path
+* the disk config does not set. Studio can change `output.path`, also inside `override`, and add
+* plugins, so without this check any member of the Studio organization could write any file the agent
+* can reach, including `node_modules` code the next run imports. A path from the config file stays
+* allowed, since a monorepo may write outside its root.
+*/
+function assertOutputPaths({ plugins, diskPlugins, root, outputPath }) {
+	const base = path.resolve(root, outputPath);
+	const targetsOf = (plugin) => {
+		const { output, override } = plugin.options ?? {};
+		return [output, ...Array.isArray(override) ? override.map((entry) => entry?.options?.output) : []].flatMap((entry) => typeof entry?.path === "string" ? [path.resolve(base, entry.path)] : []);
+	};
+	const diskTargets = new Set(diskPlugins.flatMap(targetsOf));
+	for (const plugin of plugins) {
+		const target = targetsOf(plugin).find((resolved) => !diskTargets.has(resolved) && !isPathInside(resolved, base));
+		if (!target) continue;
+		throw new Diagnostics.Error({
+			code: Diagnostics.code.pathTraversal,
+			severity: "error",
+			message: `Plugin "${plugin.name}" would write to "${target}", outside the output folder "${base}". Studio can only set an output path inside it.`,
+			help: "Choose an output path inside the output folder, or set this path in the config file.",
+			location: { kind: "config" },
+			plugin: plugin.name
+		});
+	}
+}
+/**
 * Re-invokes the factory behind a disk adapter or parser with Studio's options merged over its own.
 * An instance carries live functions (`parse`, `print`, ...) that cannot survive JSON, so Studio's
 * options are a patch, not a replacement, and the factory is found from the disk instance itself: the
@@ -1424,7 +1472,7 @@ function createGenerationStore({ storage, maxCount, maxMb, ttlMs, now = Date.now
 	/**
 	* Copies `files` into the store as one set of `jobId`. Above `maxSetMb` only the hashes are kept.
 	*/
-	async function keep({ jobId, source, files, maxSetMb }) {
+	async function keep({ jobId, source, files, maxSetMb, normalize = source === FileSource.OUTPUT }) {
 		const maxSetBytes = maxSetMb * MB;
 		const hashes = {};
 		let bytes = 0;
@@ -1435,8 +1483,8 @@ function createGenerationStore({ storage, maxCount, maxMb, ttlMs, now = Date.now
 				if (path.split("/").includes("..")) return;
 				const content = await files.storage.readItem(resolve(files.root, path));
 				if (content === null) return;
-				if (source === FileSource.OUTPUT && !content.trim()) return;
-				hashes[path] = hashOf(source === FileSource.OUTPUT ? `${content.trim()}\n` : content);
+				if (normalize && !content.trim()) return;
+				hashes[path] = hashOf(normalize ? `${content.trim()}\n` : content);
 				bytes += Buffer.byteLength(content);
 				if (bytes <= maxSetBytes) await storage.writeItem(`${dirOf(jobId)}${source}/${path}`, content);
 			}
@@ -1900,8 +1948,12 @@ var Agent = class extends RpcTarget {
 			this.#readConfigFileView(source),
 			this.#installedExtensions(source)
 		]);
+		const output = await this.#readDiskOutput(config).catch(async (error) => {
+			await this.#warn({ message: `Could not read the output directory: ${getErrorMessage(error)}` });
+		});
 		this.#session.connected.resolve(info);
 		return {
+			output,
 			versions: {
 				kubb: version,
 				agent: version$1
@@ -1938,6 +1990,32 @@ var Agent = class extends RpcTarget {
 			permissions: this.#permissions
 		};
 	}
+	async #readDiskOutput(config) {
+		if (this.#sandbox || !this.#permissions.allowRead || this.#session.active) return void 0;
+		const files = await listDisk({
+			root: this.#options.root,
+			outputPath: config.output.path,
+			maxFiles: DISK_SNAPSHOT_MAX_FILES
+		});
+		if (!files) return void 0;
+		const jobId = randomUUID();
+		const output = await this.#generations.keep({
+			jobId,
+			source: FileSource.OUTPUT,
+			files,
+			maxSetMb: this.#limits.maxSnapshotMb,
+			normalize: false
+		});
+		await this.#generations.add({
+			jobId,
+			output
+		});
+		return {
+			jobId,
+			files: output.paths,
+			hashes: output.hashes
+		};
+	}
 	startGeneration(input) {
 		const stream = createGenerationStream(this.#options.hooks, input.jobId);
 		const controller = new AbortController();
@@ -1990,6 +2068,7 @@ var Agent = class extends RpcTarget {
 			settled.resolve();
 		}
 	}
+	/** Merges Studio's config over the disk config, refuses output paths outside the output folder, then generates in `root`. */
 	async #generate({ input, root, signal }) {
 		const { jobId, config: patch } = input;
 		const studioInput = this.#sandbox ? patch?.input : void 0;
@@ -2000,6 +2079,14 @@ var Agent = class extends RpcTarget {
 				diskPlugins: config.plugins,
 				studioPlugins: patch?.plugins,
 				extensions
+			}).then((merged) => {
+				assertOutputPaths({
+					plugins: merged ?? [],
+					diskPlugins: config.plugins,
+					root,
+					outputPath: config.output.path
+				});
+				return merged;
 			}),
 			mergeAdapter(config.adapter, patch?.adapter, extensions),
 			mergeParsers({