busa-cli 0.19.1 → 0.19.2

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { n as runCli } from "./run--bA-jLSP.js";
+import { n as runCli } from "./run-ZDakuDNP.js";
 //#region src/cli.ts
 process.exit(await runCli(process.argv.slice(2)));
 //#endregion

package/dist/index.js

@@ -1,3 +1,3 @@
-import { n as runCli, r as render, t as HELP } from "./run--bA-jLSP.js";
+import { n as runCli, r as render, t as HELP } from "./run-ZDakuDNP.js";
 import { DEFAULT_BASE_URL, createBusabaseClient, normalizeBaseUrl } from "busabase-sdk";
 export { DEFAULT_BASE_URL, HELP, createBusabaseClient, normalizeBaseUrl, render, runCli };

package/dist/{run--bA-jLSP.js → run-ZDakuDNP.js}

@@ -5301,14 +5301,14 @@ z.object({
 	page: 1,
 	pageSize: 50
 });
-z.object({
+const listChangeRequestsPageResponseSchema = z.object({
 	changeRequests: z.array(changeRequestSchema),
 	total: z.number().int().nonnegative(),
 	totalPages: z.number().int().nonnegative(),
 	page: z.number().int().min(1),
 	pageSize: z.number().int().min(1).max(100)
 });
-z.object({
+const changeRequestCountsSchema = z.object({
 	review: z.number().int().nonnegative(),
 	changes: z.number().int().nonnegative(),
 	created: z.number().int().nonnegative(),
@@ -5316,6 +5316,7 @@ z.object({
 	merged: z.number().int().nonnegative(),
 	rejected: z.number().int().nonnegative()
 });
+listChangeRequestsPageResponseSchema.extend({ counts: changeRequestCountsSchema });
 const SEARCH_SOURCES = [
 	"records",
 	"files",
@@ -5994,8 +5995,75 @@ const reportUnresolvableDocAssets = (slug, body, carried = /* @__PURE__ */ new S
 	if (unresolved.length === 0) return void 0;
 	return `Doc "${slug}" embeds ${unresolved.length} image(s) that this package does not carry (${unresolved.join(", ")}). Everything else about the doc is intact, but those images will not render on another host. Re-upload them in the Doc editor, or check that the source host can still serve them.`;
 };
+//#endregion
+//#region ../../packages/busabase-package/src/record-dependencies.ts
+const recordIdentity = (baseSlug, recordKey) => `${baseSlug}\u0000${recordKey}`;
+const toRecordKeyArray = (value) => {
+	if (Array.isArray(value)) return value.filter((item) => typeof item === "string" && item.length > 0);
+	if (typeof value === "string" && value.length > 0) return [value];
+	return [];
+};
+const collectBases = (nodes) => {
+	const bases = [];
+	for (const node of nodes) {
+		if (node.type === "base") bases.push(node);
+		if (node.type === "folder") bases.push(...collectBases(node.children));
+	}
+	return bases;
+};
+const label = (baseSlug, recordKey) => `${baseSlug}/${recordKey}`;
+/**
+* Order sample records so every required relation points at an already-created row.
+*
+* Optional relations remain a separate linking pass. Required relations cannot: the
+* Base rejects a record before that later pass if its required value is absent.
+*/
+const buildRecordCreateLayers = (nodes) => {
+	const bases = collectBases(nodes);
+	const basesBySlug = new Map(bases.map((base) => [base.slug, base]));
+	const records = /* @__PURE__ */ new Map();
+	for (const base of bases) for (const record of base.records) records.set(recordIdentity(base.slug, record.key), {
+		base,
+		record
+	});
+	const dependencies = /* @__PURE__ */ new Map();
+	for (const planned of records.values()) {
+		const id = recordIdentity(planned.base.slug, planned.record.key);
+		const required = /* @__PURE__ */ new Set();
+		for (const field of planned.base.base.fields) {
+			if (field.type !== "relation" || !field.required) continue;
+			const targetBaseSlug = field.options.targetBaseSlug;
+			if (!targetBaseSlug || !basesBySlug.has(targetBaseSlug)) throw new Error(`Required relation "${planned.base.slug}.${field.slug}" targets missing Base "${targetBaseSlug || "(unset)"}". Nothing was installed.`);
+			const keys = toRecordKeyArray(planned.record.fields[field.slug]);
+			if (keys.length === 0) throw new Error(`Sample record "${label(planned.base.slug, planned.record.key)}" is missing required relation "${field.slug}". Nothing was installed.`);
+			for (const key of keys) {
+				const dependency = recordIdentity(targetBaseSlug, key);
+				if (!records.has(dependency)) throw new Error(`Sample record "${label(planned.base.slug, planned.record.key)}" requires "${targetBaseSlug}/${key}" through relation "${field.slug}", but that target is not in this package. Nothing was installed.`);
+				required.add(dependency);
+			}
+		}
+		dependencies.set(id, required);
+	}
+	const remaining = new Map(records);
+	const created = /* @__PURE__ */ new Set();
+	const layers = [];
+	while (remaining.size > 0) {
+		const ready = [...remaining.entries()].filter(([id]) => [...dependencies.get(id) ?? []].every((dependency) => created.has(dependency))).sort(([, a], [, b]) => `${a.base.slug}\u0000${a.record.key}`.localeCompare(`${b.base.slug}\u0000${b.record.key}`, "en"));
+		if (ready.length === 0) {
+			const cycle = [...remaining.values()].map((item) => label(item.base.slug, item.record.key)).sort((a, b) => a.localeCompare(b, "en"));
+			throw new Error(`Required sample relations contain a cycle involving: ${cycle.join(", ")}. Required relation targets must be creatable first. Nothing was installed.`);
+		}
+		layers.push(ready.map(([, planned]) => planned));
+		for (const [id] of ready) {
+			remaining.delete(id);
+			created.add(id);
+		}
+	}
+	return layers;
+};
 const fieldKey = (baseSlug, fieldSlug) => `${baseSlug}\u0000${fieldSlug}`;
 const applyInstall = async (client, plan, options) => {
+	const recordCreateLayers = buildRecordCreateLayers(plan.tree.nodes);
 	const state = {
 		targetFolderNodeId: "",
 		created: {
@@ -6014,90 +6082,144 @@ const applyInstall = async (client, plan, options) => {
 	const bases = [];
 	const progress = options.onProgress ?? (() => {});
 	const app = resolveAppContext(plan, options);
-	const docAssetIds = await uploadDocAssets(client, plan.tree.assets ?? [], state, progress, options.serverUrl);
-	progress("Pass 1/5: creating the node tree…");
-	if (plan.existingTargetFolderNodeId) state.targetFolderNodeId = plan.existingTargetFolderNodeId;
-	else {
-		state.targetFolderNodeId = await createFolderNode(client, {
-			parentNodeId: void 0,
-			slug: plan.targetFolderSlug,
-			name: plan.tree.manifest.name,
-			description: plan.tree.manifest.description,
-			submittedBy: options.submittedBy,
-			metadata: app?.rootMetadata
-		});
-		state.created.folders++;
-	}
-	await createStructure(client, plan.tree.nodes, state.targetFolderNodeId, options, state, bases, fieldIds, docAssetIds, app);
-	if (app?.rootSkill) {
-		progress("Pass 1/5: installing the app skill…");
-		await createFileTreeNode(client, {
-			type: "skill",
-			slug: app.rootSkill.slug,
-			name: app.rootSkill.name,
-			description: app.rootSkill.description,
-			position: void 0,
-			files: app.rootSkill.files
-		}, state.targetFolderNodeId, options, state, app, { [TEMPLATE_SKILL_METADATA_KEY]: true });
-	}
-	const deferred = bases.filter((base) => base.node.base.fields.some(isDeferredField));
-	if (deferred.length > 0) {
-		progress("Pass 2/5: adding relation and AI fields…");
-		for (const base of deferred) for (const field of base.node.base.fields.filter(isDeferredField)) {
-			const updated = await client.bases.createField({
-				baseId: base.baseId,
-				slug: field.slug,
-				name: field.name,
-				type: field.type,
-				required: field.required,
-				options: toApiFieldOptions(field.options)
-			});
-			indexFields(fieldIds, base.node.slug, updated.fields);
-		}
-	}
-	const patchable = bases.flatMap((base) => base.node.base.fields.filter(needsFieldIdPatch).map((field) => ({
-		base,
-		field
-	})));
-	if (patchable.length > 0) {
-		progress("Pass 3/5: resolving inverse and AI source field references…");
-		for (const { base, field } of patchable) {
-			const fieldId = fieldIds.get(fieldKey(base.node.slug, field.slug));
-			if (!fieldId) throw new Error(`Internal error: no field id for ${base.node.slug}.${field.slug} in pass 3.`);
-			const patched = resolveFieldIdOptions(field, base.node.slug, fieldIds, state.warnings);
-			if (!patched) continue;
-			const changeRequest = await client.bases.fieldChangeRequest({
-				operation: "update",
-				baseId: base.baseId,
-				fieldId,
-				patch: { options: patched },
-				message: `Wire up ${base.node.slug}.${field.slug} references`,
+	let phase = "Pass 1/5 (structure)";
+	try {
+		const docAssetIds = await uploadDocAssets(client, plan.tree.assets ?? [], state, progress, options.serverUrl);
+		progress("Pass 1/5: creating the node tree…");
+		if (plan.existingTargetFolderNodeId) state.targetFolderNodeId = plan.existingTargetFolderNodeId;
+		else {
+			state.targetFolderNodeId = await createFolderNode(client, {
+				parentNodeId: void 0,
+				slug: plan.targetFolderSlug,
+				name: plan.tree.manifest.name,
+				description: plan.tree.manifest.description,
 				submittedBy: options.submittedBy,
-				autoMerge: true
+				metadata: app?.rootMetadata
 			});
-			if (changeRequest.status !== "merged") throw new Error(`Field reference wiring for ${base.node.slug}.${field.slug} was requested immediately but came back "${changeRequest.status}"; install cannot leave a Base's relation fields unwired.`);
+			state.created.folders++;
 		}
-	}
-	const recordIdsByKey = /* @__PURE__ */ new Map();
-	const withRecords = bases.filter((base) => base.node.records.length > 0);
-	if (withRecords.length > 0) {
-		progress("Pass 4/5: creating records…");
-		for (const base of withRecords) await createRecords(client, base, plan, options, state, recordIdsByKey, app);
-	}
-	const relationFieldSlugs = /* @__PURE__ */ new Map();
-	for (const base of bases) {
-		const slugs = base.node.base.fields.filter((field) => field.type === "relation").map((field) => field.slug);
-		if (slugs.length > 0) relationFieldSlugs.set(base.node.slug, slugs);
-	}
-	if (relationFieldSlugs.size > 0) {
-		progress("Pass 5/5: linking relations…");
+		await createStructure(client, plan.tree.nodes, state.targetFolderNodeId, options, state, bases, fieldIds, docAssetIds, app);
+		if (app?.rootSkill) {
+			progress("Pass 1/5: installing the app skill…");
+			await createFileTreeNode(client, {
+				type: "skill",
+				slug: app.rootSkill.slug,
+				name: app.rootSkill.name,
+				description: app.rootSkill.description,
+				position: void 0,
+				files: app.rootSkill.files
+			}, state.targetFolderNodeId, options, state, app, { [TEMPLATE_SKILL_METADATA_KEY]: true });
+		}
+		phase = "Pass 2/5 (relation and AI fields)";
+		const deferred = bases.filter((base) => base.node.base.fields.some(isDeferredField));
+		if (deferred.length > 0) {
+			progress("Pass 2/5: adding relation and AI fields…");
+			for (const base of deferred) for (const field of base.node.base.fields.filter(isDeferredField)) {
+				const updated = await client.bases.createField({
+					baseId: base.baseId,
+					slug: field.slug,
+					name: field.name,
+					type: field.type,
+					required: field.required,
+					options: toApiFieldOptions(field.options)
+				});
+				indexFields(fieldIds, base.node.slug, updated.fields);
+			}
+		}
+		phase = "Pass 3/5 (field reference wiring)";
+		const patchable = bases.flatMap((base) => base.node.base.fields.filter(needsFieldIdPatch).map((field) => ({
+			base,
+			field
+		})));
+		if (patchable.length > 0) {
+			progress("Pass 3/5: resolving inverse and AI source field references…");
+			for (const { base, field } of patchable) {
+				const fieldId = fieldIds.get(fieldKey(base.node.slug, field.slug));
+				if (!fieldId) throw new Error(`Internal error: no field id for ${base.node.slug}.${field.slug} in pass 3.`);
+				const patched = resolveFieldIdOptions(field, base.node.slug, fieldIds, state.warnings);
+				if (!patched) continue;
+				const changeRequest = await client.bases.fieldChangeRequest({
+					operation: "update",
+					baseId: base.baseId,
+					fieldId,
+					patch: { options: patched },
+					message: `Wire up ${base.node.slug}.${field.slug} references`,
+					submittedBy: options.submittedBy,
+					autoMerge: true
+				});
+				if (changeRequest.status !== "merged") throw new Error(`Field reference wiring for ${base.node.slug}.${field.slug} was requested immediately but came back "${changeRequest.status}"; install cannot leave a Base's relation fields unwired.`);
+			}
+		}
+		phase = "Pass 4/5 (sample records)";
+		const recordIdsByKey = /* @__PURE__ */ new Map();
+		if (recordCreateLayers.length > 0) {
+			progress("Pass 4/5: creating records…");
+			const basesBySlug = new Map(bases.map((base) => [base.node.slug, base]));
+			for (const layer of recordCreateLayers) {
+				const byBase = /* @__PURE__ */ new Map();
+				for (const planned of layer) {
+					const group = byBase.get(planned.base.slug) ?? [];
+					group.push(planned);
+					byBase.set(planned.base.slug, group);
+				}
+				for (const [baseSlug, planned] of [...byBase].sort(([a], [b]) => a.localeCompare(b, "en"))) {
+					const base = basesBySlug.get(baseSlug);
+					if (!base) throw new Error(`Internal error: no materialized Base for ${baseSlug} in pass 4.`);
+					await createRecords(client, base, planned.map((item) => item.record), plan, options, state, recordIdsByKey, app);
+				}
+			}
+		}
+		phase = "Pass 5/5 (relation links)";
+		const relationFields = /* @__PURE__ */ new Map();
 		for (const base of bases) {
-			const slugs = relationFieldSlugs.get(base.node.slug);
-			if (!slugs) continue;
-			await linkRelations(client, base, slugs, recordIdsByKey, options, state);
+			const fields = base.node.base.fields.filter((field) => field.type === "relation");
+			if (fields.length > 0) relationFields.set(base.node.slug, fields);
 		}
+		if (relationFields.size > 0) {
+			progress("Pass 5/5: linking relations…");
+			for (const base of bases) {
+				const fields = relationFields.get(base.node.slug);
+				if (!fields) continue;
+				await linkRelations(client, base, fields, recordIdsByKey, options, state);
+			}
+		}
+		return state;
+	} catch (error) {
+		const created = Object.entries(state.created).filter(([, count]) => count > 0).map(([kind, count]) => `${count} ${kind}`).join(", ");
+		const partial = created ? `Created before failure: ${created}. Target folder: ${plan.targetFolderSlug}.` : "No package resources were created.";
+		const pending = state.pendingChangeRequests ? ` ${state.pendingChangeRequests} ChangeRequest(s) may still be pending.` : "";
+		const reason = error instanceof Error ? error.message : String(error);
+		const message = `Install stopped during ${phase}. ${partial}${pending} Cause: ${reason}`;
+		const details = {
+			phase,
+			targetFolderSlug: plan.targetFolderSlug,
+			created: { ...state.created },
+			pendingChangeRequests: state.pendingChangeRequests
+		};
+		if (error instanceof Error) {
+			error.message = message;
+			throw attachInstallFailureDetails(error, details);
+		}
+		throw attachInstallFailureDetails(new Error(message), details);
 	}
-	return state;
+};
+/**
+* A property rather than a subclass: the whole point of the rethrow above is to
+* keep the original error's prototype (an `ORPCError`'s `code`/`status`/`data`
+* are what make a permission or quota failure actionable), so the diagnostics
+* have to ride along on it instead of replacing it.
+*/
+const INSTALL_FAILURE_DETAILS_KEY = "busabaseInstallFailure";
+const attachInstallFailureDetails = (error, details) => {
+	try {
+		Object.defineProperty(error, INSTALL_FAILURE_DETAILS_KEY, {
+			value: details,
+			enumerable: false,
+			configurable: true,
+			writable: true
+		});
+	} catch {}
+	return error;
 };
 const resolveAppContext = (plan, options) => {
 	if (!plan.isTemplate) return void 0;
@@ -6453,28 +6575,39 @@ const resolveFieldIdOptions = (field, baseSlug, fieldIds, warnings) => {
 const indexFields = (fieldIds, baseSlug, fields) => {
 	for (const field of fields) fieldIds.set(fieldKey(baseSlug, field.slug), field.id);
 };
-/** Values the server computes, and relation values (pass 5), are never sent in pass 4. */
-const toCreatableFields = (node, fields) => {
-	const typeBySlug = new Map(node.base.fields.map((field) => [field.slug, field.type]));
+/**
+* Values the server computes and optional relations are omitted in pass 4.
+* Required relations are resolved to canonical ids once their dependency layer exists.
+*/
+const toCreatableFields = (node, fields, recordIdsByKey) => {
+	const fieldBySlug = new Map(node.base.fields.map((field) => [field.slug, field]));
 	const result = {};
 	for (const [slug, value] of Object.entries(fields)) {
-		const type = typeBySlug.get(slug);
-		if (!type) continue;
-		if (type === "relation") continue;
-		if (PACKAGE_COMPUTED_FIELD_TYPES.includes(type)) continue;
-		if (type === "attachment") continue;
+		const field = fieldBySlug.get(slug);
+		if (!field) continue;
+		if (field.type === "relation") {
+			if (!field.required) continue;
+			const targetBaseSlug = field.options.targetBaseSlug;
+			const keys = toRecordKeyArray(value);
+			const targetIds = keys.map((key) => targetBaseSlug ? recordIdsByKey.get(recordIdentity(targetBaseSlug, key)) : void 0).filter((id) => Boolean(id));
+			if (targetIds.length !== keys.length) throw new Error(`Internal error: required relation ${node.slug}.${slug} was scheduled before its targets existed.`);
+			result[slug] = targetIds;
+			continue;
+		}
+		if (PACKAGE_COMPUTED_FIELD_TYPES.includes(field.type)) continue;
+		if (field.type === "attachment") continue;
 		result[slug] = value;
 	}
 	return result;
 };
-const createRecords = async (client, base, plan, options, state, recordIdsByKey, app) => {
+const createRecords = async (client, base, recordsToCreate, plan, options, state, recordIdsByKey, app) => {
 	const mergeRecords = options.autoMerge || (app?.mergeSampleRecords ?? false);
-	const records = [...base.node.records].sort((a, b) => a.key.localeCompare(b.key, "en"));
+	const records = [...recordsToCreate].sort((a, b) => a.key.localeCompare(b.key, "en"));
 	for (let offset = 0; offset < records.length; offset += 200) {
 		const batch = records.slice(offset, offset + 200);
 		const changeRequest = await client.bases.createBulkChangeRequest({
 			baseId: base.baseId,
-			records: batch.map((record) => toCreatableFields(base.node, record.fields)),
+			records: batch.map((record) => toCreatableFields(base.node, record.fields, recordIdsByKey)),
 			message: `Install ${batch.length} record(s) into ${base.node.slug}`,
 			submittedBy: options.submittedBy,
 			idempotencyKey: batchIdempotencyKey(plan.tree.manifest.name, batch[0].key),
@@ -6487,7 +6620,7 @@ const createRecords = async (client, base, plan, options, state, recordIdsByKey,
 		const created = (await approveAndMerge(client, changeRequest.id)).changeRequest.operations.filter((operation) => operation.operation === "record_create").sort((a, b) => a.position - b.position);
 		for (const [index, record] of batch.entries()) {
 			const recordId = created[index]?.mergedRecordId;
-			if (recordId) recordIdsByKey.set(record.key, recordId);
+			if (recordId) recordIdsByKey.set(recordIdentity(base.node.slug, record.key), recordId);
 		}
 		state.created.records += batch.length;
 	}
@@ -6502,30 +6635,31 @@ const createRecords = async (client, base, plan, options, state, recordIdsByKey,
 * so the same package always produces the same batches and therefore the same keys.
 */
 const batchIdempotencyKey = (packageName, firstRecordKey) => `pkg:${packageName}:${firstRecordKey}`;
-const linkRelations = async (client, base, relationFieldSlugs, recordIdsByKey, options, state) => {
+const linkRelations = async (client, base, relationFields, recordIdsByKey, options, state) => {
 	for (const record of base.node.records) {
 		const relationValues = {};
-		let hasRelation = false;
-		for (const slug of relationFieldSlugs) {
-			const value = record.fields[slug];
-			const keys = toKeyArray(value);
+		let needsUpdate = false;
+		for (const field of relationFields) {
+			const value = record.fields[field.slug];
+			const keys = toRecordKeyArray(value);
 			if (keys.length === 0) continue;
-			const targetIds = keys.map((key) => recordIdsByKey.get(key)).filter((id) => Boolean(id));
-			const unresolved = keys.filter((key) => !recordIdsByKey.has(key));
-			if (unresolved.length > 0) state.warnings.push(`Record "${record.key}" in base "${base.node.slug}" links field "${slug}" to ${unresolved.length} record(s) that are not in this package — those links were skipped.`);
+			const targetBaseSlug = field.options.targetBaseSlug;
+			const targetIds = keys.map((key) => targetBaseSlug ? recordIdsByKey.get(recordIdentity(targetBaseSlug, key)) : void 0).filter((id) => Boolean(id));
+			const unresolved = keys.filter((key) => !targetBaseSlug || !recordIdsByKey.has(recordIdentity(targetBaseSlug, key)));
+			if (unresolved.length > 0) state.warnings.push(`Record "${record.key}" in base "${base.node.slug}" links field "${field.slug}" to ${unresolved.length} record(s) that are not in target Base "${targetBaseSlug || "(unset)"}" — those links were skipped.`);
 			if (targetIds.length > 0) {
-				relationValues[slug] = targetIds;
-				hasRelation = true;
+				relationValues[field.slug] = targetIds;
+				if (!field.required) needsUpdate = true;
 			}
 		}
-		if (!hasRelation) continue;
-		const recordId = recordIdsByKey.get(record.key);
+		if (!needsUpdate) continue;
+		const recordId = recordIdsByKey.get(recordIdentity(base.node.slug, record.key));
 		if (!recordId) continue;
 		const changeRequest = await client.records.changeRequest({
 			operation: "update",
 			recordId,
 			fields: {
-				...toCreatableFields(base.node, record.fields),
+				...toCreatableFields(base.node, record.fields, recordIdsByKey),
 				...relationValues
 			},
 			message: `Link relations for ${base.node.slug}`,
@@ -6536,11 +6670,6 @@ const linkRelations = async (client, base, relationFieldSlugs, recordIdsByKey, o
 		await approveAndMerge(client, changeRequest.id);
 	}
 };
-const toKeyArray = (value) => {
-	if (Array.isArray(value)) return value.filter((item) => typeof item === "string" && item.length > 0);
-	if (typeof value === "string" && value.length > 0) return [value];
-	return [];
-};
 /** Merging requires an `approved` status, so every auto-merge is review-then-merge. */
 const approveAndMerge = async (client, changeRequestId) => {
 	const reviewResult = (await client.changeRequests.review({
@@ -7681,6 +7810,7 @@ const buildInstallPlan = (tree, target, options = {}) => {
 		planned = applyRenames(prefixed, collisions, target.existingNodeSlugsByType);
 		for (const [installedSlug, originalSlug] of collectSlugRewrites(tree, planned)) resourceKeysBySlug[installedSlug] = originalSlug;
 	}
+	buildRecordCreateLayers(planned.nodes);
 	collectWarnings(planned, warnings);
 	const counts = countTree(planned);
 	if (counts.files > 5e3) throw new Error(`Package has ${counts.files} files, above the ${PACKAGE_MAX_FILE_COUNT}-file limit. Nothing was installed.`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "busa-cli",
-  "version": "0.19.1",
+  "version": "0.19.2",
   "description": "Command-line client for the Busabase OpenAPI REST API. Talks to a local or remote `busabase server`. Short-name alias for busabase-cli.",
   "license": "MIT",
   "homepage": "https://github.com/busabase/busabase/tree/main/apps/busabase-cli",
@@ -33,7 +33,7 @@
   "dependencies": {
     "@zip.js/zip.js": "^2.8.20",
     "busabase-package": "workspace:*",
-    "busabase-sdk": "0.19.1",
+    "busabase-sdk": "0.19.2",
     "commander": "^14.0.0",
     "tar-stream": "^3.1.7",
     "yaml": "^2.9.0",