@bedrock-rbx/core 0.1.0-beta.11 → 0.1.0-beta.13

package/dist/cli/run.mjs

@@ -1,13 +1,12 @@
 #!/usr/bin/env node
-import { T as serializeStateFile, a as buildStatePort, d as resolveStateConfig, f as flattenConfig, h as diff, i as loadConfig, l as validatePlan, n as serializeConfig, o as buildDesired, r as deploy, t as migrateMantleState, u as selectEnvironment } from "../migrate-mantle-state-DjAU-I39.mjs";
-import { PermissionError } from "@bedrock-rbx/ocale";
+import { B as createClackProgressAdapter, G as renderMigrationSummary, H as renderDeployError, K as renderParseError, O as serializeStateFile, U as renderMigrateError, V as renderBuildStatePortError, W as renderMigrateParseError, _ as diff, a as buildStatePort, d as selectMergedEnvironment, f as collectRedactionAnnotations, i as loadConfig, l as validatePlan, m as flattenConfig, n as serializeConfig, o as buildDesired, p as resolveStateConfig, q as renderStateWriteError, r as deploy, t as migrateMantleState, u as selectEnvironment, x as createClackPort } from "../migrate-mantle-state-CQjWBZwT.mjs";
+import { isCancel, path, select, text } from "@clack/prompts";
 import process from "node:process";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import sade from "sade";
-import { cancel, intro, isCancel, log, outro, path, select, text } from "@clack/prompts";
 //#region package.json
