@better-update/cli 0.10.1 → 0.11.0

package/dist/index.mjs

@@ -27,7 +27,7 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 //#endregion
 //#region package.json
-var version = "0.10.1";
+var version = "0.11.0";
 
 //#endregion
 //#region src/lib/interactive-mode.ts
@@ -1127,37 +1127,51 @@ var DevicesGroup = class extends HttpApiGroup.make("devices").add(HttpApiEndpoin
 
 //#endregion
 //#region ../../packages/api/src/domain/env-var.ts
-const EnvVarVisibility = Schema.Literal("plaintext", "sensitive", "secret");
+const EnvVarVisibility = Schema.Literal("plaintext", "sensitive");
+const EnvVarScope = Schema.Literal("project", "global");
+const EnvVarEnvironment = Schema.Literal("development", "preview", "production");
+const EnvVarListScope = Schema.Literal("all", "project", "global");
 var EnvVar = class extends Schema.Class("EnvVar")({
 	id: Id,
 	organizationId: Id,
-	projectId: Id,
-	environment: Schema.String,
+	projectId: Schema.NullOr(Id),
+	scope: EnvVarScope,
 	key: Schema.String,
 	visibility: EnvVarVisibility,
 	value: Schema.NullOr(Schema.String),
+	environments: Schema.Array(EnvVarEnvironment),
+	overridesGlobal: Schema.optional(Schema.Boolean),
 	createdAt: DateTimeString,
 	updatedAt: DateTimeString
 }) {};
 const EnvVarKey = Schema.String.pipe(Schema.pattern(/^[A-Z][A-Z0-9_]*$/u), Schema.maxLength(256));
 const EnvVarValue = Schema.String.pipe(Schema.maxLength(32768));
-const EnvVarEnvironment = Schema.String.pipe(Schema.minLength(1), Schema.maxLength(64));
+const EnvVarEnvironmentArray = Schema.Array(EnvVarEnvironment).pipe(Schema.minItems(1));
 const CreateEnvVarBody = Schema.Struct({
-	projectId: Id,
-	environment: EnvVarEnvironment,
+	scope: EnvVarScope,
+	projectId: Schema.optional(Id),
+	environments: EnvVarEnvironmentArray,
 	key: EnvVarKey,
 	value: EnvVarValue,
 	visibility: EnvVarVisibility
 });
 const UpdateEnvVarBody = Schema.Struct({
 	value: Schema.optional(EnvVarValue),
+	visibility: Schema.optional(EnvVarVisibility),
+	environments: Schema.optional(EnvVarEnvironmentArray)
+});
+const BulkImportEntry = Schema.Struct({
+	key: EnvVarKey,
+	value: EnvVarValue,
 	visibility: Schema.optional(EnvVarVisibility)
 });
 const BulkImportEnvVarsBody = Schema.Struct({
-	projectId: Id,
-	environment: EnvVarEnvironment,
-	content: Schema.String.pipe(Schema.maxLength(4e6)),
-	visibility: EnvVarVisibility
+	scope: EnvVarScope,
+	projectId: Schema.optional(Id),
+	environments: EnvVarEnvironmentArray,
+	content: Schema.optional(Schema.String.pipe(Schema.maxLength(4e6))),
+	entries: Schema.optional(Schema.Array(BulkImportEntry).pipe(Schema.maxItems(100))),
+	visibility: Schema.optional(EnvVarVisibility)
 });
 const BulkImportResult = Schema.Struct({
 	created: Schema.Number,
@@ -1172,7 +1186,7 @@ const EnvVarExportItem = Schema.Struct({
 });
 const EnvVarExportResult = Schema.Struct({
 	items: Schema.Array(EnvVarExportItem),
-	environment: Schema.String
+	environment: EnvVarEnvironment
 });
 
 //#endregion
@@ -1180,32 +1194,34 @@ const EnvVarExportResult = Schema.Struct({
 const idParam$5 = HttpApiSchema.param("id", Schema.String);
 var EnvVarsGroup = class extends HttpApiGroup.make("env-vars").add(HttpApiEndpoint.post("create", "/api/env-vars").setPayload(CreateEnvVarBody).addSuccess(EnvVar, { status: 201 }).addError(BadRequest).addError(Conflict).annotateContext(OpenApi.annotations({
 	title: "Create environment variable",
-	description: "Create a new environment variable for a project"
+	description: "Create a new environment variable. Scope can be 'project' (requires projectId) or 'global' (organization-wide)."
 }))).add(HttpApiEndpoint.get("list", "/api/env-vars").setUrlParams(Schema.Struct({
-	projectId: Id,
-	environment: Schema.optional(Schema.String),
+	scope: Schema.optional(EnvVarListScope),
+	projectId: Schema.optional(Id),
+	environments: Schema.optional(Schema.String),
+	search: Schema.optional(Schema.String),
 	...PaginationParams.fields
-})).addSuccess(Schema.Struct({ items: Schema.Array(EnvVar) })).annotateContext(OpenApi.annotations({
+})).addSuccess(Schema.Struct({ items: Schema.Array(EnvVar) })).addError(BadRequest).annotateContext(OpenApi.annotations({
 	title: "List environment variables",
-	description: "List environment variables with optional filters"
+	description: "List environment variables. scope=all merges project + global vars with project overrides. environments is a comma-separated list. search matches key substring."
 }))).add(HttpApiEndpoint.get("get")`/api/env-vars/${idParam$5}`.addSuccess(EnvVar).annotateContext(OpenApi.annotations({
 	title: "Get environment variable",
 	description: "Get an environment variable by ID"
 }))).add(HttpApiEndpoint.patch("update")`/api/env-vars/${idParam$5}`.setPayload(UpdateEnvVarBody).addSuccess(EnvVar).addError(BadRequest).annotateContext(OpenApi.annotations({
 	title: "Update environment variable",
-	description: "Update an environment variable's value or visibility"
+	description: "Update value, visibility, or assigned environments"
 }))).add(HttpApiEndpoint.del("delete")`/api/env-vars/${idParam$5}`.addSuccess(DeleteEnvVarResult).annotateContext(OpenApi.annotations({
 	title: "Delete environment variable",
 	description: "Delete an environment variable"
 }))).add(HttpApiEndpoint.post("bulkImport", "/api/env-vars/bulk-import").setPayload(BulkImportEnvVarsBody).addSuccess(BulkImportResult).addError(BadRequest).annotateContext(OpenApi.annotations({
 	title: "Bulk import environment variables",
-	description: "Import environment variables from a dotenv-formatted string. Supports KEY=VALUE format with # comments. Quoted values (single/double) are unquoted. Multiline values are not supported."
+	description: "Import variables from a dotenv-formatted string. Applies to all selected environments. Supports KEY=VALUE format with # comments. Quoted values (single/double) are unquoted. Multiline values are not supported."
 }))).add(HttpApiEndpoint.get("export", "/api/env-vars/export").setUrlParams(Schema.Struct({
 	projectId: Id,
-	environment: Schema.String
+	environment: EnvVarEnvironment
 })).addSuccess(EnvVarExportResult).addError(Forbidden).annotateContext(OpenApi.annotations({
 	title: "Export environment variables",
-	description: "Export environment variables for a project environment"
+	description: "Export environment variables for a project environment. Global org-scoped vars are merged in; project values override globals on key collision."
 }))).addError(NotFound).addError(Forbidden).addError(BadRequest).annotateContext(OpenApi.annotations({
 	title: "Environment Variables",
 	description: "Manage environment variables for project builds and deployments"
@@ -3891,14 +3907,19 @@ const clearBuildCaches = (projectRoot) => Effect.gen(function* () {
 
 //#endregion
 //#region src/lib/env-exporter.ts
+const coerceEnvironment = (raw) => raw === "development" || raw === "preview" || raw === "production" ? raw : void 0;
 /**
 * Pull environment variables for a project + environment and flatten them into
 * a key/value map. Returns an empty map when the project has no variables.
 */
-const pullEnvVars = (api, { projectId, environment }) => api["env-vars"].export({ urlParams: {
-	projectId,
-	environment
-} }).pipe(Effect.map((result) => Object.fromEntries(result.items.map((item) => [item.key, item.value]))), Effect.mapError((cause) => new EnvExportError({ message: `Failed to export environment variables for "${environment}": ${String(cause)}` })));
+const pullEnvVars = (api, { projectId, environment }) => {
+	const validated = coerceEnvironment(environment);
+	if (!validated) return Effect.fail(new EnvExportError({ message: `Invalid environment "${environment}". Must be one of: development, preview, production.` }));
+	return api["env-vars"].export({ urlParams: {
+		projectId,
+		environment: validated
+	} }).pipe(Effect.map((result) => Object.fromEntries(result.items.map((item) => [item.key, item.value]))), Effect.mapError((cause) => new EnvExportError({ message: `Failed to export environment variables for "${environment}": ${String(cause)}` })));
+};
 
 //#endregion
 //#region src/lib/git-context.ts
@@ -10058,36 +10079,45 @@ const envErrorExtras = {
 	SystemError: 6,
 	BadArgument: 6
 };
+const isEnvironmentName = (value) => value === "development" || value === "preview" || value === "production";
+const parseEnvironmentsArg = (raw) => Effect.gen(function* () {
+	const tokens = raw.split(",").map((token) => token.trim()).filter((token) => token.length > 0);
+	if (tokens.length === 0) return yield* new InvalidArgumentError({ message: "Provide at least one environment (development, preview, production)." });
+	const seen = /* @__PURE__ */ new Set();
+	yield* Effect.forEach(tokens, (token) => Effect.gen(function* () {
+		if (!isEnvironmentName(token)) return yield* new InvalidArgumentError({ message: `Invalid environment "${token}". Must be one of: development, preview, production.` });
+		seen.add(token);
+	}), { discard: true });
+	return [...seen];
+});
+const parseSingleEnvironmentArg = (raw) => Effect.gen(function* () {
+	if (!isEnvironmentName(raw)) return yield* new InvalidArgumentError({ message: `Invalid environment "${raw}". Must be one of: development, preview, production.` });
+	return raw;
+});
+const formatEnvironments = (environments) => [...environments].toSorted((left, right) => left.localeCompare(right)).join(",");
 
 //#endregion
 //#region src/commands/env/delete.ts
 const deleteCommand$2 = defineCommand({
 	meta: {
 		name: "delete",
-		description: "Delete an environment variable by key"
-	},
-	args: {
-		key: {
-			type: "positional",
-			required: true,
-			description: "Env var key"
-		},
-		environment: {
-			type: "string",
-			default: "production",
-			description: "Target environment"
-		}
+		description: "Delete a project env var by key"
 	},
+	args: { key: {
+		type: "positional",
+		required: true,
+		description: "Env var key"
+	} },
 	run: async ({ args }) => runEffect(Effect.gen(function* () {
 		const projectId = yield* readProjectId;
 		const api = yield* apiClient;
 		const match = (yield* api["env-vars"].list({ urlParams: {
 			projectId,
-			environment: args.environment
+			scope: "project"
 		} })).items.find((item) => item.key === args.key);
-		if (!match) return yield* new EnvResourceNotFoundError({ message: `Environment variable ${args.key} not found in ${args.environment}` });
+		if (!match) return yield* new EnvResourceNotFoundError({ message: `Project env var "${args.key}" not found.` });
 		yield* api["env-vars"].delete({ path: { id: match.id } });
-		yield* Console.log(`Deleted ${args.key} from ${args.environment}`);
+		yield* Console.log(`Deleted ${args.key}`);
 	}), envErrorExtras)
 });
 
@@ -10139,11 +10169,12 @@ const execCommand = defineCommand({
 	} },
 	run: async ({ args }) => runEffect(Effect.gen(function* () {
 		const [bin, rest] = yield* splitTrailing(getExecTrailingArgv());
+		const environment = yield* parseSingleEnvironmentArg(args.environment);
 		const projectId = yield* readProjectId;
 		const api = yield* apiClient;
 		const runtime = yield* CliRuntime;
 		const baseEnv = yield* runtime.commandEnvironment();
-		const pulled = yield* pullForExec(api, projectId, args.environment);
+		const pulled = yield* pullForExec(api, projectId, environment);
 		const cmd = Command.make(bin, ...rest).pipe(Command.env({
 			...baseEnv,
 			...pulled
@@ -10163,13 +10194,14 @@ const exportCommand = defineCommand({
 	args: { environment: {
 		type: "string",
 		default: "production",
-		description: "Target environment"
+		description: "Target environment (development, preview, production)"
 	} },
 	run: async ({ args }) => runEffect(Effect.gen(function* () {
+		const environment = yield* parseSingleEnvironmentArg(args.environment);
 		const projectId = yield* readProjectId;
 		const result = yield* (yield* apiClient)["env-vars"].export({ urlParams: {
 			projectId,
-			environment: args.environment
+			environment
 		} });
 		for (const item of result.items) {
 			const escaped = item.value.replaceAll("'", String.raw`'\''`);
@@ -10195,7 +10227,8 @@ const getCommand$1 = defineCommand({
 		yield* printKeyValue([
 			["ID", envVar.id],
 			["Key", envVar.key],
-			["Environment", envVar.environment],
+			["Scope", envVar.scope],
+			["Environments", formatEnvironments(envVar.environments)],
 			["Visibility", envVar.visibility],
 			["Value", envVar.visibility === "plaintext" ? envVar.value ?? "" : "******"],
 			["Created", envVar.createdAt],
@@ -10220,25 +10253,23 @@ const importCommand = defineCommand({
 		environment: {
 			type: "string",
 			default: "production",
-			description: "Target environment"
+			description: "Target environments (comma-separated, e.g. development,production). Default: production"
 		},
 		visibility: {
 			type: "enum",
-			options: [
-				"plaintext",
-				"sensitive",
-				"secret"
-			],
+			options: ["plaintext", "sensitive"],
 			default: "plaintext",
 			description: "Visibility applied to all imported values"
 		}
 	},
 	run: async ({ args }) => runEffect(Effect.gen(function* () {
 		const content = yield* (yield* FileSystem.FileSystem).readFileString(args.file);
+		const environments = yield* parseEnvironmentsArg(args.environment);
 		const projectId = yield* readProjectId;
 		const result = yield* (yield* apiClient)["env-vars"].bulkImport({ payload: {
+			scope: "project",
 			projectId,
-			environment: args.environment,
+			environments,
 			content,
 			visibility: args.visibility
 		} });
@@ -10253,25 +10284,44 @@ const listCommand$2 = defineCommand({
 		name: "list",
 		description: "List environment variables"
 	},
-	args: { environment: {
-		type: "string",
-		description: "Filter by environment"
-	} },
+	args: {
+		environments: {
+			type: "string",
+			description: "Filter by environments (comma-separated, e.g. development,production). Default: all"
+		},
+		scope: {
+			type: "enum",
+			options: [
+				"all",
+				"project",
+				"global"
+			],
+			description: "Filter by scope (default: all — merged with global override resolution)"
+		},
+		search: {
+			type: "string",
+			description: "Filter by key substring (case-insensitive)"
+		}
+	},
 	run: async ({ args }) => runEffect(Effect.gen(function* () {
 		const projectId = yield* readProjectId;
 		const api = yield* apiClient;
-		const envFilter = args.environment ? { environment: args.environment } : {};
+		const urlParams = {
+			projectId,
+			...args.scope ? { scope: args.scope } : {},
+			...args.environments ? { environments: args.environments } : {},
+			...args.search ? { search: args.search } : {}
+		};
 		yield* printList([
 			"Key",
-			"Environment",
+			"Environments",
+			"Scope",
 			"Visibility",
 			"Value"
-		], (yield* api["env-vars"].list({ urlParams: {
-			projectId,
-			...envFilter
-		} })).items.map((item) => [
+		], (yield* api["env-vars"].list({ urlParams })).items.map((item) => [
 			item.key,
-			item.environment,
+			formatEnvironments(item.environments),
+			item.overridesGlobal ? `${item.scope} (overrides global)` : item.scope,
 			item.visibility,
 			item.visibility === "plaintext" ? item.value ?? "" : "••••••"
 		]), "No environment variables found.");
@@ -10288,13 +10338,14 @@ const pullCommand = defineCommand({
 	args: { environment: {
 		type: "string",
 		default: "production",
-		description: "Target environment"
+		description: "Target environment (development, preview, production)"
 	} },
 	run: async ({ args }) => runEffect(Effect.gen(function* () {
+		const environment = yield* parseSingleEnvironmentArg(args.environment);
 		const projectId = yield* readProjectId;
 		const result = yield* (yield* apiClient)["env-vars"].export({ urlParams: {
 			projectId,
-			environment: args.environment
+			environment
 		} });
 		for (const item of result.items) {
 			const escaped = item.value.replaceAll("'", String.raw`'\''`);
@@ -10342,7 +10393,7 @@ const pushCommand = defineCommand({
 		environment: {
 			type: "string",
 			default: "production",
-			description: "Target environment"
+			description: "Target environments (comma-separated, e.g. development,production). Default: production"
 		},
 		force: {
 			type: "boolean",
@@ -10355,11 +10406,12 @@ const pushCommand = defineCommand({
 			yield* printHuman(`No valid KEY=VALUE entries found in ${args.file}.`);
 			return;
 		}
+		const environments = yield* parseEnvironmentsArg(args.environment);
 		const projectId = yield* readProjectId;
 		const api = yield* apiClient;
 		const existingResp = yield* api["env-vars"].list({ urlParams: {
 			projectId,
-			environment: args.environment
+			scope: "project"
 		} });
 		const existingByKey = new Map(existingResp.items.map((item) => [item.key, item]));
 		const conflicts = parsed.filter((entry) => existingByKey.has(entry.key));
@@ -10379,8 +10431,9 @@ const pushCommand = defineCommand({
 		});
 		const skipped = conflicts.length - entriesToOverwrite.length;
 		yield* Effect.forEach(newEntries, (entry) => api["env-vars"].create({ payload: {
+			scope: "project",
 			projectId,
-			environment: args.environment,
+			environments,
 			key: entry.key,
 			value: entry.value,
 			visibility: entry.visibility
@@ -10392,11 +10445,12 @@ const pushCommand = defineCommand({
 				path: { id: existing.id },
 				payload: {
 					value: entry.value,
-					visibility: entry.visibility
+					visibility: entry.visibility,
+					environments
 				}
 			});
 		}, { concurrency: 4 });
-		yield* printHuman(`Pushed to ${args.environment}: ${String(newEntries.length)} created, ${String(entriesToOverwrite.length)} updated${skipped > 0 ? `, ${String(skipped)} skipped` : ""}.`);
+		yield* printHuman(`Pushed to ${formatEnvironments(environments)}: ${String(newEntries.length)} created, ${String(entriesToOverwrite.length)} updated${skipped > 0 ? `, ${String(skipped)} skipped` : ""}.`);
 	}), envErrorExtras)
 });
 
@@ -10405,7 +10459,7 @@ const pushCommand = defineCommand({
 const setCommand$1 = defineCommand({
 	meta: {
 		name: "set",
-		description: "Create or update an environment variable"
+		description: "Create or update a project-scoped environment variable"
 	},
 	args: {
 		keyValue: {
@@ -10416,47 +10470,46 @@ const setCommand$1 = defineCommand({
 		environment: {
 			type: "string",
 			default: "production",
-			description: "Target environment"
+			description: "Target environments (comma-separated, e.g. development,production). Default: production"
 		},
 		visibility: {
 			type: "enum",
-			options: [
-				"plaintext",
-				"sensitive",
-				"secret"
-			],
+			options: ["plaintext", "sensitive"],
 			default: "plaintext",
 			description: "Value visibility"
 		}
 	},
 	run: async ({ args }) => runEffect(Effect.gen(function* () {
 		const { key, value } = yield* parseKeyValue(args.keyValue);
-		const { environment } = args;
+		const environments = yield* parseEnvironmentsArg(args.environment);
 		const { visibility } = args;
 		const projectId = yield* readProjectId;
 		const api = yield* apiClient;
 		const match = (yield* api["env-vars"].list({ urlParams: {
 			projectId,
-			environment
+			scope: "project"
 		} })).items.find((item) => item.key === key);
+		const label = formatEnvironments(environments);
 		if (match) {
 			yield* api["env-vars"].update({
 				path: { id: match.id },
 				payload: {
 					value,
-					visibility
+					visibility,
+					environments
 				}
 			});
-			yield* Console.log(`Updated ${key} in ${environment}`);
+			yield* Console.log(`Updated ${key} (environments: ${label})`);
 		} else {
 			yield* api["env-vars"].create({ payload: {
+				scope: "project",
 				projectId,
-				environment,
+				environments,
 				key,
 				value,
 				visibility
 			} });
-			yield* Console.log(`Created ${key} in ${environment}`);
+			yield* Console.log(`Created ${key} (environments: ${label})`);
 		}
 	}), envErrorExtras)
 });
@@ -10466,7 +10519,7 @@ const setCommand$1 = defineCommand({
 const updateCommand$1 = defineCommand({
 	meta: {
 		name: "update",
-		description: "Update an env var's value or visibility"
+		description: "Update a project env var's value, visibility, or environments"
 	},
 	args: {
 		key: {
@@ -10480,32 +10533,29 @@ const updateCommand$1 = defineCommand({
 		},
 		visibility: {
 			type: "enum",
-			options: [
-				"plaintext",
-				"sensitive",
-				"secret"
-			],
+			options: ["plaintext", "sensitive"],
 			description: "New visibility (leave unset to keep current)"
 		},
-		environment: {
+		environments: {
 			type: "string",
-			default: "production",
-			description: "Target environment"
+			description: "New environments assignment (comma-separated, e.g. development,production). Leave unset to keep current."
 		}
 	},
 	run: async ({ args }) => runEffect(Effect.gen(function* () {
-		const { key, value, visibility, environment } = args;
-		if (value === void 0 && visibility === void 0) return yield* new InvalidArgumentError({ message: "Pass --value, --visibility, or both. Nothing to update otherwise." });
+		const { key, value, visibility, environments } = args;
+		if (value === void 0 && visibility === void 0 && environments === void 0) return yield* new InvalidArgumentError({ message: "Pass --value, --visibility, --environments (or any combination). Nothing to update otherwise." });
 		const projectId = yield* readProjectId;
 		const api = yield* apiClient;
 		const match = (yield* api["env-vars"].list({ urlParams: {
 			projectId,
-			environment
+			scope: "project"
 		} })).items.find((item) => item.key === key);
-		if (!match) return yield* new EnvResourceNotFoundError({ message: `Env var "${key}" not found in environment "${environment}".` });
+		if (!match) return yield* new EnvResourceNotFoundError({ message: `Env var "${key}" not found in project.` });
+		const envList = environments ? yield* parseEnvironmentsArg(environments) : void 0;
 		const payload = {
 			...value === void 0 ? {} : { value },
-			...visibility === void 0 ? {} : { visibility }
+			...visibility === void 0 ? {} : { visibility },
+			...envList ? { environments: envList } : {}
 		};
 		yield* api["env-vars"].update({
 			path: { id: match.id },
@@ -10514,7 +10564,8 @@ const updateCommand$1 = defineCommand({
 		const changed = [];
 		if (value !== void 0) changed.push("value");
 		if (visibility !== void 0) changed.push("visibility");
-		yield* printHuman(`Updated ${changed.join(" + ")} for ${key} in ${environment}.`);
+		if (envList) changed.push("environments");
+		yield* printHuman(`Updated ${changed.join(" + ")} for ${key}.`);
 	}), envErrorExtras)
 });