-var version = "0.1.0-beta.11";
+var version = "0.1.0-beta.13";
 //#endregion
 //#region src/cli/credential-environment-overrides.ts
 /**
@@ -117,202 +116,6 @@ function pickString(rawOptions, ...keys) {
 	}
 }
 //#endregion
-//#region src/cli/render.ts
-/**
-* Render a `DeployError` to the supplied `ClackPort` as a single error line.
-* Each variant produces a distinct, terse diagnostic; wrapped variants
-* (`applyFailed`, `buildDesiredFailed`, `configLoadFailed`, `stateReadFailed`,
-* `stateWriteFailed`) surface the inner cause's actionable detail (file path,
-* resource key, parser message, HTTP failure, validator issue) so the reader
-* does not have to inspect the full cause to act.
-* @param err - The deploy error to describe.
-* @param port - The output port the diagnostic is written to.
-*/
-function renderDeployError(err, port) {
-	port.logError(deployErrorMessage(err));
-}
-/**
-* Render a `ParseOptionsError` to the supplied `ClackPort` as a single
-* error line. Each variant names the offending flag so the diagnostic
-* pinpoints what the caller needs to change.
-* @param err - The parse error to describe.
-* @param port - The output port the diagnostic is written to.
-*/
-function renderParseError(err, port) {
-	port.logError(parseErrorMessage(err));
-}
-/**
-* Construct a `ClackPort` whose methods delegate to `@clack/prompts`. The
-* resulting port writes to `process.stdout` via clack's defaults.
-* @returns A port whose six methods each invoke the matching clack helper.
-*/
-function createClackPort() {
-	return {
-		cancel: (message) => {
-			cancel(message);
-		},
-		intro: (message) => {
-			intro(message);
-		},
-		logError: (message) => {
-			log.error(message);
-		},
-		logMessage: (message) => {
-			log.message(message);
-		},
-		logSuccess: (message) => {
-			log.success(message);
-		},
-		outro: (message) => {
-			outro(message);
-		}
-	};
-}
-/**
-* Render a `ParseMigrateError` to the supplied `ClackPort`. Reuses
-* `parseErrorMessage` for the three flag-shape variants and adds a
-* dedicated message for `unknownSource` listing the supported sources.
-* @param err - The parse error to describe.
-* @param port - The output port the diagnostic is written to.
-*/
-function renderMigrateParseError(err, port) {
-	port.logError(migrateParseErrorMessage(err));
-}
-/**
-* Render a `MigrateError` to the supplied `ClackPort` as a single error
-* line. Each variant points at the offending Mantle state file path,
-* primary-environment input, or wrapped `ConfigError` so the reader can
-* act without inspecting the raw error object.
-* @param err - The migrate error to describe.
-* @param port - The output port the diagnostic is written to.
-*/
-function renderMigrateError(err, port) {
-	port.logError(migrateErrorMessage(err));
-}
-/**
-* Render a `MissingCredentialError` or `UnsupportedBackendError`
-* surfaced when the migrate command tried to default-construct the
-* configured `StatePort` and was missing its inputs.
-* @param err - The error returned by `buildStatePort`.
-* @param port - The output port the diagnostic is written to.
-*/
-function renderBuildStatePortError(err, port) {
-	port.logError(buildStatePortErrorMessage(err));
-}
-/**
-* Render the post-migrate review prompt to the supplied `ClackPort`.
-* Three outcomes:
-*
-* - Any `ambiguous` warnings exist: emit a single error line directing
-*   the user to the report. The migration ran but there are decisions
-*   the user still needs to make before deploy will be meaningful.
-* - No `ambiguous` warnings but non-zero `blocked` / `deferred` /
-*   `interpretive`: emit a single success line pointing at the report
-*   for auditing.
-* - All counts zero: silent. The closing `outro("migrate succeeded")`
-*   already speaks for the run.
-* @param input - Counts plus the path of the Markdown report.
-* @param port - The output port the line is written to.
-*/
-function renderMigrationSummary(input, port) {
-	const { ambiguousCount, blockedCount, deferredCount, interpretiveCount } = input.summary;
-	if (ambiguousCount > 0) {
-		port.logError(`action required: ${String(ambiguousCount)} fields need your input. See ${input.reportPath}`);
-		return;
-	}
-	const reviewable = blockedCount + deferredCount + interpretiveCount;
-	if (reviewable > 0) port.logSuccess(`migration complete; see ${input.reportPath} for ${String(reviewable)} auto-mapped or skipped fields`);
-}
-/**
-* Render a `StateError` produced when the migrator wrote a per-environment
-* state through the `StatePort`. Names the environment alongside the
-* adapter's failure reason so the reader knows which write failed.
-* @param input - Environment + state-error to describe.
-* @param port - The output port the diagnostic is written to.
-*/
-function renderStateWriteError(input, port) {
-	port.logError(`state write failed for '${input.environment}' (${input.err.file}): ${input.err.reason}`);
-}
-function permissionDetail(err) {
-	const isPlural = err.requiredScopes.length > 1;
-	const label = isPlural ? "scopes" : "scope";
-	const pronoun = isPlural ? "them" : "it";
-	const scopeList = err.requiredScopes.map((scope) => `'${scope}'`).join(", ");
-	return `${err.message} on ${err.operationKey}: missing required ${label} ${scopeList}. Grant ${pronoun} on the API key at https://create.roblox.com/credentials`;
-}
-function applyCauseDetail(cause) {
-	switch (cause.kind) {
-		case "driverFailure":
-			if (cause.cause instanceof PermissionError) return permissionDetail(cause.cause);
-			return cause.cause.message;
-		case "updateUnsupported": return "update not supported";
-	}
-}
-function buildDesiredDetail(cause) {
-	switch (cause.kind) {
-		case "fileReadFailed": return `(${cause.filePath}): ${cause.reason}`;
-		case "iconRemovalRejected": return `: ${cause.message}`;
-	}
-}
-function configErrorDetail(err) {
-	switch (err.kind) {
-		case "configFunctionFailed": return `${err.sourceFile}: config function threw: ${err.message}`;
-		case "fileNotFound": return `no bedrock config under ${err.searchedFrom}`;
-		case "luauRuntimeMissing": return `${err.sourceFile}: ${err.hint}`;
-		case "parseFailed": return `${err.sourceFile}: ${err.message}`;
-		case "validationFailed": {
-			const first = err.issues[0];
-			return first === void 0 ? `${err.sourceFile}: invalid` : `${err.sourceFile}: ${first.path.join(".")} ${first.message}`;
-		}
-	}
-}
-function stateErrorDetail(cause) {
-	return `(${cause.file}): ${cause.reason}`;
-}
-function deployErrorMessage(err) {
-	switch (err.kind) {
-		case "applyFailed": return `apply failed for '${err.cause.key}': ${applyCauseDetail(err.cause)}`;
-		case "buildDesiredFailed": return `build desired state failed for '${err.cause.key}' ${buildDesiredDetail(err.cause)}`;
-		case "configLoadFailed": return `config load failed: ${configErrorDetail(err.cause)}`;
-		case "incompletePlaceEntry": return `place '${err.key}' is missing '${err.missingField}' under environment '${err.environment}'`;
-		case "incompleteUniverseEntry": return `universe is missing '${err.missingField}' under environment '${err.environment}'`;
-		case "missingCredential": return `missing credential: environment variable ${err.variable} is not set`;
-		case "registryConfigMissing": return `registry config missing '${err.missing}' (${err.hint})`;
-		case "stateNotConfigured": return `state not configured for environment '${err.environment}'`;
-		case "stateReadFailed": return `state read failed ${stateErrorDetail(err.cause)}`;
-		case "stateWriteFailed": return `state write failed ${stateErrorDetail(err.cause)}`;
-		case "unknownEnvironment": return `unknown environment '${err.environment}' (declared: ${err.declared.join(", ")})`;
-		case "unsupportedBackend": return `unsupported state backend '${err.backend}' (${err.hint})`;
-	}
-}
-function parseErrorMessage(err) {
-	switch (err.kind) {
-		case "invalidValue": return `invalid value for flag '--${err.flag}' (expected a string)`;
-		case "missingRequired": return `missing required flag --${err.flag}`;
-		case "unknownFlag": return `unknown flag '--${err.flag}'`;
-	}
-}
-function migrateParseErrorMessage(err) {
-	if (err.kind === "unknownSource") return `unknown migration source '${err.received}' (supported: ${err.supported.join(", ")})`;
-	return parseErrorMessage(err);
-}
-function migrateErrorMessage(err) {
-	switch (err.kind) {
-		case "internalError": return `migrate internal error: ${err.reason} (${configErrorDetail(err.cause)})`;
-		case "primaryEnvironmentNotFound": return `primary environment '${err.primary}' not found (available: ${err.available.join(", ")})`;
-		case "primaryEnvironmentRequired": return `primary environment required (available: ${err.available.join(", ")})`;
-		case "stateFileNotFound": return `Mantle state file not found at '${err.path}'`;
-		case "stateParseFailed": return `Mantle state file at '${err.path}' could not be parsed: ${err.reason}`;
-		case "unsupportedMantleStateVersion": return `unsupported Mantle state version '${err.found}' (supported: ${err.supported.join(", ")})`;
-	}
-}
-function buildStatePortErrorMessage(err) {
-	switch (err.kind) {
-		case "missingCredential": return `missing credential: environment variable ${err.variable} is not set`;
-		case "unsupportedBackend": return `unsupported state backend '${err.backend}' (${err.hint})`;
-	}
-}
-//#endregion
 //#region src/cli/commands/deploy.ts
 /**
 * Build the sade action for `bedrock deploy`. The returned function consumes
@@ -333,11 +136,13 @@ function deployCommand(deps) {
 	};
 }
 function resolveDeploy(deps) {
+	const clack = deps.clack ?? createClackPort();
 	return {
-		clack: deps.clack ?? createClackPort(),
+		clack,
 		deploy: deps.deploy ?? deploy,
 		exit: deps.exit ?? ((code) => process.exit(code)),
-		loadConfig: deps.loadConfig ?? loadConfig
+		loadConfig: deps.loadConfig ?? loadConfig,
+		progress: deps.progress ?? createClackProgressAdapter({ clack })
 	};
 }
 function loadOptionsFor$1(parsed) {
@@ -352,9 +157,17 @@ async function dispatchEnvironments$1(inputs) {
 			environment,
 			getEnv
 		});
-		if (result.success) resolved.clack.logSuccess(`${environment}: ${result.data.resources.length} resources reconciled`);
+		if (result.success) resolved.progress.emit({
+			environment,
+			kind: "deploySuccess",
+			resourceCount: result.data.resources.length
+		});
 		else {
-			renderDeployError(result.err, resolved.clack);
+			resolved.progress.emit({
+				environment,
+				error: result.err,
+				kind: "deployFailure"
+			});
 			failed.push(environment);
 		}
 	}
@@ -453,15 +266,31 @@ function pickStatePort(options, config) {
 		stateConfig: stateConfig.data
 	});
 }
-async function resolveDeps(options) {
-	const config = await pickConfig(options);
-	if (!config.success) return config;
-	const selected = selectEnvironment(config.data, options.environment);
+function resolveEnvironmentView(config, environment) {
+	const merged = selectMergedEnvironment(config, environment);
+	if (!merged.success) return {
+		err: merged.err,
+		success: false
+	};
+	const selected = selectEnvironment(config, environment);
 	if (!selected.success) return {
 		err: selected.err,
 		success: false
 	};
-	const effective = selected.data;
+	return {
+		data: {
+			effective: selected.data,
+			redactions: collectRedactionAnnotations(merged.data.merged)
+		},
+		success: true
+	};
+}
+async function resolveDeps(options) {
+	const config = await pickConfig(options);
+	if (!config.success) return config;
+	const view = resolveEnvironmentView(config.data, options.environment);
+	if (!view.success) return view;
+	const { effective, redactions } = view.data;
 	const readFile$1 = options.readFile ?? readFile;
 	const statePort = pickStatePort(options, effective);
 	if (!statePort.success) return statePort;
@@ -469,6 +298,7 @@ async function resolveDeps(options) {
 		data: {
 			config: effective,
 			readFile: readFile$1,
+			redactions,
 			statePort: statePort.data
 		},
 		success: true
@@ -503,7 +333,8 @@ async function runPreview(environment, deps) {
 	return {
 		data: {
 			environment,
-			ops: diff(desired.data, priorResources)
+			ops: diff(desired.data, priorResources),
+			redactions: deps.redactions
 		},
 		success: true
 	};
@@ -556,14 +387,27 @@ function describeOp(op) {
 function isDriftOp(op) {
 	return op.type !== "noop";
 }
+function describeRedaction(redaction) {
+	const suffix = redaction.hasRealValueEdits ? "redacted, real values not pushed" : "redacted";
+	return `- ${redaction.kind}:${redaction.key} (${suffix})`;
+}
+function renderRedactions(preview, clack) {
+	const driftPairs = new Set(preview.ops.filter(isDriftOp).map((op) => `${op.desired.kind}:${op.key}`));
+	const redactedNoops = preview.redactions.filter((redaction) => !driftPairs.has(`${redaction.kind}:${redaction.key}`));
+	if (redactedNoops.length === 0) return;
+	clack.logMessage(`Redacted in "${preview.environment}":`);
+	for (const redaction of redactedNoops) clack.logMessage(describeRedaction(redaction));
+}
 function renderPreview(preview, clack) {
 	const drift = preview.ops.filter(isDriftOp);
 	if (drift.length === 0) {
 		clack.logSuccess(`No drift for "${preview.environment}"`);
+		renderRedactions(preview, clack);
 		return false;
 	}
 	clack.logMessage(`Pending changes for "${preview.environment}":`);
 	for (const op of drift) clack.logMessage(describeOp(op));
+	renderRedactions(preview, clack);
 	return true;
 }
 async function dispatchEnvironments(inputs) {