@better-update/cli 0.6.2 → 0.6.3

package/dist/index.mjs

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 import { createRequire } from "node:module";
-import process from "node:process";
-import { Args, Command, Options, Prompt } from "@effect/cli";
-import { NodeContext, NodeRuntime } from "@effect/platform-node";
-import { Cause, Console, Context, Data, Deferred, Duration, Effect, Fiber, Layer, Match, Option, ParseResult, Redacted, Schema, Stream } from "effect";
-import { Command as Command$1, FetchHttpClient, FileSystem, HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema, HttpApiSecurity, HttpClient, HttpClientRequest, OpenApi } from "@effect/platform";
+import { defineCommand, runMain } from "citty";
+import { Console, Context, Data, Deferred, Duration, Effect, Fiber, Layer, Match, Option, ParseResult, Schema, Stream } from "effect";
+import { Command, FetchHttpClient, FileSystem, HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema, HttpApiSecurity, HttpClient, HttpClientRequest, OpenApi } from "@effect/platform";
+import { NodeContext } from "@effect/platform-node";
 import path from "node:path";
+import process$1 from "node:process";
 import { maxBy, uniqBy } from "es-toolkit";
 import { createHash, randomBytes, randomUUID } from "node:crypto";
 import { createReadStream } from "node:fs";
@@ -14,10 +14,88 @@ import plist from "@expo/plist";
 import { ExpoRunFormatter } from "@expo/xcpretty";
 import { getFormattedSerialNumber, getX509Certificate, parsePKCS12 } from "@expo/pkcs12";
 import { createServer } from "node:http";
+import { cancel, isCancel, password } from "@clack/prompts";
 
 //#region \0rolldown/runtime.js
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
+//#endregion
+//#region src/lib/exit-codes.ts
+var AuthRequiredError = class extends Data.TaggedError("AuthRequiredError") {};
+var ProjectNotLinkedError = class extends Data.TaggedError("ProjectNotLinkedError") {};
+var UploadFailedError = class extends Data.TaggedError("UploadFailedError") {};
+var BuildProfileError = class extends Data.TaggedError("BuildProfileError") {};
+var RuntimeVersionError = class extends Data.TaggedError("RuntimeVersionError") {};
+var MissingCredentialsError = class extends Data.TaggedError("MissingCredentialsError") {};
+var BuildFailedError = class extends Data.TaggedError("BuildFailedError") {};
+var ReserveError = class extends Data.TaggedError("ReserveError") {};
+var CompleteError = class extends Data.TaggedError("CompleteError") {};
+var PresignedUrlExpiredError = class extends Data.TaggedError("PresignedUrlExpiredError") {};
+var ArtifactNotFoundError = class extends Data.TaggedError("ArtifactNotFoundError") {};
+var KeychainError = class extends Data.TaggedError("KeychainError") {};
+var ProvisioningError = class extends Data.TaggedError("ProvisioningError") {};
+var EnvExportError = class extends Data.TaggedError("EnvExportError") {};
+var UpdatePublishError = class extends Data.TaggedError("UpdatePublishError") {};
+var UpdateRollbackError = class extends Data.TaggedError("UpdateRollbackError") {};
+var UpdatePromoteError = class extends Data.TaggedError("UpdatePromoteError") {};
+var CredentialValidationError = class extends Data.TaggedError("CredentialValidationError") {};
+var AppleAuthError = class extends Data.TaggedError("AppleAuthError") {};
+var InvalidArgumentError = class extends Data.TaggedError("InvalidArgumentError") {};
+
+//#endregion
+//#region src/lib/format-error.ts
+const formatCause = (cause) => {
+	if (cause instanceof Error) return cause.message;
+	if (typeof cause === "object" && cause !== null) {
+		const tagged = cause;
+		const tag = typeof tagged._tag === "string" ? tagged._tag : void 0;
+		const message = typeof tagged.message === "string" ? tagged.message : void 0;
+		if (tag && message) return `${tag}: ${message}`;
+		if (message) return message;
+		if (tag) return tag;
+	}
+	return String(cause);
+};
+
+//#endregion
+//#region src/lib/record.ts
+const isRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+const asRecord = (value) => isRecord(value) ? value : void 0;
+
+//#endregion
+//#region src/lib/app-json.ts
+const readAppJson = Effect.gen(function* () {
+	const content = yield* (yield* FileSystem.FileSystem).readFileString("./app.json").pipe(Effect.mapError(() => new ProjectNotLinkedError({ message: "app.json not found in current directory" })));
+	const parsed = yield* Effect.try({
+		try: () => JSON.parse(content),
+		catch: () => new ProjectNotLinkedError({ message: "app.json contains malformed JSON" })
+	});
+	if (!isRecord(parsed)) return yield* new ProjectNotLinkedError({ message: "app.json must be a JSON object" });
+	return parsed;
+});
+const readProjectId = Effect.gen(function* () {
+	const projectId = asRecord(asRecord(asRecord((yield* readAppJson)["expo"])?.["extra"])?.["betterUpdate"])?.["projectId"];
+	if (typeof projectId !== "string") return yield* new ProjectNotLinkedError({ message: "Project not linked. Run `better-update link` to connect this project, or set expo.extra.betterUpdate.projectId in app.json." });
+	return projectId;
+});
+const readSlug = Effect.gen(function* () {
+	const slug = asRecord((yield* readAppJson)["expo"])?.["slug"];
+	if (typeof slug !== "string") return yield* new ProjectNotLinkedError({ message: "Missing expo.slug in app.json. Required to identify the project." });
+	return slug;
+});
+const writeProjectId = (id) => Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const appJson = yield* readAppJson;
+	const expo = asRecord(appJson["expo"]) ?? {};
+	const extra = asRecord(expo["extra"]) ?? {};
+	const betterUpdate = asRecord(extra["betterUpdate"]) ?? {};
+	betterUpdate["projectId"] = id;
+	extra["betterUpdate"] = betterUpdate;
+	expo["extra"] = extra;
+	appJson["expo"] = expo;
+	yield* fs.writeFileString("./app.json", `${JSON.stringify(appJson, null, 2)}\n`);
+}).pipe(Effect.mapError((cause) => cause instanceof ProjectNotLinkedError ? cause : new ProjectNotLinkedError({ message: `Failed to write project ID to app.json: ${formatCause(cause)}` })));
+
 //#endregion
 //#region ../../packages/api/src/auth/context.ts
 var AuthContext = class extends Context.Tag("api/AuthContext")() {};
@@ -1363,65 +1441,23 @@ var ProtocolApi = class extends HttpApi.make("protocol-api").add(ManifestGroup).
 	description: "Expo Updates protocol endpoints (unauthenticated)"
 })) {};
 
-//#endregion
-//#region src/lib/exit-codes.ts
-var AuthRequiredError = class extends Data.TaggedError("AuthRequiredError") {};
-var ProjectNotLinkedError = class extends Data.TaggedError("ProjectNotLinkedError") {};
-var UploadFailedError = class extends Data.TaggedError("UploadFailedError") {};
-var BuildProfileError = class extends Data.TaggedError("BuildProfileError") {};
-var RuntimeVersionError = class extends Data.TaggedError("RuntimeVersionError") {};
-var MissingCredentialsError = class extends Data.TaggedError("MissingCredentialsError") {};
-var BuildFailedError = class extends Data.TaggedError("BuildFailedError") {};
-var ReserveError = class extends Data.TaggedError("ReserveError") {};
-var CompleteError = class extends Data.TaggedError("CompleteError") {};
-var PresignedUrlExpiredError = class extends Data.TaggedError("PresignedUrlExpiredError") {};
-var ArtifactNotFoundError = class extends Data.TaggedError("ArtifactNotFoundError") {};
-var KeychainError = class extends Data.TaggedError("KeychainError") {};
-var ProvisioningError = class extends Data.TaggedError("ProvisioningError") {};
-var EnvExportError = class extends Data.TaggedError("EnvExportError") {};
-var UpdatePublishError = class extends Data.TaggedError("UpdatePublishError") {};
-var UpdateRollbackError = class extends Data.TaggedError("UpdateRollbackError") {};
-var UpdatePromoteError = class extends Data.TaggedError("UpdatePromoteError") {};
-var CredentialValidationError = class extends Data.TaggedError("CredentialValidationError") {};
-var AppleAuthError = class extends Data.TaggedError("AppleAuthError") {};
-
-//#endregion
-//#region src/lib/format-error.ts
-const formatCause = (cause) => {
-	if (cause instanceof Error) return cause.message;
-	if (typeof cause === "object" && cause !== null) {
-		const tagged = cause;
-		const tag = typeof tagged._tag === "string" ? tagged._tag : void 0;
-		const message = typeof tagged.message === "string" ? tagged.message : void 0;
-		if (tag && message) return `${tag}: ${message}`;
-		if (message) return message;
-		if (tag) return tag;
-	}
-	return String(cause);
-};
-
-//#endregion
-//#region src/lib/record.ts
-const isRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
-const asRecord = (value) => isRecord(value) ? value : void 0;
-
 //#endregion
 //#region src/services/cli-runtime.ts
-const definedEnvironment = () => Object.fromEntries(Object.entries(process.env).flatMap(([key, value]) => typeof value === "string" ? [[key, value]] : []));
+const definedEnvironment = () => Object.fromEntries(Object.entries(process$1.env).flatMap(([key, value]) => typeof value === "string" ? [[key, value]] : []));
 var CliRuntime = class extends Context.Tag("cli/CliRuntime")() {};
 const CliRuntimeLive = Layer.succeed(CliRuntime, {
-	argv: [...process.argv],
-	platform: process.platform,
-	cwd: Effect.sync(() => process.cwd()),
-	getEnv: (name) => Effect.sync(() => process.env[name]),
-	homeDirectory: Effect.sync(() => process.env["HOME"] ?? process.env["USERPROFILE"] ?? process.cwd()),
-	userName: Effect.sync(() => process.env["USER"] ?? process.env["USERNAME"] ?? "better-update"),
+	argv: [...process$1.argv],
+	platform: process$1.platform,
+	cwd: Effect.sync(() => process$1.cwd()),
+	getEnv: (name) => Effect.sync(() => process$1.env[name]),
+	homeDirectory: Effect.sync(() => process$1.env["HOME"] ?? process$1.env["USERPROFILE"] ?? process$1.cwd()),
+	userName: Effect.sync(() => process$1.env["USER"] ?? process$1.env["USERNAME"] ?? "better-update"),
 	commandEnvironment: (overrides = {}) => Effect.sync(() => ({
 		...definedEnvironment(),
 		...overrides
 	})),
 	setExitCode: (code) => Effect.sync(() => {
-		process.exitCode = code;
+		process$1.exitCode = code;
 	})
 });
 
@@ -1608,55 +1644,6 @@ const PresignedUploadLayer = PresignedUploadClientLive.pipe(Layer.provide(CliPla
 const UpdateAssetUploaderLayer = UpdateAssetUploaderLive.pipe(Layer.provide(Layer.mergeAll(ApiClientLayer, PresignedUploadLayer)));
 const CliLive = Layer.mergeAll(CliAdapterDependencies, ApiClientLayer, PresignedUploadLayer, UpdateAssetUploaderLayer);
 
-//#endregion
-//#region src/lib/app-json.ts
-const readAppJson = Effect.gen(function* () {
-	const content = yield* (yield* FileSystem.FileSystem).readFileString("./app.json").pipe(Effect.mapError(() => new ProjectNotLinkedError({ message: "app.json not found in current directory" })));
-	const parsed = yield* Effect.try({
-		try: () => JSON.parse(content),
-		catch: () => new ProjectNotLinkedError({ message: "app.json contains malformed JSON" })
-	});
-	if (!isRecord(parsed)) return yield* new ProjectNotLinkedError({ message: "app.json must be a JSON object" });
-	return parsed;
-});
-const readProjectId = Effect.gen(function* () {
-	const projectId = asRecord(asRecord(asRecord((yield* readAppJson)["expo"])?.["extra"])?.["betterUpdate"])?.["projectId"];
-	if (typeof projectId !== "string") return yield* new ProjectNotLinkedError({ message: "Project not linked. Run `better-update link` to connect this project, or set expo.extra.betterUpdate.projectId in app.json." });
-	return projectId;
-});
-const readSlug = Effect.gen(function* () {
-	const slug = asRecord((yield* readAppJson)["expo"])?.["slug"];
-	if (typeof slug !== "string") return yield* new ProjectNotLinkedError({ message: "Missing expo.slug in app.json. Required to identify the project." });
-	return slug;
-});
-const writeProjectId = (id) => Effect.gen(function* () {
-	const fs = yield* FileSystem.FileSystem;
-	const appJson = yield* readAppJson;
-	const expo = asRecord(appJson["expo"]) ?? {};
-	const extra = asRecord(expo["extra"]) ?? {};
-	const betterUpdate = asRecord(extra["betterUpdate"]) ?? {};
-	betterUpdate["projectId"] = id;
-	extra["betterUpdate"] = betterUpdate;
-	expo["extra"] = extra;
-	appJson["expo"] = expo;
-	yield* fs.writeFileString("./app.json", `${JSON.stringify(appJson, null, 2)}\n`);
-}).pipe(Effect.mapError((cause) => cause instanceof ProjectNotLinkedError ? cause : new ProjectNotLinkedError({ message: `Failed to write project ID to app.json: ${formatCause(cause)}` })));
-
-//#endregion
-//#region src/lib/output.ts
-const printTable = (headers, rows) => Effect.gen(function* () {
-	const allRows = [headers, ...rows];
-	const colWidths = headers.map((_, colIndex) => Math.max(...allRows.map((row) => (row[colIndex] ?? "").length)));
-	const formatRow = (row) => row.map((cell, idx) => cell.padEnd(colWidths[idx] ?? 0)).join("  ");
-	yield* Console.log(formatRow(headers));
-	yield* Console.log(colWidths.map((width) => "-".repeat(width)).join("  "));
-	for (const row of rows) yield* Console.log(formatRow(row));
-});
-const printKeyValue = (pairs) => Effect.gen(function* () {
-	const maxKeyLen = Math.max(...pairs.map(([key]) => key.length));
-	for (const [key, value] of pairs) yield* Console.log(`${key.padEnd(maxKeyLen)}  ${value}`);
-});
-
 //#endregion
 //#region src/application/command-exit.ts
 const exitWith = (code, message) => Console.error(message).pipe(Effect.zipRight(Effect.gen(function* () {
@@ -1671,7 +1658,8 @@ const BASE_TAG_MAP = {
 	NotFound: 1,
 	Conflict: 1,
 	Forbidden: 1,
-	BadRequest: 2
+	BadRequest: 2,
+	InvalidArgumentError: 2
 };
 const SYSTEM_TAG_MESSAGE = {
 	SystemError: (error) => `Filesystem error: ${error.message}`,
@@ -1698,287 +1686,394 @@ const makeCommandErrorHandler = (extras = {}) => {
 };
 
 //#endregion
-//#region src/commands/analytics/helpers.ts
-const handleAnalyticsCommandErrors = makeCommandErrorHandler();
+//#region src/lib/citty-effect.ts
+const runEffect = async (effect, extras = {}) => {
+	const provided = makeCommandErrorHandler(extras)(effect).pipe(Effect.provide(CliLive));
+	return Effect.runPromise(provided.pipe(Effect.asVoid));
+};
+
+//#endregion
+//#region src/lib/output.ts
+const printTable = (headers, rows) => Effect.gen(function* () {
+	const allRows = [headers, ...rows];
+	const colWidths = headers.map((_, colIndex) => Math.max(...allRows.map((row) => (row[colIndex] ?? "").length)));
+	const formatRow = (row) => row.map((cell, idx) => cell.padEnd(colWidths[idx] ?? 0)).join("  ");
+	yield* Console.log(formatRow(headers));
+	yield* Console.log(colWidths.map((width) => "-".repeat(width)).join("  "));
+	for (const row of rows) yield* Console.log(formatRow(row));
+});
+const printKeyValue = (pairs) => Effect.gen(function* () {
+	const maxKeyLen = Math.max(...pairs.map(([key]) => key.length));
+	for (const [key, value] of pairs) yield* Console.log(`${key.padEnd(maxKeyLen)}  ${value}`);
+});
 
 //#endregion
 //#region src/commands/analytics/adoption.ts
-const period$3 = Options.choice("period", [
-	"1d",
-	"7d",
-	"30d",
-	"90d"
-]).pipe(Options.optional);
-const adoptionCommand = Command.make("adoption", { period: period$3 }, (opts) => Effect.gen(function* () {
-	const projectId = yield* readProjectId;
-	const api = yield* apiClient;
-	const periodFilter = Option.match(opts.period, {
-		onNone: () => ({}),
-		onSome: (periodValue) => ({ period: periodValue })
-	});
-	const result = yield* api.analytics.adoption({ urlParams: {
-		projectId,
-		...periodFilter
-	} });
-	if (result.updates.length === 0) {
-		yield* Console.log("No adoption data found.");
-		return;
-	}
-	yield* printTable([
-		"Update ID",
-		"Devices",
-		"First Seen",
-		"Last Seen"
-	], result.updates.map((update) => [
-		update.updateId,
-		String(update.devices),
-		update.firstSeen,
-		update.lastSeen
-	]));
-}).pipe(handleAnalyticsCommandErrors));
+const adoptionCommand = defineCommand({
+	meta: {
+		name: "adoption",
+		description: "Show update adoption across devices"
+	},
+	args: { period: {
+		type: "enum",
+		options: [
+			"1d",
+			"7d",
+			"30d",
+			"90d"
+		],
+		description: "Time window"
+	} },
+	run: async ({ args }) => runEffect(Effect.gen(function* () {
+		const projectId = yield* readProjectId;
+		const api = yield* apiClient;
+		const periodFilter = args.period ? { period: args.period } : {};
+		const result = yield* api.analytics.adoption({ urlParams: {
+			projectId,
+			...periodFilter
+		} });
+		if (result.updates.length === 0) {
+			yield* Console.log("No adoption data found.");
+			return;
+		}
+		yield* printTable([
+			"Update ID",
+			"Devices",
+			"First Seen",
+			"Last Seen"
+		], result.updates.map((update) => [
+			update.updateId,
+			String(update.devices),
+			update.firstSeen,
+			update.lastSeen
+		]));
+	}))
+});
 
 //#endregion
 //#region src/commands/analytics/channels.ts
-const channel$1 = Options.text("channel");
-const period$2 = Options.choice("period", [
-	"1d",
-	"7d",
-	"30d",
-	"90d"
-]).pipe(Options.optional);
-const channelsCommand$1 = Command.make("channels", {
-	channel: channel$1,
-	period: period$2
-}, (opts) => Effect.gen(function* () {
-	const projectId = yield* readProjectId;
-	const api = yield* apiClient;
-	const periodFilter = Option.match(opts.period, {
-		onNone: () => ({}),
-		onSome: (periodValue) => ({ period: periodValue })
-	});
-	const result = yield* api.analytics.channels({ urlParams: {
-		projectId,
-		channel: opts.channel,
-		...periodFilter
-	} });
-	yield* printKeyValue([
-		["Channel", result.channel],
-		["Total Requests", String(result.totalRequests)],
-		["Unique Devices", String(result.uniqueDevices)],
-		["Manifest", String(result.responseTypeDistribution.manifest)],
-		["Directive", String(result.responseTypeDistribution.directive)],
-		["No Update", String(result.responseTypeDistribution.no_update)]
-	]);
-}).pipe(handleAnalyticsCommandErrors));
+const channelsCommand$1 = defineCommand({
+	meta: {
+		name: "channels",
+		description: "Stats for a specific channel"
+	},
+	args: {
+		channel: {
+			type: "string",
+			required: true,
+			description: "Channel name"
+		},
+		period: {
+			type: "enum",
+			options: [
+				"1d",
+				"7d",
+				"30d",
+				"90d"
+			],
+			description: "Time window"
+		}
+	},
+	run: async ({ args }) => runEffect(Effect.gen(function* () {
+		const projectId = yield* readProjectId;
+		const api = yield* apiClient;
+		const periodFilter = args.period ? { period: args.period } : {};
+		const result = yield* api.analytics.channels({ urlParams: {
+			projectId,
+			channel: args.channel,
+			...periodFilter
+		} });
+		yield* printKeyValue([
+			["Channel", result.channel],
+			["Total Requests", String(result.totalRequests)],
+			["Unique Devices", String(result.uniqueDevices)],
+			["Manifest", String(result.responseTypeDistribution.manifest)],
+			["Directive", String(result.responseTypeDistribution.directive)],
+			["No Update", String(result.responseTypeDistribution.no_update)]
+		]);
+	}))
+});
 
 //#endregion
 //#region src/commands/analytics/platforms.ts
-const period$1 = Options.choice("period", [
-	"1d",
-	"7d",
-	"30d",
-	"90d"
-]).pipe(Options.optional);
-const platformsCommand = Command.make("platforms", { period: period$1 }, (opts) => Effect.gen(function* () {
-	const projectId = yield* readProjectId;
-	const api = yield* apiClient;
-	const periodFilter = Option.match(opts.period, {
-		onNone: () => ({}),
-		onSome: (periodValue) => ({ period: periodValue })
-	});
-	const result = yield* api.analytics.platforms({ urlParams: {
-		projectId,
-		...periodFilter
-	} });
-	if (result.platforms.length === 0) {
-		yield* Console.log("No platform data found.");
-		return;
-	}
-	yield* printTable([
-		"Platform",
-		"Requests",
-		"Devices"
-	], result.platforms.map((platform) => [
-		platform.platform,
-		String(platform.requests),
-		String(platform.devices)
-	]));
-}).pipe(handleAnalyticsCommandErrors));
+const platformsCommand = defineCommand({
+	meta: {
+		name: "platforms",
+		description: "Stats by platform"
+	},
+	args: { period: {
+		type: "enum",
+		options: [
+			"1d",
+			"7d",
+			"30d",
+			"90d"
+		],
+		description: "Time window"
+	} },
+	run: async ({ args }) => runEffect(Effect.gen(function* () {
+		const projectId = yield* readProjectId;
+		const api = yield* apiClient;
+		const periodFilter = args.period ? { period: args.period } : {};
+		const result = yield* api.analytics.platforms({ urlParams: {
+			projectId,
+			...periodFilter
+		} });
+		if (result.platforms.length === 0) {
+			yield* Console.log("No platform data found.");
+			return;
+		}
+		yield* printTable([
+			"Platform",
+			"Requests",
+			"Devices"
+		], result.platforms.map((platform) => [
+			platform.platform,
+			String(platform.requests),
+			String(platform.devices)
+		]));
+	}))
+});
 
 //#endregion
 //#region src/commands/analytics/updates.ts
-const updateId$4 = Options.text("update-id");
-const period = Options.choice("period", [
-	"1d",
-	"7d",
-	"30d",
-	"90d"
-]).pipe(Options.optional);
-const updatesCommand = Command.make("updates", {
-	updateId: updateId$4,
-	period
-}, (opts) => Effect.gen(function* () {
-	const projectId = yield* readProjectId;
-	const api = yield* apiClient;
-	const periodFilter = Option.match(opts.period, {
-		onNone: () => ({}),
-		onSome: (periodValue) => ({ period: periodValue })
-	});
-	const result = yield* api.analytics.updates({ urlParams: {
-		projectId,
-		updateId: opts.updateId,
-		...periodFilter
-	} });
-	yield* printKeyValue([
-		["Update ID", result.updateId],
-		["Total Requests", String(result.totalRequests)],
-		["Unique Devices", String(result.uniqueDevices)],
-		["Manifest", String(result.byResponseType.manifest)],
-		["Directive", String(result.byResponseType.directive)],
-		["No Update", String(result.byResponseType.no_update)]
-	]);
-}).pipe(handleAnalyticsCommandErrors));
+const updatesCommand = defineCommand({
+	meta: {
+		name: "updates",
+		description: "Stats for a specific update"
+	},
+	args: {
+		"update-id": {
+			type: "string",
+			required: true,
+			description: "Update ID"
+		},
+		period: {
+			type: "enum",
+			options: [
+				"1d",
+				"7d",
+				"30d",
+				"90d"
+			],
+			description: "Time window"
+		}
+	},
+	run: async ({ args }) => runEffect(Effect.gen(function* () {
+		const projectId = yield* readProjectId;
+		const api = yield* apiClient;
+		const periodFilter = args.period ? { period: args.period } : {};
+		const result = yield* api.analytics.updates({ urlParams: {
+			projectId,
+			updateId: args["update-id"],
+			...periodFilter
+		} });
+		yield* printKeyValue([
+			["Update ID", result.updateId],
+			["Total Requests", String(result.totalRequests)],
+			["Unique Devices", String(result.uniqueDevices)],
+			["Manifest", String(result.byResponseType.manifest)],
+			["Directive", String(result.byResponseType.directive)],
+			["No Update", String(result.byResponseType.no_update)]
+		]);
+	}))
+});
 
 //#endregion
 //#region src/commands/analytics/index.ts
-const analyticsCommand = Command.make("analytics", {}, () => Console.log("View deployment analytics. Run with --help for subcommands.")).pipe(Command.withSubcommands([
-	adoptionCommand,
-	updatesCommand,
-	channelsCommand$1,
-	platformsCommand
-]));
-
-//#endregion
-//#region src/commands/audit-logs/helpers.ts
-const handleAuditLogCommandErrors = makeCommandErrorHandler();
+const analyticsCommand = defineCommand({
+	meta: {
+		name: "analytics",
+		description: "View deployment analytics"
+	},
+	subCommands: {
+		adoption: adoptionCommand,
+		updates: updatesCommand,
+		channels: channelsCommand$1,
+		platforms: platformsCommand
+	}
+});
 
 //#endregion
 //#region src/commands/audit-logs/list.ts
-const action = Options.text("action").pipe(Options.optional);
-const resourceType = Options.text("resource-type").pipe(Options.optional);
-const actorId = Options.text("actor-id").pipe(Options.optional);
-const from = Options.text("from").pipe(Options.optional);
-const to = Options.text("to").pipe(Options.optional);
-const listCommand$7 = Command.make("list", {
-	action,
-	resourceType,
-	actorId,
-	from,
-	to
-}, (opts) => Effect.gen(function* () {
-	const api = yield* apiClient;
-	const filters = {
-		...Option.match(opts.action, {
-			onNone: () => ({}),
-			onSome: (value) => ({ action: value })
-		}),
-		...Option.match(opts.resourceType, {
-			onNone: () => ({}),
-			onSome: (value) => ({ resourceType: value })
-		}),
-		...Option.match(opts.actorId, {
-			onNone: () => ({}),
-			onSome: (value) => ({ actorId: value })
-		}),
-		...Option.match(opts.from, {
-			onNone: () => ({}),
-			onSome: (value) => ({ from: value })
-		}),
-		...Option.match(opts.to, {
-			onNone: () => ({}),
-			onSome: (value) => ({ to: value })
-		})
-	};
-	const { items } = yield* api["audit-logs"].list({ urlParams: {
-		...filters,
-		page: 1,
-		limit: 100
-	} });
-	if (items.length === 0) {
-		yield* Console.log("No audit log entries found.");
-		return;
-	}
-	yield* printTable([
-		"ID",
-		"Action",
-		"Resource Type",
-		"Resource ID",
-		"Actor",
-		"Source",
-		"Created"
-	], items.map((log) => [
-		log.id,
-		log.action,
-		log.resourceType,
-		log.resourceId ?? "-",
-		log.actorEmail,
-		log.source,
-		log.createdAt
-	]));
-}).pipe(handleAuditLogCommandErrors));
+const listCommand$7 = defineCommand({
+	meta: {
+		name: "list",
+		description: "List audit log entries"
+	},
+	args: {
+		action: {
+			type: "string",
+			description: "Filter by action"
+		},
+		"resource-type": {
+			type: "string",
+			description: "Filter by resource type"
+		},
+		"actor-id": {
+			type: "string",
+			description: "Filter by actor ID"
+		},
+		from: {
+			type: "string",
+			description: "ISO timestamp lower bound"
+		},
+		to: {
+			type: "string",
+			description: "ISO timestamp upper bound"
+		}
+	},
+	run: async ({ args }) => runEffect(Effect.gen(function* () {
+		const api = yield* apiClient;
+		const filters = {};
+		if (args.action) filters["action"] = args.action;
+		if (args["resource-type"]) filters["resourceType"] = args["resource-type"];
+		if (args["actor-id"]) filters["actorId"] = args["actor-id"];
+		if (args.from) filters["from"] = args.from;
+		if (args.to) filters["to"] = args.to;
+		const { items } = yield* api["audit-logs"].list({ urlParams: {
+			...filters,
+			page: 1,
+			limit: 100
+		} });
+		if (items.length === 0) {
+			yield* Console.log("No audit log entries found.");
+			return;
+		}
+		yield* printTable([
+			"ID",
+			"Action",
+			"Resource Type",
+			"Resource ID",
+			"Actor",
+			"Source",
+			"Created"
+		], items.map((log) => [
+			log.id,
+			log.action,
+			log.resourceType,
+			log.resourceId ?? "-",
+			log.actorEmail,
+			log.source,
+			log.createdAt
+		]));
+	}))
+});
 
 //#endregion
 //#region src/commands/audit-logs/index.ts
-const auditLogsCommand = Command.make("audit-logs", {}, () => Console.log("View audit logs. Run with --help for subcommands.")).pipe(Command.withSubcommands([listCommand$7]));
+const auditLogsCommand = defineCommand({
+	meta: {
+		name: "audit-logs",
+		description: "View audit logs"
+	},
+	subCommands: { list: listCommand$7 }
+});
 
 //#endregion
 //#region src/commands/branches.ts
-const handleErrors$1 = makeCommandErrorHandler();
-const idArg$1 = Args.text({ name: "id" });
-const nameOption$1 = Options.text("name");
-const listCommand$6 = Command.make("list", {}, () => Effect.gen(function* () {
-	const projectId = yield* readProjectId;
-	const { items } = yield* (yield* apiClient).branches.list({ urlParams: {
-		projectId,
-		page: 1,
-		limit: 1e3
-	} });
-	if (items.length === 0) {
-		yield* Console.log("No branches found.");
-		return;
+const listCommand$6 = defineCommand({
+	meta: {
+		name: "list",
+		description: "List branches for the linked project"
+	},
+	run: async () => runEffect(Effect.gen(function* () {
+		const projectId = yield* readProjectId;
+		const { items } = yield* (yield* apiClient).branches.list({ urlParams: {
+			projectId,
+			page: 1,
+			limit: 1e3
+		} });
+		if (items.length === 0) {
+			yield* Console.log("No branches found.");
+			return;
+		}
+		yield* printTable([
+			"ID",
+			"Name",
+			"Created"
+		], items.map((branch) => [
+			branch.id,
+			branch.name,
+			branch.createdAt
+		]));
+	}))
+});
+const createCommand$3 = defineCommand({
+	meta: {
+		name: "create",
+		description: "Create a branch"
+	},
+	args: { name: {
+		type: "string",
+		required: true,
+		description: "Branch name"
+	} },
+	run: async ({ args }) => runEffect(Effect.gen(function* () {
+		const projectId = yield* readProjectId;
+		const branch = yield* (yield* apiClient).branches.create({ payload: {
+			projectId,
+			name: args.name
+		} });
+		yield* printKeyValue([
+			["ID", branch.id],
+			["Name", branch.name],
+			["Created", branch.createdAt]
+		]);
+	}))
+});
+const renameCommand$1 = defineCommand({
+	meta: {
+		name: "rename",
+		description: "Rename a branch"
+	},
+	args: {
+		id: {
+			type: "positional",
+			required: true,
+			description: "Branch ID"
+		},
+		name: {
+			type: "string",
+			required: true,
+			description: "New branch name"
+		}
+	},
+	run: async ({ args }) => runEffect(Effect.gen(function* () {
+		const branch = yield* (yield* apiClient).branches.rename({
+			path: { id: args.id },
+			payload: { name: args.name }
+		});
+		yield* Console.log(`Branch renamed to "${branch.name}".`);
+	}))
+});
+const deleteCommand$6 = defineCommand({
+	meta: {
+		name: "delete",
+		description: "Delete a branch"
+	},
+	args: { id: {
+		type: "positional",
+		required: true,
+		description: "Branch ID"
+	} },
+	run: async ({ args }) => runEffect(Effect.gen(function* () {
+		yield* (yield* apiClient).branches.delete({ path: { id: args.id } });
+		yield* Console.log(`Branch ${args.id} deleted.`);
+	}))
+});
+const branchesCommand = defineCommand({
+	meta: {
+		name: "branches",
+		description: "Manage branches"
+	},
+	subCommands: {
+		list: listCommand$6,
+		create: createCommand$3,
+		rename: renameCommand$1,
+		delete: deleteCommand$6
 	}
-	yield* printTable([
-		"ID",
-		"Name",
-		"Created"
-	], items.map((branch) => [
-		branch.id,
-		branch.name,
-		branch.createdAt
-	]));
-}).pipe(handleErrors$1));
-const createCommand$3 = Command.make("create", { name: nameOption$1 }, (opts) => Effect.gen(function* () {
-	const projectId = yield* readProjectId;
-	const branch = yield* (yield* apiClient).branches.create({ payload: {
-		projectId,
-		name: opts.name
-	} });
-	yield* printKeyValue([
-		["ID", branch.id],
-		["Name", branch.name],
-		["Created", branch.createdAt]
-	]);
-}).pipe(handleErrors$1));
-const renameCommand$1 = Command.make("rename", {
-	id: idArg$1,
-	name: nameOption$1
-}, (opts) => Effect.gen(function* () {
-	const branch = yield* (yield* apiClient).branches.rename({
-		path: { id: opts.id },
-		payload: { name: opts.name }
-	});
-	yield* Console.log(`Branch renamed to "${branch.name}".`);
-}).pipe(handleErrors$1));
-const deleteCommand$6 = Command.make("delete", { id: idArg$1 }, (opts) => Effect.gen(function* () {
-	yield* (yield* apiClient).branches.delete({ path: { id: opts.id } });
-	yield* Console.log(`Branch ${opts.id} deleted.`);
-}).pipe(handleErrors$1));
-const branchesCommand = Command.make("branches", {}, () => Console.log("Manage branches. Run with --help for subcommands.")).pipe(Command.withSubcommands([
-	listCommand$6,
-	createCommand$3,
-	renameCommand$1,
-	deleteCommand$6
-]));
+});
 
 //#endregion
 //#region src/lib/android-signing-gradle.ts
@@ -2213,7 +2308,7 @@ const sha256Namespaced = (contentType, contentSha256Hex) => {
 
 //#endregion
 //#region src/commands/build/run-step.ts
-const runStep = (cmd, step) => Command$1.exitCode(cmd.pipe(Command$1.stdout("inherit"), Command$1.stderr("inherit"))).pipe(Effect.mapError((cause) => new BuildFailedError({
+const runStep = (cmd, step) => Command.exitCode(cmd.pipe(Command.stdout("inherit"), Command.stderr("inherit"))).pipe(Effect.mapError((cause) => new BuildFailedError({
 	step,
 	exitCode: 1,
 	message: `${step} failed to spawn: ${String(cause)}`
@@ -2227,7 +2322,7 @@ const runStep = (cmd, step) => Command$1.exitCode(cmd.pipe(Command$1.stdout("inh
 * stderr passes through to the terminal directly.
 */
 const runStepFormatted = (cmd, step, formatter) => Effect.gen(function* () {
-	const proc = yield* Command$1.start(cmd.pipe(Command$1.stdout("pipe"), Command$1.stderr("pipe"))).pipe(Effect.mapError((cause) => new BuildFailedError({
+	const proc = yield* Command.start(cmd.pipe(Command.stdout("pipe"), Command.stderr("pipe"))).pipe(Effect.mapError((cause) => new BuildFailedError({
 		step,
 		exitCode: 1,
 		message: `${step} failed to spawn: ${String(cause)}`
@@ -2235,14 +2330,14 @@ const runStepFormatted = (cmd, step, formatter) => Effect.gen(function* () {
 	const stdoutFiber = yield* proc.stdout.pipe(Stream.decodeText(), Stream.splitLines, Stream.runForEach((line) => {
 		const formatted = formatter.pipe(line);
 		return formatted.length > 0 ? Effect.sync(() => {
-			for (const output of formatted) process.stdout.write(`${output}\n`);
+			for (const output of formatted) process$1.stdout.write(`${output}\n`);
 		}) : Effect.void;
 	}), Effect.mapError((cause) => new BuildFailedError({
 		step,
 		exitCode: 1,
 		message: `${step} stdout stream error: ${String(cause)}`
 	})), Effect.fork);
-	const stderrFiber = yield* proc.stderr.pipe(Stream.decodeText(), Stream.splitLines, Stream.runForEach((line) => Effect.sync(() => process.stderr.write(`${line}\n`))), Effect.mapError((cause) => new BuildFailedError({
+	const stderrFiber = yield* proc.stderr.pipe(Stream.decodeText(), Stream.splitLines, Stream.runForEach((line) => Effect.sync(() => process$1.stderr.write(`${line}\n`))), Effect.mapError((cause) => new BuildFailedError({
 		step,
 		exitCode: 1,
 		message: `${step} stderr stream error: ${String(cause)}`
@@ -2255,7 +2350,7 @@ const runStepFormatted = (cmd, step, formatter) => Effect.gen(function* () {
 	})));
 	if (code !== 0) {
 		const summary = formatter.getBuildSummary();
-		if (summary) process.stderr.write(`${summary}\n`);
+		if (summary) process$1.stderr.write(`${summary}\n`);
 		return yield* new BuildFailedError({
 			step,
 			exitCode: code,
@@ -2293,7 +2388,7 @@ const runAndroidBuild = (input) => Effect.gen(function* () {
 		applicationIdentifier,
 		tempDir
 	});
-	yield* runStep(Command$1.make("bunx", "expo", "prebuild", "--platform", "android", "--clean").pipe(Command$1.workingDirectory(projectRoot), Command$1.env(commandEnv)), "expo prebuild android");
+	yield* runStep(Command.make("bunx", "expo", "prebuild", "--platform", "android", "--clean").pipe(Command.workingDirectory(projectRoot), Command.env(commandEnv)), "expo prebuild android");
 	const fs = yield* FileSystem.FileSystem;
 	const signingGradlePath = path.join(tempDir, "signing.gradle");
 	yield* fs.writeFileString(signingGradlePath, renderSigningGradle({
@@ -2303,7 +2398,7 @@ const runAndroidBuild = (input) => Effect.gen(function* () {
 		keyPassword: credentials.keyPassword
 	}));
 	const taskName = gradleTaskName(format, flavor, buildType);
-	yield* runStep(Command$1.make("./gradlew", "--init-script", signingGradlePath, `:app:${taskName}`).pipe(Command$1.workingDirectory(androidDir), Command$1.env(commandEnv)), "gradlew");
+	yield* runStep(Command.make("./gradlew", "--init-script", signingGradlePath, `:app:${taskName}`).pipe(Command.workingDirectory(androidDir), Command.env(commandEnv)), "gradlew");
 	const artifactPath = yield* findAndroidArtifact({
 		projectRoot,
 		format,
@@ -2358,9 +2453,9 @@ const renderExportOptionsPlist = ({ method, teamId, bundleId, provisioningProfil
 
 //#endregion
 //#region src/lib/ios-keychain.ts
-const runOrFail = (cmd, step) => Command$1.string(cmd).pipe(Effect.mapError((cause) => new KeychainError({ message: `keychain ${step} failed: ${String(cause)}` })));
+const runOrFail = (cmd, step) => Command.string(cmd).pipe(Effect.mapError((cause) => new KeychainError({ message: `keychain ${step} failed: ${String(cause)}` })));
 const listCurrentKeychains = Effect.gen(function* () {
-	return (yield* runOrFail(Command$1.make("security", "list-keychains", "-d", "user"), "list-keychains")).split("\n").map((line) => line.trim().replace(/^"/, "").replace(/"$/, "")).filter((line) => line.length > 0);
+	return (yield* runOrFail(Command.make("security", "list-keychains", "-d", "user"), "list-keychains")).split("\n").map((line) => line.trim().replace(/^"/, "").replace(/"$/, "")).filter((line) => line.length > 0);
 });
 const parseSigningIdentity = (output) => {
 	const lines = output.split("\n");
@@ -2381,13 +2476,13 @@ const acquireKeychain = ({ tempDir, p12Path, p12Password }) => {
 	const keychainPassword = randomBytes(32).toString("hex");
 	return Effect.acquireRelease(Effect.gen(function* () {
 		const priorKeychains = yield* listCurrentKeychains;
-		yield* runOrFail(Command$1.make("security", "create-keychain", "-p", keychainPassword, keychainPath), "create-keychain");
-		yield* runOrFail(Command$1.make("security", "unlock-keychain", "-p", keychainPassword, keychainPath), "unlock-keychain");
-		yield* runOrFail(Command$1.make("security", "set-keychain-settings", "-t", "3600", "-l", keychainPath), "set-keychain-settings");
-		yield* runOrFail(Command$1.make("security", "import", p12Path, "-k", keychainPath, "-P", p12Password, "-T", "/usr/bin/codesign"), "import");
-		yield* runOrFail(Command$1.make("security", "set-key-partition-list", "-S", "apple-tool:,apple:,codesign:", "-s", "-k", keychainPassword, keychainPath), "set-key-partition-list");
-		yield* runOrFail(Command$1.make("security", "list-keychains", "-d", "user", "-s", keychainPath, ...priorKeychains), "list-keychains -s (add)");
-		const signingIdentity = parseSigningIdentity(yield* runOrFail(Command$1.make("security", "find-identity", "-v", "-p", "codesigning", keychainPath), "find-identity"));
+		yield* runOrFail(Command.make("security", "create-keychain", "-p", keychainPassword, keychainPath), "create-keychain");
+		yield* runOrFail(Command.make("security", "unlock-keychain", "-p", keychainPassword, keychainPath), "unlock-keychain");
+		yield* runOrFail(Command.make("security", "set-keychain-settings", "-t", "3600", "-l", keychainPath), "set-keychain-settings");
+		yield* runOrFail(Command.make("security", "import", p12Path, "-k", keychainPath, "-P", p12Password, "-T", "/usr/bin/codesign"), "import");
+		yield* runOrFail(Command.make("security", "set-key-partition-list", "-S", "apple-tool:,apple:,codesign:", "-s", "-k", keychainPassword, keychainPath), "set-key-partition-list");
+		yield* runOrFail(Command.make("security", "list-keychains", "-d", "user", "-s", keychainPath, ...priorKeychains), "list-keychains -s (add)");
+		const signingIdentity = parseSigningIdentity(yield* runOrFail(Command.make("security", "find-identity", "-v", "-p", "codesigning", keychainPath), "find-identity"));
 		if (!signingIdentity) return yield* new KeychainError({ message: "No code signing identity found after importing .p12 into ephemeral keychain." });
 		return {
 			handle: {
@@ -2398,8 +2493,8 @@ const acquireKeychain = ({ tempDir, p12Path, p12Password }) => {
 			priorKeychains
 		};
 	}), ({ priorKeychains }) => Effect.gen(function* () {
-		yield* Command$1.string(Command$1.make("security", "list-keychains", "-d", "user", "-s", ...priorKeychains)).pipe(Effect.catchAll(() => Effect.void));
-		yield* Command$1.string(Command$1.make("security", "delete-keychain", keychainPath)).pipe(Effect.catchAll(() => Effect.void));
+		yield* Command.string(Command.make("security", "list-keychains", "-d", "user", "-s", ...priorKeychains)).pipe(Effect.catchAll(() => Effect.void));
+		yield* Command.string(Command.make("security", "delete-keychain", keychainPath)).pipe(Effect.catchAll(() => Effect.void));
 	})).pipe(Effect.map(({ handle }) => handle));
 };
 
@@ -2464,7 +2559,7 @@ const userProvisioningProfilesDir = () => path.join(os.homedir(), "Library", "Mo
 */
 const installProvisioningProfile = ({ profilePath }) => Effect.acquireRelease(Effect.gen(function* () {
 	const fs = yield* FileSystem.FileSystem;
-	const info = yield* extractProvisioningInfo(yield* Command$1.string(Command$1.make("security", "cms", "-D", "-i", profilePath)).pipe(Effect.mapError((cause) => new ProvisioningError({ message: `security cms -D failed for ${profilePath}: ${String(cause)}` }))));
+	const info = yield* extractProvisioningInfo(yield* Command.string(Command.make("security", "cms", "-D", "-i", profilePath)).pipe(Effect.mapError((cause) => new ProvisioningError({ message: `security cms -D failed for ${profilePath}: ${String(cause)}` }))));
 	const targetDir = userProvisioningProfilesDir();
 	const installedPath = path.join(targetDir, `${info.uuid}.mobileprovision`);
 	yield* fs.makeDirectory(targetDir, { recursive: true }).pipe(Effect.catchAll((cause) => new ProvisioningError({ message: `Failed to create provisioning profiles dir: ${String(cause)}` })));
@@ -2534,7 +2629,7 @@ const checkBundleId = (appDir, expectedBundleId) => Effect.gen(function* () {
 const checkEmbeddedProfile = (appDir, expectedUuid, expectedTeamId) => Effect.gen(function* () {
 	const warnings = [];
 	const profilePath = path.join(appDir, "embedded.mobileprovision");
-	const parsed = parsePlistXml(yield* Command$1.string(Command$1.make("security", "cms", "-D", "-i", profilePath)));
+	const parsed = parsePlistXml(yield* Command.string(Command.make("security", "cms", "-D", "-i", profilePath)));
 	const actualUuid = parsed["UUID"];
 	if (typeof actualUuid === "string" && actualUuid !== expectedUuid) warnings.push(`Profile UUID mismatch: expected "${expectedUuid}", got "${actualUuid}"`);
 	const teamIdentifiers = parsed["TeamIdentifier"];
@@ -2585,8 +2680,8 @@ const runIosBuild = (input) => Effect.gen(function* () {
 		distribution,
 		tempDir
 	});
-	yield* runStep(Command$1.make("bunx", "expo", "prebuild", "--platform", "ios", "--clean").pipe(Command$1.workingDirectory(projectRoot), Command$1.env(commandEnv)), "expo prebuild ios");
-	yield* runStep(Command$1.make("pod", "install").pipe(Command$1.workingDirectory(iosDir), Command$1.env(commandEnv)), "pod install");
+	yield* runStep(Command.make("bunx", "expo", "prebuild", "--platform", "ios", "--clean").pipe(Command.workingDirectory(projectRoot), Command.env(commandEnv)), "expo prebuild ios");
+	yield* runStep(Command.make("pod", "install").pipe(Command.workingDirectory(iosDir), Command.env(commandEnv)), "pod install");
 	const keychain = yield* acquireKeychain({
 		tempDir,
 		p12Path: credentials.p12Path,
@@ -2597,7 +2692,7 @@ const runIosBuild = (input) => Effect.gen(function* () {
 	const scheme = iosProfile.scheme ?? workspaceFilename.replace(/\.xcworkspace$/, "");
 	const configuration = iosProfile.buildConfiguration ?? "Release";
 	const archivePath = path.join(tempDir, "build.xcarchive");
-	const archiveCmd = Command$1.make("xcodebuild", "-workspace", workspaceFilename, "-scheme", scheme, "-configuration", configuration, "-archivePath", archivePath, "-allowProvisioningUpdates", "archive", "CODE_SIGN_STYLE=Manual", `DEVELOPMENT_TEAM=${provisioning.teamId}`, `CODE_SIGN_IDENTITY=${keychain.signingIdentity}`, `PROVISIONING_PROFILE_SPECIFIER=${provisioning.name}`).pipe(Command$1.workingDirectory(iosDir), Command$1.env(commandEnv));
+	const archiveCmd = Command.make("xcodebuild", "-workspace", workspaceFilename, "-scheme", scheme, "-configuration", configuration, "-archivePath", archivePath, "-allowProvisioningUpdates", "archive", "CODE_SIGN_STYLE=Manual", `DEVELOPMENT_TEAM=${provisioning.teamId}`, `CODE_SIGN_IDENTITY=${keychain.signingIdentity}`, `PROVISIONING_PROFILE_SPECIFIER=${provisioning.name}`).pipe(Command.workingDirectory(iosDir), Command.env(commandEnv));
 	const formatter = input.rawOutput ? void 0 : createXcodebuildFormatter(projectRoot);
 	yield* formatter ? runStepFormatted(archiveCmd, "xcodebuild archive", formatter) : runStep(archiveCmd, "xcodebuild archive");
 	const fs = yield* FileSystem.FileSystem;
@@ -2609,7 +2704,7 @@ const runIosBuild = (input) => Effect.gen(function* () {
 		provisioningProfileName: provisioning.name
 	}));
 	const exportPath = path.join(tempDir, "export");
-	const exportCmd = Command$1.make("xcodebuild", "-exportArchive", "-archivePath", archivePath, "-exportPath", exportPath, "-exportOptionsPlist", exportOptionsPath, "-allowProvisioningUpdates").pipe(Command$1.workingDirectory(iosDir), Command$1.env(commandEnv));
+	const exportCmd = Command.make("xcodebuild", "-exportArchive", "-archivePath", archivePath, "-exportPath", exportPath, "-exportOptionsPlist", exportOptionsPath, "-allowProvisioningUpdates").pipe(Command.workingDirectory(iosDir), Command.env(commandEnv));
 	yield* formatter ? runStepFormatted(exportCmd, "xcodebuild exportArchive", formatter) : runStep(exportCmd, "xcodebuild exportArchive");
 	yield* validateIosBuild({
 		archivePath,
@@ -2819,8 +2914,8 @@ const pullEnvVars = (api, { projectId, environment }) => api["env-vars"].export(
 const readExpoConfig = (projectRoot, envVars = {}) => Effect.acquireUseRelease(Effect.sync(() => {
 	const previous = {};
 	for (const [key, value] of Object.entries(envVars)) {
-		previous[key] = process.env[key];
-		process.env[key] = value;
+		previous[key] = process$1.env[key];
+		process$1.env[key] = value;
 	}
 	return previous;
 }), () => Effect.try({
@@ -2831,8 +2926,8 @@ const readExpoConfig = (projectRoot, envVars = {}) => Effect.acquireUseRelease(E
 	},
 	catch: () => void 0
 }).pipe(Effect.catchAll(() => Effect.succeed(void 0))), (previous) => Effect.sync(() => {
-	for (const [key, value] of Object.entries(previous)) if (value === void 0) delete process.env[key];
-	else process.env[key] = value;
+	for (const [key, value] of Object.entries(previous)) if (value === void 0) delete process$1.env[key];
+	else process$1.env[key] = value;
 }));
 const extractBuildNumber = (config, platform) => {
 	if (platform === "ios") return config.ios?.buildNumber;
@@ -2862,7 +2957,7 @@ const readAppMetaFromConfig = (config, platform) => Effect.gen(function* () {
 
 //#endregion
 //#region src/lib/git-context.ts
-const runString = (cmd, cwd) => Command$1.string(Command$1.workingDirectory(cmd, cwd));
+const runString = (cmd, cwd) => Command.string(Command.workingDirectory(cmd, cwd));
 /**
 * Best-effort git context extraction. If git is missing, the directory isn't
 * a repo, or any command fails, we silently return undefined fields so the
@@ -2871,10 +2966,10 @@ const runString = (cmd, cwd) => Command$1.string(Command$1.workingDirectory(cmd,
 */
 const readGitContext = (projectRoot) => Effect.gen(function* () {
 	const [commit, ref, commitMessage, status] = yield* Effect.all([
-		runString(Command$1.make("git", "rev-parse", "HEAD"), projectRoot).pipe(Effect.map((output) => output.trim()), Effect.catchAll(() => Effect.succeed(""))),
-		runString(Command$1.make("git", "symbolic-ref", "--short", "HEAD"), projectRoot).pipe(Effect.map((output) => output.trim()), Effect.catchAll(() => Effect.succeed(""))),
-		runString(Command$1.make("git", "log", "-1", "--format=%s"), projectRoot).pipe(Effect.map((output) => output.trim()), Effect.catchAll(() => Effect.succeed(""))),
-		runString(Command$1.make("git", "status", "--porcelain"), projectRoot).pipe(Effect.catchAll(() => Effect.succeed("")))
+		runString(Command.make("git", "rev-parse", "HEAD"), projectRoot).pipe(Effect.map((output) => output.trim()), Effect.catchAll(() => Effect.succeed(""))),
+		runString(Command.make("git", "symbolic-ref", "--short", "HEAD"), projectRoot).pipe(Effect.map((output) => output.trim()), Effect.catchAll(() => Effect.succeed(""))),
+		runString(Command.make("git", "log", "-1", "--format=%s"), projectRoot).pipe(Effect.map((output) => output.trim()), Effect.catchAll(() => Effect.succeed(""))),
+		runString(Command.make("git", "status", "--porcelain"), projectRoot).pipe(Effect.catchAll(() => Effect.succeed("")))
 	], { concurrency: "unbounded" });
 	return {
 		ref: ref.length > 0 ? ref : void 0,
@@ -2946,8 +3041,8 @@ const unquote = (input) => input.startsWith("\"") && input.endsWith("\"") ? inpu
 //#region src/lib/fingerprint.ts
 var FingerprintError = class extends Data.TaggedError("FingerprintError") {};
 const runFingerprintFull = (projectRoot) => Effect.gen(function* () {
-	const cmd = Command$1.make("bunx", "@expo/fingerprint", projectRoot).pipe(Command$1.workingDirectory(projectRoot));
-	const stdout = yield* Command$1.string(cmd).pipe(Effect.mapError((cause) => new FingerprintError({ message: `Failed to run "@expo/fingerprint": ${cause.message}` })));
+	const cmd = Command.make("bunx", "@expo/fingerprint", projectRoot).pipe(Command.workingDirectory(projectRoot));
+	const stdout = yield* Command.string(cmd).pipe(Effect.mapError((cause) => new FingerprintError({ message: `Failed to run "@expo/fingerprint": ${cause.message}` })));
 	const parsed = yield* Effect.try({
 		try: () => JSON.parse(stdout),
 		catch: () => new FingerprintError({ message: "Failed to parse @expo/fingerprint output as JSON." })
@@ -3124,162 +3219,260 @@ const runBuildWorkflow = (options) => Effect.scoped(Effect.gen(function* () {
 
 //#endregion
 //#region src/commands/build/index.ts
-const platform$7 = Options.choice("platform", ["ios", "android"]);
-const profile$1 = Options.text("profile").pipe(Options.withDefault("production"));
-const message$3 = Options.text("message").pipe(Options.optional);
-const noUpload = Options.boolean("no-upload");
-const rawOutput = Options.boolean("raw-output");
-const buildCommand = Command.make("build", {
-	platform: platform$7,
-	profile: profile$1,
-	message: message$3,
-	noUpload,
-	rawOutput
-}, (opts) => runBuildWorkflow({
-	platform: opts.platform,
-	profileName: opts.profile,
-	message: Option.getOrUndefined(opts.message),
-	noUpload: opts.noUpload,
-	rawOutput: opts.rawOutput
-}).pipe(Effect.catchTags({
-	AuthRequiredError: (err) => exitWith(3, err.message),
-	ProjectNotLinkedError: (err) => exitWith(4, err.message),
-	BuildProfileError: (err) => exitWith(2, err.message),
-	RuntimeVersionError: (err) => exitWith(2, err.message),
-	MissingCredentialsError: (err) => exitWith(5, `${err.message}\n${err.hint}`),
-	BuildFailedError: (err) => exitWith(6, err.message),
-	KeychainError: (err) => exitWith(6, err.message),
-	ProvisioningError: (err) => exitWith(6, err.message),
-	ArtifactNotFoundError: (err) => exitWith(6, err.message),
-	ReserveError: (err) => exitWith(7, err.message),
-	UploadFailedError: (err) => exitWith(7, err.message),
-	PresignedUrlExpiredError: (err) => exitWith(7, err.message),
-	CompleteError: (err) => exitWith(7, err.message),
-	EnvExportError: (err) => exitWith(7, err.message),
-	SystemError: (err) => exitWith(6, `Filesystem error: ${err.message}`),
-	BadArgument: (err) => exitWith(6, `Invalid argument: ${err.message}`)
-})));
-
-//#endregion
-//#region src/commands/builds/helpers.ts
-const handleBuildsCommandErrors = makeCommandErrorHandler();
+const BUILD_EXIT_EXTRAS = {
+	BuildProfileError: 2,
+	RuntimeVersionError: 2,
+	MissingCredentialsError: 5,
+	BuildFailedError: 6,
+	KeychainError: 6,
+	ProvisioningError: 6,
+	ArtifactNotFoundError: 6,
+	ReserveError: 7,
+	UploadFailedError: 7,
+	PresignedUrlExpiredError: 7,
+	CompleteError: 7,
+	EnvExportError: 7
+};
+const buildCommand = defineCommand({
+	meta: {
+		name: "build",
+		description: "Build the app locally and optionally upload"
+	},
+	args: {
+		platform: {
+			type: "enum",
+			options: ["ios", "android"],
+			required: true
+		},
+		profile: {
+			type: "string",
+			default: "production",
+			description: "Build profile name"
+		},
+		message: {
+			type: "string",
+			description: "Optional build message"
+		},
+		upload: {
+			type: "boolean",
+			default: true,
+			description: "Upload the built artifact to better-update",
+			negativeDescription: "Skip upload (use --no-upload)"
+		},
+		"raw-output": {
+			type: "boolean",
+			description: "Stream raw Gradle/Xcode output"
+		}
+	},
+	run: async ({ args }) => runEffect(runBuildWorkflow({
+		platform: args.platform,
+		profileName: args.profile,
+		message: args.message,
+		noUpload: !args.upload,
+		rawOutput: args["raw-output"] ?? false
+	}), BUILD_EXIT_EXTRAS)
+});
 
 //#endregion
 //#region src/commands/builds/compatibility-matrix.ts
-const compatibilityMatrixCommand = Command.make("compatibility-matrix", {}, () => Effect.gen(function* () {
-	const projectId = yield* readProjectId;
-	const result = yield* (yield* apiClient).builds.compatibilityMatrix({ urlParams: { projectId } });
-	if (result.rows.length === 0 && result.missingRuntimeVersions.length === 0) {
-		yield* Console.log("No compatibility data found.");
-		return;
-	}
-	if (result.rows.length > 0) {
-		yield* Console.log("Build-to-Channel Compatibility:");
-		yield* printTable([
-			"Build ID",
-			"Platform",
-			"Runtime Version",
-			"Channels"
-		], result.rows.map((row) => [
-			row.id,
-			row.platform,
-			row.runtimeVersion ?? "-",
-			row.channels.map((channel) => channel.channelName).join(", ") || "-"
-		]));
-	}
-	if (result.missingRuntimeVersions.length > 0) {
-		yield* Console.log("\nMissing Runtime Versions:");
-		yield* printTable([
-			"Channel",
-			"Platform",
-			"Runtime Version",
-			"Updates"
-		], result.missingRuntimeVersions.map((missing) => [
-			missing.channelName,
-			missing.platform,
-			missing.runtimeVersion,
-			String(missing.updateCount)
-		]));
-	}
-}).pipe(handleBuildsCommandErrors));
+const compatibilityMatrixCommand = defineCommand({
+	meta: {
+		name: "compatibility-matrix",
+		description: "Show build-to-channel compatibility and missing runtime versions"
+	},
+	run: async () => runEffect(Effect.gen(function* () {
+		const projectId = yield* readProjectId;
+		const result = yield* (yield* apiClient).builds.compatibilityMatrix({ urlParams: { projectId } });
+		if (result.rows.length === 0 && result.missingRuntimeVersions.length === 0) {
+			yield* Console.log("No compatibility data found.");
+			return;
+		}
+		if (result.rows.length > 0) {
+			yield* Console.log("Build-to-Channel Compatibility:");
+			yield* printTable([
+				"Build ID",
+				"Platform",
+				"Runtime Version",
+				"Channels"
+			], result.rows.map((row) => [
+				row.id,
+				row.platform,
+				row.runtimeVersion ?? "-",
+				row.channels.map((channel) => channel.channelName).join(", ") || "-"
+			]));
+		}
+		if (result.missingRuntimeVersions.length > 0) {
+			yield* Console.log("\nMissing Runtime Versions:");
+			yield* printTable([
+				"Channel",
+				"Platform",
+				"Runtime Version",
+				"Updates"
+			], result.missingRuntimeVersions.map((missing) => [
+				missing.channelName,
+				missing.platform,
+				missing.runtimeVersion,
+				String(missing.updateCount)
+			]));
+		}
+	}))
+});
 
 //#endregion
 //#region src/commands/builds/delete.ts
-const id$8 = Args.text({ name: "id" });
-const deleteCommand$5 = Command.make("delete", { id: id$8 }, (opts) => Effect.gen(function* () {
-	yield* (yield* apiClient).builds.delete({ path: { id: opts.id } });
-	yield* Console.log(`Build ${opts.id} deleted.`);
-}).pipe(handleBuildsCommandErrors));
+const deleteCommand$5 = defineCommand({
+	meta: {
+		name: "delete",
+		description: "Delete a build"
+	},
+	args: { id: {
+		type: "positional",
+		required: true,
+		description: "Build ID"
+	} },
+	run: async ({ args }) => runEffect(Effect.gen(function* () {
+		yield* (yield* apiClient).builds.delete({ path: { id: args.id } });
+		yield* Console.log(`Build ${args.id} deleted.`);
+	}))
+});
 
 //#endregion
 //#region src/commands/builds/get.ts
-const id$7 = Args.text({ name: "id" });
-const getCommand$2 = Command.make("get", { id: id$7 }, (opts) => Effect.gen(function* () {
-	const build = yield* (yield* apiClient).builds.get({ path: { id: opts.id } });
-	yield* printKeyValue([
-		["ID", build.id],
-		["Platform", build.platform],
-		["Profile", build.profile],
-		["Distribution", build.distribution],
-		["Version", build.appVersion ?? "-"],
-		["Build Number", build.buildNumber ?? "-"],
-		["Runtime Version", build.runtimeVersion ?? "-"],
-		["Bundle ID", build.bundleId ?? "-"],
-		["Git Ref", build.gitRef ?? "-"],
-		["Message", build.message ?? "-"],
-		["Artifact", build.artifact ? `${build.artifact.format} (${String(build.artifact.byteSize)} bytes)` : "none"],
-		["Created", build.createdAt]
-	]);
-}).pipe(handleBuildsCommandErrors));
+const getCommand$2 = defineCommand({
+	meta: {
+		name: "get",
+		description: "Show a build"
+	},
+	args: { id: {
+		type: "positional",
+		required: true,
+		description: "Build ID"
+	} },
+	run: async ({ args }) => runEffect(Effect.gen(function* () {
+		const build = yield* (yield* apiClient).builds.get({ path: { id: args.id } });
+		yield* printKeyValue([
+			["ID", build.id],
+			["Platform", build.platform],
+			["Profile", build.profile],
+			["Distribution", build.distribution],
+			["Version", build.appVersion ?? "-"],
+			["Build Number", build.buildNumber ?? "-"],
+			["Runtime Version", build.runtimeVersion ?? "-"],
+			["Bundle ID", build.bundleId ?? "-"],
+			["Git Ref", build.gitRef ?? "-"],
+			["Message", build.message ?? "-"],
+			["Artifact", build.artifact ? `${build.artifact.format} (${String(build.artifact.byteSize)} bytes)` : "none"],
+			["Created", build.createdAt]
+		]);
+	}))
+});
 
 //#endregion
 //#region src/commands/builds/install-link.ts
-const id$6 = Args.text({ name: "id" });
-const installLinkCommand = Command.make("install-link", { id: id$6 }, (opts) => Effect.gen(function* () {
-	const result = yield* (yield* apiClient).builds.getInstallLink({ path: { id: opts.id } });
-	yield* printKeyValue([
-		["Artifact URL", result.artifactUrl],
-		["Install URL", result.installUrl ?? "-"],
-		["Expires", String(result.expires)]
-	]);
-}).pipe(handleBuildsCommandErrors));
+const installLinkCommand = defineCommand({
+	meta: {
+		name: "install-link",
+		description: "Get install/artifact URLs for a build"
+	},
+	args: { id: {
+		type: "positional",
+		required: true,
+		description: "Build ID"
+	} },
+	run: async ({ args }) => runEffect(Effect.gen(function* () {
+		const result = yield* (yield* apiClient).builds.getInstallLink({ path: { id: args.id } });
+		yield* printKeyValue([
+			["Artifact URL", result.artifactUrl],
+			["Install URL", result.installUrl ?? "-"],
+			["Expires", String(result.expires)]
+		]);
+	}))
+});
+
+//#endregion
+//#region src/lib/cli-schemas.ts
+const RolloutPercentage = Schema.Number.pipe(Schema.int(), Schema.between(1, 100)).annotations({
+	message: () => "Rollout percentage must be between 1 and 100.",
+	identifier: "RolloutPercentage"
+});
+const KeyValuePair = Schema.Struct({
+	key: Schema.String,
+	value: Schema.String
+});
+const KeyValueFromString = Schema.transformOrFail(Schema.String, KeyValuePair, {
+	strict: true,
+	decode: (input, _options, ast) => {
+		const eqIndex = input.indexOf("=");
+		if (eqIndex <= 0) return ParseResult.fail(new ParseResult.Type(ast, input, "Invalid format. Use KEY=VALUE (e.g. API_KEY=abc123)"));
+		return ParseResult.succeed({
+			key: input.slice(0, eqIndex),
+			value: input.slice(eqIndex + 1)
+		});
+	},
+	encode: ({ key, value }) => ParseResult.succeed(`${key}=${value}`)
+});
+const parseRolloutPercentage = (raw, flag) => Effect.try({
+	try: () => Schema.decodeUnknownSync(RolloutPercentage)(Number(raw)),
+	catch: () => new InvalidArgumentError({ message: `--${flag} must be an integer between 1 and 100, got "${raw}".` })
+});
+const parseKeyValue = (raw) => Effect.try({
+	try: () => Schema.decodeUnknownSync(KeyValueFromString)(raw),
+	catch: () => new InvalidArgumentError({ message: "Invalid format. Use KEY=VALUE (e.g. API_KEY=abc123)" })
+});
+const parseLimit = (raw, defaultValue) => {
+	if (raw === void 0) return Effect.succeed(defaultValue);
+	const parsed = Number(raw);
+	if (!Number.isInteger(parsed) || parsed < 1) return Effect.fail(new InvalidArgumentError({ message: `--limit must be a positive integer, got "${raw}".` }));
+	return Effect.succeed(parsed);
+};
 
 //#endregion
 //#region src/commands/builds/list.ts
-const platform$6 = Options.choice("platform", ["ios", "android"]).pipe(Options.optional);
-const limit$1 = Options.integer("limit").pipe(Options.withDefault(10));
-const listCommand$5 = Command.make("list", {
-	platform: platform$6,
-	limit: limit$1
-}, (opts) => Effect.gen(function* () {
-	const projectId = yield* readProjectId;
-	const api = yield* apiClient;
-	const platformFilter = Option.match(opts.platform, {
-		onNone: () => ({}),
-		onSome: (platformValue) => ({ platform: platformValue })
-	});
-	const { items } = yield* api.builds.list({ urlParams: {
-		projectId,
-		...platformFilter,
-		page: 1,
-		limit: opts.limit
-	} });
-	yield* printTable([
-		"ID",
-		"Platform",
-		"Profile",
-		"Distribution",
-		"Version",
-		"Created"
-	], items.map((build) => [
-		build.id,
-		build.platform,
-		build.profile,
-		build.distribution,
-		build.appVersion ?? "-",
-		build.createdAt
-	]));
-}).pipe(handleBuildsCommandErrors));
+const listCommand$5 = defineCommand({
+	meta: {
+		name: "list",
+		description: "List builds for the linked project"
+	},
+	args: {
+		platform: {
+			type: "enum",
+			options: ["ios", "android"],
+			description: "Filter by platform"
+		},
+		limit: {
+			type: "string",
+			default: "10",
+			description: "Max rows (default 10)"
+		}
+	},
+	run: async ({ args }) => runEffect(Effect.gen(function* () {
+		const limit = yield* parseLimit(args.limit, 10);
+		const projectId = yield* readProjectId;
+		const api = yield* apiClient;
+		const platformFilter = args.platform ? { platform: args.platform } : {};
+		const { items } = yield* api.builds.list({ urlParams: {
+			projectId,
+			...platformFilter,
+			page: 1,
+			limit
+		} });
+		yield* printTable([
+			"ID",
+			"Platform",
+			"Profile",
+			"Distribution",
+			"Version",
+			"Created"
+		], items.map((build) => [
+			build.id,
+			build.platform,
+			build.profile,
+			build.distribution,
+			build.appVersion ?? "-",
+			build.createdAt
+		]));
+	}))
+});
 
 //#endregion
 //#region src/application/upload-workflow.ts
@@ -3369,44 +3562,67 @@ const runUploadWorkflow = (options) => Effect.gen(function* () {
 
 //#endregion
 //#region src/commands/builds/upload.ts
-const artifactPath = Args.text({ name: "artifact-path" });
-const platform$5 = Options.choice("platform", ["ios", "android"]);
-const profile = Options.text("profile").pipe(Options.withDefault("production"));
-const message$2 = Options.text("message").pipe(Options.optional);
-const uploadCommand$1 = Command.make("upload", {
-	artifactPath,
-	platform: platform$5,
-	profile,
-	message: message$2
-}, (opts) => runUploadWorkflow({
-	artifactPath: opts.artifactPath,
-	platform: opts.platform,
-	profileName: opts.profile,
-	message: Option.getOrUndefined(opts.message)
-}).pipe(Effect.catchTags({
-	AuthRequiredError: (err) => exitWith(3, err.message),
-	ProjectNotLinkedError: (err) => exitWith(4, err.message),
-	BuildProfileError: (err) => exitWith(2, err.message),
-	RuntimeVersionError: (err) => exitWith(2, err.message),
-	ArtifactNotFoundError: (err) => exitWith(6, err.message),
-	BuildFailedError: (err) => exitWith(6, err.message),
-	ReserveError: (err) => exitWith(7, err.message),
-	UploadFailedError: (err) => exitWith(7, err.message),
-	PresignedUrlExpiredError: (err) => exitWith(7, err.message),
-	CompleteError: (err) => exitWith(7, err.message),
-	EnvExportError: (err) => exitWith(7, err.message)
-})));
+const UPLOAD_EXIT_EXTRAS = {
+	BuildProfileError: 2,
+	RuntimeVersionError: 2,
+	ArtifactNotFoundError: 6,
+	BuildFailedError: 6,
+	ReserveError: 7,
+	UploadFailedError: 7,
+	PresignedUrlExpiredError: 7,
+	CompleteError: 7,
+	EnvExportError: 7
+};
+const uploadCommand$1 = defineCommand({
+	meta: {
+		name: "upload",
+		description: "Upload an existing artifact to better-update"
+	},
+	args: {
+		"artifact-path": {
+			type: "positional",
+			required: true,
+			description: "Path to artifact"
+		},
+		platform: {
+			type: "enum",
+			options: ["ios", "android"],
+			required: true
+		},
+		profile: {
+			type: "string",
+			default: "production",
+			description: "Build profile name"
+		},
+		message: {
+			type: "string",
+			description: "Optional build message"
+		}
+	},
+	run: async ({ args }) => runEffect(runUploadWorkflow({
+		artifactPath: args["artifact-path"],
+		platform: args.platform,
+		profileName: args.profile,
+		message: args.message
+	}), UPLOAD_EXIT_EXTRAS)
+});
 
 //#endregion
 //#region src/commands/builds/index.ts
-const buildsCommand = Command.make("builds", {}, () => Console.log("Manage builds. Run with --help for subcommands.")).pipe(Command.withSubcommands([
-	listCommand$5,
-	getCommand$2,
-	deleteCommand$5,
-	installLinkCommand,
-	compatibilityMatrixCommand,
-	uploadCommand$1
-]));
+const buildsCommand = defineCommand({
+	meta: {
+		name: "builds",
+		description: "Manage builds"
+	},
+	subCommands: {
+		list: listCommand$5,
+		get: getCommand$2,
+		delete: deleteCommand$5,
+		"install-link": installLinkCommand,
+		"compatibility-matrix": compatibilityMatrixCommand,
+		upload: uploadCommand$1
+	}
+});
 
 //#endregion
 //#region src/lib/resolve-named-resource.ts
@@ -3419,237 +3635,337 @@ const resolveNamedResourceId$2 = (params, makeError) => Effect.gen(function* ()
 //#endregion
 //#region src/commands/channels/helpers.ts
 var ChannelCommandError = class extends Data.TaggedError("ChannelCommandError") {};
-const handleChannelCommandErrors = makeCommandErrorHandler({ ChannelCommandError: 2 });
+const channelErrorExtras = { ChannelCommandError: 2 };
 const resolveNamedResourceId$1 = (params) => resolveNamedResourceId$2(params, (message) => new ChannelCommandError({ message }));
 
 //#endregion
 //#region src/commands/channels/create.ts
-const name$1 = Options.text("name");
-const branch$5 = Options.text("branch");
-const createCommand$2 = Command.make("create", {
-	name: name$1,
-	branch: branch$5
-}, (opts) => Effect.gen(function* () {
-	const projectId = yield* readProjectId;
-	const api = yield* apiClient;
-	const { items: branches } = yield* api.branches.list({ urlParams: {
-		projectId,
-		page: 1,
-		limit: 1e3
-	} });
-	const branchId = yield* resolveNamedResourceId$1({
-		items: branches,
-		kind: "Branch",
-		name: opts.branch
-	});
-	const channel = yield* api.channels.create({ payload: {
-		projectId,
-		name: opts.name,
-		branchId
-	} });
-	yield* printKeyValue([
-		["ID", channel.id],
-		["Name", channel.name],
-		["Branch", opts.branch],
-		["Created", channel.createdAt]
-	]);
-}).pipe(handleChannelCommandErrors));
+const createCommand$2 = defineCommand({
+	meta: {
+		name: "create",
+		description: "Create a channel"
+	},
+	args: {
+		name: {
+			type: "string",
+			required: true,
+			description: "Channel name"
+		},
+		branch: {
+			type: "string",
+			required: true,
+			description: "Initial branch name"
+		}
+	},
+	run: async ({ args }) => runEffect(Effect.gen(function* () {
+		const projectId = yield* readProjectId;
+		const api = yield* apiClient;
+		const { items: branches } = yield* api.branches.list({ urlParams: {
+			projectId,
+			page: 1,
+			limit: 1e3
+		} });
+		const branchId = yield* resolveNamedResourceId$1({
+			items: branches,
+			kind: "Branch",
+			name: args.branch
+		});
+		const channel = yield* api.channels.create({ payload: {
+			projectId,
+			name: args.name,
+			branchId
+		} });
+		yield* printKeyValue([
+			["ID", channel.id],
+			["Name", channel.name],
+			["Branch", args.branch],
+			["Created", channel.createdAt]
+		]);
+	}), channelErrorExtras)
+});
 
 //#endregion
 //#region src/commands/channels/delete.ts
-const id$5 = Args.text({ name: "id" });
-const deleteCommand$4 = Command.make("delete", { id: id$5 }, (opts) => Effect.gen(function* () {
-	yield* (yield* apiClient).channels.delete({ path: { id: opts.id } });
-	yield* Console.log(`Channel ${opts.id} deleted.`);
-}).pipe(handleChannelCommandErrors));
+const deleteCommand$4 = defineCommand({
+	meta: {
+		name: "delete",
+		description: "Delete a channel"
+	},
+	args: { id: {
+		type: "positional",
+		required: true,
+		description: "Channel ID"
+	} },
+	run: async ({ args }) => runEffect(Effect.gen(function* () {
+		yield* (yield* apiClient).channels.delete({ path: { id: args.id } });
+		yield* Console.log(`Channel ${args.id} deleted.`);
+	}), channelErrorExtras)
+});
 
 //#endregion
 //#region src/commands/channels/list.ts
-const listCommand$4 = Command.make("list", {}, () => Effect.gen(function* () {
-	const projectId = yield* readProjectId;
-	const api = yield* apiClient;
-	const [{ items }, { items: branches }] = yield* Effect.all([api.channels.list({ urlParams: {
-		projectId,
-		page: 1,
-		limit: 1e3
-	} }), api.branches.list({ urlParams: {
-		projectId,
-		page: 1,
-		limit: 1e3
-	} })]);
-	if (items.length === 0) {
-		yield* Console.log("No channels found.");
-		return;
-	}
-	const branchNames = new Map(branches.map((branch) => [branch.id, branch.name]));
-	yield* printTable([
-		"ID",
-		"Name",
-		"Branch",
-		"Paused",
-		"Rollout",
-		"Created"
-	], items.map((channel) => [
-		channel.id,
-		channel.name,
-		branchNames.get(channel.branchId) ?? channel.branchId,
-		channel.isPaused ? "yes" : "no",
-		channel.branchMappingJson === null ? "-" : "active",
-		channel.createdAt
-	]));
-}).pipe(handleChannelCommandErrors));
+const listCommand$4 = defineCommand({
+	meta: {
+		name: "list",
+		description: "List channels for the linked project"
+	},
+	run: async () => runEffect(Effect.gen(function* () {
+		const projectId = yield* readProjectId;
+		const api = yield* apiClient;
+		const [{ items }, { items: branches }] = yield* Effect.all([api.channels.list({ urlParams: {
+			projectId,
+			page: 1,
+			limit: 1e3
+		} }), api.branches.list({ urlParams: {
+			projectId,
+			page: 1,
+			limit: 1e3
+		} })]);
+		if (items.length === 0) {
+			yield* Console.log("No channels found.");
+			return;
+		}
+		const branchNames = new Map(branches.map((branch) => [branch.id, branch.name]));
+		yield* printTable([
+			"ID",
+			"Name",
+			"Branch",
+			"Paused",
+			"Rollout",
+			"Created"
+		], items.map((channel) => [
+			channel.id,
+			channel.name,
+			branchNames.get(channel.branchId) ?? channel.branchId,
+			channel.isPaused ? "yes" : "no",
+			channel.branchMappingJson === null ? "-" : "active",
+			channel.createdAt
+		]));
+	}), channelErrorExtras)
+});
 
 //#endregion
 //#region src/commands/channels/pause.ts
-const id$4 = Args.text({ name: "id" });
-const pauseCommand = Command.make("pause", { id: id$4 }, (opts) => Effect.gen(function* () {
-	const channel = yield* (yield* apiClient).channels.pause({ path: { id: opts.id } });
-	yield* Console.log(`Channel "${channel.name}" paused.`);
-}).pipe(handleChannelCommandErrors));
+const pauseCommand = defineCommand({
+	meta: {
+		name: "pause",
+		description: "Pause a channel"
+	},
+	args: { id: {
+		type: "positional",
+		required: true,
+		description: "Channel ID"
+	} },
+	run: async ({ args }) => runEffect(Effect.gen(function* () {
+		const channel = yield* (yield* apiClient).channels.pause({ path: { id: args.id } });
+		yield* Console.log(`Channel "${channel.name}" paused.`);
+	}), channelErrorExtras)
+});
 
 //#endregion
 //#region src/commands/channels/resume.ts
-const id$3 = Args.text({ name: "id" });
-const resumeCommand = Command.make("resume", { id: id$3 }, (opts) => Effect.gen(function* () {
-	const channel = yield* (yield* apiClient).channels.resume({ path: { id: opts.id } });
-	yield* Console.log(`Channel "${channel.name}" resumed.`);
-}).pipe(handleChannelCommandErrors));
+const resumeCommand = defineCommand({
+	meta: {
+		name: "resume",
+		description: "Resume a paused channel"
+	},
+	args: { id: {
+		type: "positional",
+		required: true,
+		description: "Channel ID"
+	} },
+	run: async ({ args }) => runEffect(Effect.gen(function* () {
+		const channel = yield* (yield* apiClient).channels.resume({ path: { id: args.id } });
+		yield* Console.log(`Channel "${channel.name}" resumed.`);
+	}), channelErrorExtras)
+});
 
 //#endregion
 //#region src/commands/channels/rollout/complete.ts
-const channelId$3 = Args.text({ name: "channelId" });
-const completeCommand$1 = Command.make("complete", { channelId: channelId$3 }, (opts) => Effect.gen(function* () {
-	const channel = yield* (yield* apiClient).channels.completeBranchRollout({ path: { id: opts.channelId } });
-	yield* Console.log(`Completed rollout on channel "${channel.name}".`);
-}).pipe(handleChannelCommandErrors));
-
-//#endregion
-//#region src/lib/cli-schemas.ts
-const RolloutPercentage = Schema.Number.pipe(Schema.int(), Schema.between(1, 100)).annotations({
-	message: () => "Rollout percentage must be between 1 and 100.",
-	identifier: "RolloutPercentage"
-});
-const rolloutPercentageOption = (name) => Options.integer(name).pipe(Options.withSchema(RolloutPercentage));
-const KeyValuePair = Schema.Struct({
-	key: Schema.String,
-	value: Schema.String
-});
-const KeyValueFromString = Schema.transformOrFail(Schema.String, KeyValuePair, {
-	strict: true,
-	decode: (input, _options, ast) => {
-		const eqIndex = input.indexOf("=");
-		if (eqIndex <= 0) return ParseResult.fail(new ParseResult.Type(ast, input, "Invalid format. Use KEY=VALUE (e.g. API_KEY=abc123)"));
-		return ParseResult.succeed({
-			key: input.slice(0, eqIndex),
-			value: input.slice(eqIndex + 1)
-		});
+const completeCommand$1 = defineCommand({
+	meta: {
+		name: "complete",
+		description: "Complete the active branch rollout"
 	},
-	encode: ({ key, value }) => ParseResult.succeed(`${key}=${value}`)
+	args: { channelId: {
+		type: "positional",
+		required: true,
+		description: "Channel ID"
+	} },
+	run: async ({ args }) => runEffect(Effect.gen(function* () {
+		const channel = yield* (yield* apiClient).channels.completeBranchRollout({ path: { id: args.channelId } });
+		yield* Console.log(`Completed rollout on channel "${channel.name}".`);
+	}), channelErrorExtras)
 });
-const keyValueArg = (name) => Args.text({ name }).pipe(Args.withSchema(KeyValueFromString));
 
 //#endregion
 //#region src/commands/channels/rollout/create.ts
-const channelId$2 = Args.text({ name: "channelId" });
-const branch$4 = Options.text("branch");
-const percentage$2 = rolloutPercentageOption("percentage");
-const createCommand$1 = Command.make("create", {
-	channelId: channelId$2,
-	branch: branch$4,
-	percentage: percentage$2
-}, (opts) => Effect.gen(function* () {
-	const projectId = yield* readProjectId;
-	const api = yield* apiClient;
-	const { items: branches } = yield* api.branches.list({ urlParams: {
-		projectId,
-		page: 1,
-		limit: 1e3
-	} });
-	const newBranchId = yield* resolveNamedResourceId$1({
-		items: branches,
-		kind: "Branch",
-		name: opts.branch
-	});
-	const channel = yield* api.channels.createBranchRollout({
-		path: { id: opts.channelId },
-		payload: {
-			newBranchId,
-			percentage: opts.percentage
+const createCommand$1 = defineCommand({
+	meta: {
+		name: "create",
+		description: "Start a branch rollout on a channel"
+	},
+	args: {
+		channelId: {
+			type: "positional",
+			required: true,
+			description: "Channel ID"
+		},
+		branch: {
+			type: "string",
+			required: true,
+			description: "Target branch name"
+		},
+		percentage: {
+			type: "string",
+			required: true,
+			description: "Initial rollout percentage (1-100)"
 		}
-	});
-	yield* Console.log(`Started rollout on channel "${channel.name}" to branch "${opts.branch}" at ${String(opts.percentage)}%.`);
-}).pipe(handleChannelCommandErrors));
+	},
+	run: async ({ args }) => runEffect(Effect.gen(function* () {
+		const percentage = yield* parseRolloutPercentage(args.percentage, "percentage");
+		const projectId = yield* readProjectId;
+		const api = yield* apiClient;
+		const { items: branches } = yield* api.branches.list({ urlParams: {
+			projectId,
+			page: 1,
+			limit: 1e3
+		} });
+		const newBranchId = yield* resolveNamedResourceId$1({
+			items: branches,
+			kind: "Branch",
+			name: args.branch
+		});
+		const channel = yield* api.channels.createBranchRollout({
+			path: { id: args.channelId },
+			payload: {
+				newBranchId,
+				percentage
+			}
+		});
+		yield* Console.log(`Started rollout on channel "${channel.name}" to branch "${args.branch}" at ${String(percentage)}%.`);
+	}), channelErrorExtras)
+});
 
 //#endregion
 //#region src/commands/channels/rollout/revert.ts
-const channelId$1 = Args.text({ name: "channelId" });
-const revertCommand$1 = Command.make("revert", { channelId: channelId$1 }, (opts) => Effect.gen(function* () {
-	const channel = yield* (yield* apiClient).channels.revertBranchRollout({ path: { id: opts.channelId } });
-	yield* Console.log(`Reverted rollout on channel "${channel.name}".`);
-}).pipe(handleChannelCommandErrors));
+const revertCommand$1 = defineCommand({
+	meta: {
+		name: "revert",
+		description: "Revert the active branch rollout"
+	},
+	args: { channelId: {
+		type: "positional",
+		required: true,
+		description: "Channel ID"
+	} },
+	run: async ({ args }) => runEffect(Effect.gen(function* () {
+		const channel = yield* (yield* apiClient).channels.revertBranchRollout({ path: { id: args.channelId } });
+		yield* Console.log(`Reverted rollout on channel "${channel.name}".`);
+	}), channelErrorExtras)
+});
 
 //#endregion
 //#region src/commands/channels/rollout/update.ts
-const channelId = Args.text({ name: "channelId" });
-const percentage$1 = rolloutPercentageOption("percentage");
-const updateCommand$2 = Command.make("update", {
-	channelId,
-	percentage: percentage$1
-}, (opts) => Effect.gen(function* () {
-	const channel = yield* (yield* apiClient).channels.updateBranchRollout({
-		path: { id: opts.channelId },
-		payload: { percentage: opts.percentage }
-	});
-	yield* Console.log(`Updated rollout on channel "${channel.name}" to ${String(opts.percentage)}%.`);
-}).pipe(handleChannelCommandErrors));
-
-//#endregion
-//#region src/commands/channels/rollout/index.ts
-const rolloutCommand$1 = Command.make("rollout", {}, () => Console.log("Manage channel branch rollouts. Run with --help for subcommands.")).pipe(Command.withSubcommands([
-	createCommand$1,
-	updateCommand$2,
-	completeCommand$1,
-	revertCommand$1
-]));
+const updateCommand$2 = defineCommand({
+	meta: {
+		name: "update",
+		description: "Update the rollout percentage on a channel"
+	},
+	args: {
+		channelId: {
+			type: "positional",
+			required: true,
+			description: "Channel ID"
+		},
+		percentage: {
+			type: "string",
+			required: true,
+			description: "New rollout percentage (1-100)"
+		}
+	},
+	run: async ({ args }) => runEffect(Effect.gen(function* () {
+		const percentage = yield* parseRolloutPercentage(args.percentage, "percentage");
+		const channel = yield* (yield* apiClient).channels.updateBranchRollout({
+			path: { id: args.channelId },
+			payload: { percentage }
+		});
+		yield* Console.log(`Updated rollout on channel "${channel.name}" to ${String(percentage)}%.`);
+	}), channelErrorExtras)
+});
+
+//#endregion
+//#region src/commands/channels/rollout/index.ts
+const rolloutCommand$1 = defineCommand({
+	meta: {
+		name: "rollout",
+		description: "Manage channel branch rollouts"
+	},
+	subCommands: {
+		create: createCommand$1,
+		update: updateCommand$2,
+		complete: completeCommand$1,
+		revert: revertCommand$1
+	}
+});
 
 //#endregion
 //#region src/commands/channels/update.ts
-const id$2 = Args.text({ name: "id" });
-const branch$3 = Options.text("branch");
-const updateCommand$1 = Command.make("update", {
-	id: id$2,
-	branch: branch$3
-}, (opts) => Effect.gen(function* () {
-	const projectId = yield* readProjectId;
-	const api = yield* apiClient;
-	const { items: branches } = yield* api.branches.list({ urlParams: {
-		projectId,
-		page: 1,
-		limit: 1e3
-	} });
-	const branchId = yield* resolveNamedResourceId$1({
-		items: branches,
-		kind: "Branch",
-		name: opts.branch
-	});
-	const channel = yield* api.channels.update({
-		path: { id: opts.id },
-		payload: { branchId }
-	});
-	yield* Console.log(`Channel "${channel.name}" relinked to branch "${opts.branch}".`);
-}).pipe(handleChannelCommandErrors));
+const updateCommand$1 = defineCommand({
+	meta: {
+		name: "update",
+		description: "Relink a channel to a different branch"
+	},
+	args: {
+		id: {
+			type: "positional",
+			required: true,
+			description: "Channel ID"
+		},
+		branch: {
+			type: "string",
+			required: true,
+			description: "Target branch name"
+		}
+	},
+	run: async ({ args }) => runEffect(Effect.gen(function* () {
+		const projectId = yield* readProjectId;
+		const api = yield* apiClient;
+		const { items: branches } = yield* api.branches.list({ urlParams: {
+			projectId,
+			page: 1,
+			limit: 1e3
+		} });
+		const branchId = yield* resolveNamedResourceId$1({
+			items: branches,
+			kind: "Branch",
+			name: args.branch
+		});
+		const channel = yield* api.channels.update({
+			path: { id: args.id },
+			payload: { branchId }
+		});
+		yield* Console.log(`Channel "${channel.name}" relinked to branch "${args.branch}".`);
+	}), channelErrorExtras)
+});
 
 //#endregion
 //#region src/commands/channels/index.ts
-const channelsCommand = Command.make("channels", {}, () => Console.log("Manage channels. Run with --help for subcommands.")).pipe(Command.withSubcommands([
-	listCommand$4,
-	createCommand$2,
-	updateCommand$1,
-	pauseCommand,
-	resumeCommand,
-	deleteCommand$4,
-	rolloutCommand$1
-]));
+const channelsCommand = defineCommand({
+	meta: {
+		name: "channels",
+		description: "Manage channels"
+	},
+	subCommands: {
+		list: listCommand$4,
+		create: createCommand$2,
+		update: updateCommand$1,
+		pause: pauseCommand,
+		resume: resumeCommand,
+		delete: deleteCommand$4,
+		rollout: rolloutCommand$1
+	}
+});
 
 //#endregion
 //#region src/lib/pkcs12.ts
@@ -3882,355 +4198,529 @@ const deleteCredential = (api, input) => {
 
 //#endregion
 //#region src/commands/credentials/delete.ts
-const id$1 = Args.text({ name: "id" });
-const platform$4 = Options.choice("platform", ["ios", "android"]);
-const type$1 = Options.choice("type", [
+const CREDENTIAL_TYPES$1 = [
 	"distribution-certificate",
 	"provisioning-profile",
 	"push-key",
 	"asc-api-key",
 	"keystore",
 	"google-service-account-key"
-]);
-const deleteCommand$3 = Command.make("delete", {
-	id: id$1,
-	platform: platform$4,
-	type: type$1
-}, (opts) => Effect.gen(function* () {
-	yield* deleteCredential(yield* apiClient, {
-		id: opts.id,
-		platform: opts.platform,
-		type: opts.type
-	});
-	yield* Console.log(`Credential ${opts.id} deleted.`);
-}));
+];
+const deleteCommand$3 = defineCommand({
+	meta: {
+		name: "delete",
+		description: "Delete a credential"
+	},
+	args: {
+		id: {
+			type: "positional",
+			required: true,
+			description: "Credential ID"
+		},
+		platform: {
+			type: "enum",
+			options: ["ios", "android"],
+			required: true
+		},
+		type: {
+			type: "enum",
+			options: [...CREDENTIAL_TYPES$1],
+			required: true
+		}
+	},
+	run: async ({ args }) => runEffect(Effect.gen(function* () {
+		yield* deleteCredential(yield* apiClient, {
+			id: args.id,
+			platform: args.platform,
+			type: args.type
+		});
+		yield* Console.log(`Credential ${args.id} deleted.`);
+	}))
+});
 
 //#endregion
 //#region src/commands/credentials/list.ts
-const platform$3 = Options.choice("platform", ["ios", "android"]).pipe(Options.optional);
-const listCommand$3 = Command.make("list", { platform: platform$3 }, (opts) => Effect.gen(function* () {
-	const filtered = filterCredentials(yield* listAllCredentials(yield* apiClient), Option.match(opts.platform, {
-		onNone: () => ({}),
-		onSome: (platformValue) => ({ platform: platformValue })
-	}));
-	if (filtered.length === 0) {
-		yield* Console.log("No credentials found.");
-		return;
-	}
-	yield* printTable([
-		"ID",
-		"Name",
-		"Platform",
-		"Type",
-		"Distribution"
-	], filtered.map((row) => [
-		row.id,
-		row.name,
-		row.platform,
-		row.type,
-		row.distribution ?? "-"
-	]));
-}));
+const listCommand$3 = defineCommand({
+	meta: {
+		name: "list",
+		description: "List credentials across platforms"
+	},
+	args: { platform: {
+		type: "enum",
+		options: ["ios", "android"],
+		description: "Filter by platform"
+	} },
+	run: async ({ args }) => runEffect(Effect.gen(function* () {
+		const filtered = filterCredentials(yield* listAllCredentials(yield* apiClient), args.platform ? { platform: args.platform } : {});
+		if (filtered.length === 0) {
+			yield* Console.log("No credentials found.");
+			return;
+		}
+		yield* printTable([
+			"ID",
+			"Name",
+			"Platform",
+			"Type",
+			"Distribution"
+		], filtered.map((row) => [
+			row.id,
+			row.name,
+			row.platform,
+			row.type,
+			row.distribution ?? "-"
+		]));
+	}))
+});
 
 //#endregion
 //#region src/commands/credentials/upload.ts
-const platform$2 = Options.choice("platform", ["ios", "android"]);
-const type = Options.choice("type", [
+const CREDENTIAL_TYPES = [
 	"distribution-certificate",
 	"provisioning-profile",
 	"push-key",
 	"asc-api-key",
 	"keystore",
 	"google-service-account-key"
-]);
-const name = Options.text("name");
-const file = Options.text("file");
-const password = Options.text("password").pipe(Options.optional);
-const keyAlias = Options.text("key-alias").pipe(Options.optional);
-const keyPassword = Options.text("key-password").pipe(Options.optional);
-const keyId = Options.text("key-id").pipe(Options.optional);
-const issuerId = Options.text("issuer-id").pipe(Options.optional);
-const appleTeamIdentifier = Options.text("apple-team-identifier").pipe(Options.optional);
-const uploadCommand = Command.make("upload", {
-	platform: platform$2,
-	type,
-	name,
-	file,
-	password,
-	keyAlias,
-	keyPassword,
-	keyId,
-	issuerId,
-	appleTeamIdentifier
-}, (opts) => Effect.gen(function* () {
-	const api = yield* apiClient;
-	const passwordOpt = Option.getOrUndefined(opts.password);
-	const keyAliasOpt = Option.getOrUndefined(opts.keyAlias);
-	const keyPasswordOpt = Option.getOrUndefined(opts.keyPassword);
-	const keyIdOpt = Option.getOrUndefined(opts.keyId);
-	const issuerIdOpt = Option.getOrUndefined(opts.issuerId);
-	const appleTeamIdentifierOpt = Option.getOrUndefined(opts.appleTeamIdentifier);
-	const credential = yield* uploadCredential(api, {
-		platform: opts.platform,
-		type: opts.type,
-		name: opts.name,
-		filePath: opts.file,
-		...passwordOpt === void 0 ? {} : { password: passwordOpt },
-		...keyAliasOpt === void 0 ? {} : { keyAlias: keyAliasOpt },
-		...keyPasswordOpt === void 0 ? {} : { keyPassword: keyPasswordOpt },
-		...keyIdOpt === void 0 ? {} : { keyId: keyIdOpt },
-		...issuerIdOpt === void 0 ? {} : { issuerId: issuerIdOpt },
-		...appleTeamIdentifierOpt === void 0 ? {} : { appleTeamIdentifier: appleTeamIdentifierOpt }
-	});
-	yield* Console.log("Credential uploaded successfully.");
-	yield* Console.log("");
-	yield* printKeyValue([
-		["ID", credential.id],
-		["Name", credential.name],
-		["Platform", credential.platform],
-		["Type", credential.type]
-	]);
-}));
+];
+const uploadCommand = defineCommand({
+	meta: {
+		name: "upload",
+		description: "Upload a credential"
+	},
+	args: {
+		platform: {
+			type: "enum",
+			options: ["ios", "android"],
+			required: true
+		},
+		type: {
+			type: "enum",
+			options: [...CREDENTIAL_TYPES],
+			required: true
+		},
+		name: {
+			type: "string",
+			required: true,
+			description: "Display name"
+		},
+		file: {
+			type: "string",
+			required: true,
+			description: "Path to credential file"
+		},
+		password: {
+			type: "string",
+			description: "File password (keystore/p12)"
+		},
+		"key-alias": {
+			type: "string",
+			description: "Keystore alias"
+		},
+		"key-password": {
+			type: "string",
+			description: "Keystore key password"
+		},
+		"key-id": {
+			type: "string",
+			description: "ASC API key ID"
+		},
+		"issuer-id": {
+			type: "string",
+			description: "ASC API issuer ID"
+		},
+		"apple-team-identifier": {
+			type: "string",
+			description: "Apple Team ID"
+		}
+	},
+	run: async ({ args }) => runEffect(Effect.gen(function* () {
+		const credential = yield* uploadCredential(yield* apiClient, {
+			platform: args.platform,
+			type: args.type,
+			name: args.name,
+			filePath: args.file,
+			...args.password === void 0 ? {} : { password: args.password },
+			...args["key-alias"] === void 0 ? {} : { keyAlias: args["key-alias"] },
+			...args["key-password"] === void 0 ? {} : { keyPassword: args["key-password"] },
+			...args["key-id"] === void 0 ? {} : { keyId: args["key-id"] },
+			...args["issuer-id"] === void 0 ? {} : { issuerId: args["issuer-id"] },
+			...args["apple-team-identifier"] === void 0 ? {} : { appleTeamIdentifier: args["apple-team-identifier"] }
+		});
+		yield* Console.log("Credential uploaded successfully.");
+		yield* Console.log("");
+		yield* printKeyValue([
+			["ID", credential.id],
+			["Name", credential.name],
+			["Platform", credential.platform],
+			["Type", credential.type]
+		]);
+	}))
+});
 
 //#endregion
 //#region src/commands/credentials/index.ts
-const credentialsCommand = Command.make("credentials", {}, () => Console.log("Manage credentials. Run with --help for subcommands.")).pipe(Command.withSubcommands([
-	listCommand$3,
-	uploadCommand,
-	deleteCommand$3
-]));
+const credentialsCommand = defineCommand({
+	meta: {
+		name: "credentials",
+		description: "Manage credentials"
+	},
+	subCommands: {
+		list: listCommand$3,
+		upload: uploadCommand,
+		delete: deleteCommand$3
+	}
+});
 
 //#endregion
 //#region src/commands/env/helpers.ts
 var EnvResourceNotFoundError = class extends Data.TaggedError("EnvResourceNotFoundError") {};
-const handleEnvCommandErrors = makeCommandErrorHandler({
+const envErrorExtras = {
 	EnvResourceNotFoundError: 1,
 	SystemError: 6,
 	BadArgument: 6
-});
+};
 
 //#endregion
 //#region src/commands/env/delete.ts
-const keyArg = Args.text({ name: "KEY" });
-const environmentOption$5 = Options.text("environment").pipe(Options.withDefault("production"));
-const deleteCommand$2 = Command.make("delete", {
-	key: keyArg,
-	environment: environmentOption$5
-}, ({ key, environment }) => Effect.gen(function* () {
-	const projectId = yield* readProjectId;
-	const api = yield* apiClient;
-	const match = (yield* api["env-vars"].list({ urlParams: {
-		projectId,
-		environment
-	} })).items.find((item) => item.key === key);
-	if (!match) return yield* new EnvResourceNotFoundError({ message: `Environment variable ${key} not found in ${environment}` });
-	yield* api["env-vars"].delete({ path: { id: match.id } });
-	yield* Console.log(`Deleted ${key} from ${environment}`);
-}).pipe(handleEnvCommandErrors));
+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"
+		}
+	},
+	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
+		} })).items.find((item) => item.key === args.key);
+		if (!match) return yield* new EnvResourceNotFoundError({ message: `Environment variable ${args.key} not found in ${args.environment}` });
+		yield* api["env-vars"].delete({ path: { id: match.id } });
+		yield* Console.log(`Deleted ${args.key} from ${args.environment}`);
+	}), envErrorExtras)
+});
 
 //#endregion
 //#region src/commands/env/export.ts
-const environmentOption$4 = Options.text("environment").pipe(Options.withDefault("production"));
-const exportCommand = Command.make("export", { environment: environmentOption$4 }, ({ environment }) => Effect.gen(function* () {
-	const projectId = yield* readProjectId;
-	const result = yield* (yield* apiClient)["env-vars"].export({ urlParams: {
-		projectId,
-		environment
-	} });
-	for (const item of result.items) {
-		const escaped = item.value.replaceAll("'", String.raw`'\''`);
-		yield* Console.log(`${item.key}='${escaped}'`);
-	}
-}).pipe(handleEnvCommandErrors));
+const exportCommand = defineCommand({
+	meta: {
+		name: "export",
+		description: "Print env vars in KEY='value' format"
+	},
+	args: { environment: {
+		type: "string",
+		default: "production",
+		description: "Target environment"
+	} },
+	run: async ({ args }) => runEffect(Effect.gen(function* () {
+		const projectId = yield* readProjectId;
+		const result = yield* (yield* apiClient)["env-vars"].export({ urlParams: {
+			projectId,
+			environment: args.environment
+		} });
+		for (const item of result.items) {
+			const escaped = item.value.replaceAll("'", String.raw`'\''`);
+			yield* Console.log(`${item.key}='${escaped}'`);
+		}
+	}), envErrorExtras)
+});
 
 //#endregion
 //#region src/commands/env/get.ts
-const id = Args.text({ name: "id" });
-const getCommand$1 = Command.make("get", { id }, (opts) => Effect.gen(function* () {
-	const envVar = yield* (yield* apiClient)["env-vars"].get({ path: { id: opts.id } });
-	yield* printKeyValue([
-		["ID", envVar.id],
-		["Key", envVar.key],
-		["Environment", envVar.environment],
-		["Visibility", envVar.visibility],
-		["Value", envVar.visibility === "plaintext" ? envVar.value ?? "" : "******"],
-		["Created", envVar.createdAt],
-		["Updated", envVar.updatedAt]
-	]);
-}).pipe(handleEnvCommandErrors));
+const getCommand$1 = defineCommand({
+	meta: {
+		name: "get",
+		description: "Show an environment variable"
+	},
+	args: { id: {
+		type: "positional",
+		required: true,
+		description: "Env var ID"
+	} },
+	run: async ({ args }) => runEffect(Effect.gen(function* () {
+		const envVar = yield* (yield* apiClient)["env-vars"].get({ path: { id: args.id } });
+		yield* printKeyValue([
+			["ID", envVar.id],
+			["Key", envVar.key],
+			["Environment", envVar.environment],
+			["Visibility", envVar.visibility],
+			["Value", envVar.visibility === "plaintext" ? envVar.value ?? "" : "******"],
+			["Created", envVar.createdAt],
+			["Updated", envVar.updatedAt]
+		]);
+	}), envErrorExtras)
+});
 
 //#endregion
 //#region src/commands/env/import.ts
-const fileArg = Args.text({ name: "file" });
-const environmentOption$3 = Options.text("environment").pipe(Options.withDefault("production"));
-const importCommand = Command.make("import", {
-	file: fileArg,
-	environment: environmentOption$3
-}, ({ file, environment }) => Effect.gen(function* () {
-	const content = yield* (yield* FileSystem.FileSystem).readFileString(file);
-	const projectId = yield* readProjectId;
-	const result = yield* (yield* apiClient)["env-vars"].bulkImport({ payload: {
-		projectId,
-		environment,
-		content,
-		visibility: "plaintext"
-	} });
-	yield* Console.log(`Imported: ${String(result.created)} created, ${String(result.updated)} updated, ${String(result.skipped)} skipped`);
-}).pipe(handleEnvCommandErrors));
+const importCommand = defineCommand({
+	meta: {
+		name: "import",
+		description: "Bulk-import env vars from a dotenv file"
+	},
+	args: {
+		file: {
+			type: "positional",
+			required: true,
+			description: "Path to .env file"
+		},
+		environment: {
+			type: "string",
+			default: "production",
+			description: "Target environment"
+		}
+	},
+	run: async ({ args }) => runEffect(Effect.gen(function* () {
+		const content = yield* (yield* FileSystem.FileSystem).readFileString(args.file);
+		const projectId = yield* readProjectId;
+		const result = yield* (yield* apiClient)["env-vars"].bulkImport({ payload: {
+			projectId,
+			environment: args.environment,
+			content,
+			visibility: "plaintext"
+		} });
+		yield* Console.log(`Imported: ${String(result.created)} created, ${String(result.updated)} updated, ${String(result.skipped)} skipped`);
+	}), envErrorExtras)
+});
 
 //#endregion
 //#region src/commands/env/list.ts
-const environmentOption$2 = Options.text("environment").pipe(Options.optional);
-const listCommand$2 = Command.make("list", { environment: environmentOption$2 }, ({ environment }) => Effect.gen(function* () {
-	const projectId = yield* readProjectId;
-	const api = yield* apiClient;
-	const envFilter = Option.match(environment, {
-		onNone: () => ({}),
-		onSome: (value) => ({ environment: value })
-	});
-	const result = yield* api["env-vars"].list({ urlParams: {
-		projectId,
-		...envFilter
-	} });
-	if (result.items.length === 0) {
-		yield* Console.log("No environment variables found.");
-		return;
-	}
-	yield* printTable([
-		"Key",
-		"Environment",
-		"Visibility",
-		"Value"
-	], result.items.map((item) => [
-		item.key,
-		item.environment,
-		item.visibility,
-		item.visibility === "plaintext" ? item.value ?? "" : "••••••"
-	]));
-}).pipe(handleEnvCommandErrors));
+const listCommand$2 = defineCommand({
+	meta: {
+		name: "list",
+		description: "List environment variables"
+	},
+	args: { environment: {
+		type: "string",
+		description: "Filter by environment"
+	} },
+	run: async ({ args }) => runEffect(Effect.gen(function* () {
+		const projectId = yield* readProjectId;
+		const api = yield* apiClient;
+		const envFilter = args.environment ? { environment: args.environment } : {};
+		const result = yield* api["env-vars"].list({ urlParams: {
+			projectId,
+			...envFilter
+		} });
+		if (result.items.length === 0) {
+			yield* Console.log("No environment variables found.");
+			return;
+		}
+		yield* printTable([
+			"Key",
+			"Environment",
+			"Visibility",
+			"Value"
+		], result.items.map((item) => [
+			item.key,
+			item.environment,
+			item.visibility,
+			item.visibility === "plaintext" ? item.value ?? "" : "••••••"
+		]));
+	}), envErrorExtras)
+});
 
 //#endregion
 //#region src/commands/env/pull.ts
-const environmentOption$1 = Options.text("environment").pipe(Options.withDefault("production"));
-const pullCommand = Command.make("pull", { environment: environmentOption$1 }, ({ environment }) => Effect.gen(function* () {
-	const projectId = yield* readProjectId;
-	const result = yield* (yield* apiClient)["env-vars"].export({ urlParams: {
-		projectId,
-		environment
-	} });
-	for (const item of result.items) {
-		const escaped = item.value.replaceAll("'", String.raw`'\''`);
-		yield* Console.log(`export ${item.key}='${escaped}'`);
-	}
-}).pipe(handleEnvCommandErrors));
+const pullCommand = defineCommand({
+	meta: {
+		name: "pull",
+		description: "Print env vars in `export KEY='value'` format"
+	},
+	args: { environment: {
+		type: "string",
+		default: "production",
+		description: "Target environment"
+	} },
+	run: async ({ args }) => runEffect(Effect.gen(function* () {
+		const projectId = yield* readProjectId;
+		const result = yield* (yield* apiClient)["env-vars"].export({ urlParams: {
+			projectId,
+			environment: args.environment
+		} });
+		for (const item of result.items) {
+			const escaped = item.value.replaceAll("'", String.raw`'\''`);
+			yield* Console.log(`export ${item.key}='${escaped}'`);
+		}
+	}), envErrorExtras)
+});
 
 //#endregion
 //#region src/commands/env/set.ts
-const keyValue = keyValueArg("KEY=VALUE");
-const environmentOption = Options.text("environment").pipe(Options.withDefault("production"));
-const visibilityOption = Options.choice("visibility", [
-	"plaintext",
-	"sensitive",
-	"secret"
-]).pipe(Options.withDefault("plaintext"));
-const setCommand$1 = Command.make("set", {
-	keyValue,
-	environment: environmentOption,
-	visibility: visibilityOption
-}, ({ keyValue: { key, value }, environment, visibility }) => Effect.gen(function* () {
-	const projectId = yield* readProjectId;
-	const api = yield* apiClient;
-	const match = (yield* api["env-vars"].list({ urlParams: {
-		projectId,
-		environment
-	} })).items.find((item) => item.key === key);
-	if (match) {
-		yield* api["env-vars"].update({
-			path: { id: match.id },
-			payload: {
+const setCommand$1 = defineCommand({
+	meta: {
+		name: "set",
+		description: "Create or update an environment variable"
+	},
+	args: {
+		keyValue: {
+			type: "positional",
+			required: true,
+			description: "KEY=VALUE pair (e.g. API_KEY=abc123)"
+		},
+		environment: {
+			type: "string",
+			default: "production",
+			description: "Target environment"
+		},
+		visibility: {
+			type: "enum",
+			options: [
+				"plaintext",
+				"sensitive",
+				"secret"
+			],
+			default: "plaintext",
+			description: "Value visibility"
+		}
+	},
+	run: async ({ args }) => runEffect(Effect.gen(function* () {
+		const { key, value } = yield* parseKeyValue(args.keyValue);
+		const { environment } = args;
+		const { visibility } = args;
+		const projectId = yield* readProjectId;
+		const api = yield* apiClient;
+		const match = (yield* api["env-vars"].list({ urlParams: {
+			projectId,
+			environment
+		} })).items.find((item) => item.key === key);
+		if (match) {
+			yield* api["env-vars"].update({
+				path: { id: match.id },
+				payload: {
+					value,
+					visibility
+				}
+			});
+			yield* Console.log(`Updated ${key} in ${environment}`);
+		} else {
+			yield* api["env-vars"].create({ payload: {
+				projectId,
+				environment,
+				key,
 				value,
 				visibility
-			}
-		});
-		yield* Console.log(`Updated ${key} in ${environment}`);
-	} else {
-		yield* api["env-vars"].create({ payload: {
-			projectId,
-			environment,
-			key,
-			value,
-			visibility
-		} });
-		yield* Console.log(`Created ${key} in ${environment}`);
-	}
-}).pipe(handleEnvCommandErrors));
+			} });
+			yield* Console.log(`Created ${key} in ${environment}`);
+		}
+	}), envErrorExtras)
+});
 
 //#endregion
 //#region src/commands/env/index.ts
-const envCommand = Command.make("env", {}, () => Console.log("Manage environment variables. Run with --help for subcommands.")).pipe(Command.withSubcommands([
-	listCommand$2,
-	getCommand$1,
-	setCommand$1,
-	deleteCommand$2,
-	importCommand,
-	exportCommand,
-	pullCommand
-]));
+const envCommand = defineCommand({
+	meta: {
+		name: "env",
+		description: "Manage environment variables"
+	},
+	subCommands: {
+		list: listCommand$2,
+		get: getCommand$1,
+		set: setCommand$1,
+		delete: deleteCommand$2,
+		import: importCommand,
+		export: exportCommand,
+		pull: pullCommand
+	}
+});
 
 //#endregion
 //#region src/commands/fingerprint/compare.ts
-const hash = Args.text({ name: "hash" });
-const compareCommand = Command.make("compare", { hash }, (opts) => Effect.gen(function* () {
-	const result = yield* runFingerprintFull(yield* (yield* CliRuntime).cwd);
-	if (result.hash === opts.hash) {
-		yield* Console.log("Fingerprints match.");
-		return;
-	}
-	yield* Console.log("Fingerprints differ.");
-	yield* Console.log(`  Local:    ${result.hash}`);
-	yield* Console.log(`  Provided: ${opts.hash}`);
-	return yield* exitWith(1, "Fingerprint mismatch");
-}).pipe(Effect.catchTag("FingerprintError", (error) => exitWith(2, error.message))));
+const compareCommand = defineCommand({
+	meta: {
+		name: "compare",
+		description: "Compare a fingerprint hash against the current project"
+	},
+	args: { hash: {
+		type: "positional",
+		required: true,
+		description: "Fingerprint hash to compare"
+	} },
+	run: async ({ args }) => runEffect(Effect.gen(function* () {
+		const result = yield* runFingerprintFull(yield* (yield* CliRuntime).cwd);
+		if (result.hash === args.hash) {
+			yield* Console.log("Fingerprints match.");
+			return;
+		}
+		yield* Console.log("Fingerprints differ.");
+		yield* Console.log(`  Local:    ${result.hash}`);
+		yield* Console.log(`  Provided: ${args.hash}`);
+		return yield* exitWith(1, "Fingerprint mismatch");
+	}), { FingerprintError: 2 })
+});
 
 //#endregion
 //#region src/commands/fingerprint/generate.ts
-const generateCommand = Command.make("generate", {}, () => Effect.gen(function* () {
-	const result = yield* runFingerprintFull(yield* (yield* CliRuntime).cwd);
-	yield* Console.log(result.hash);
-	if (result.sources.length > 0) yield* Console.log(`${result.sources.length} sources`);
-}).pipe(Effect.catchTag("FingerprintError", (error) => exitWith(2, error.message))));
+const generateCommand = defineCommand({
+	meta: {
+		name: "generate",
+		description: "Compute a fingerprint for the current project"
+	},
+	run: async () => runEffect(Effect.gen(function* () {
+		const result = yield* runFingerprintFull(yield* (yield* CliRuntime).cwd);
+		yield* Console.log(result.hash);
+		if (result.sources.length > 0) yield* Console.log(`${result.sources.length} sources`);
+	}), { FingerprintError: 2 })
+});
 
 //#endregion
 //#region src/commands/fingerprint/index.ts
-const fingerprintCommand = Command.make("fingerprint", {}, () => Console.log("Fingerprint utilities. Use --help for subcommands.")).pipe(Command.withSubcommands([generateCommand, compareCommand]));
+const fingerprintCommand = defineCommand({
+	meta: {
+		name: "fingerprint",
+		description: "Fingerprint utilities"
+	},
+	subCommands: {
+		generate: generateCommand,
+		compare: compareCommand
+	}
+});
 
 //#endregion
 //#region src/commands/init.ts
-const initCommand = Command.make("init", {}, () => Effect.gen(function* () {
-	const expo = asRecord((yield* readAppJson)["expo"]);
-	const name = asString$1(expo?.["name"]) ?? asString$1(expo?.["slug"]) ?? "untitled";
-	const slug = yield* readSlug;
-	yield* Console.log(`Linking project: ${name} (${slug})`);
-	const api = yield* apiClient;
-	const { items } = yield* api.projects.list({ urlParams: {
-		page: 1,
-		limit: 100
-	} });
-	const existing = items.find((project) => project.slug === slug);
-	if (existing) {
-		yield* Console.log(`Found existing project: ${existing.name} (${existing.id})`);
-		yield* writeProjectId(existing.id);
-	} else {
-		yield* Console.log("No existing project found. Creating new project...");
-		const project = yield* api.projects.create({ payload: {
-			name,
-			slug
+const initCommand = defineCommand({
+	meta: {
+		name: "init",
+		description: "Link the local Expo project to a better-update project"
+	},
+	run: async () => runEffect(Effect.gen(function* () {
+		const expo = asRecord((yield* readAppJson)["expo"]);
+		const name = asString$1(expo?.["name"]) ?? asString$1(expo?.["slug"]) ?? "untitled";
+		const slug = yield* readSlug;
+		yield* Console.log(`Linking project: ${name} (${slug})`);
+		const api = yield* apiClient;
+		const { items } = yield* api.projects.list({ urlParams: {
+			page: 1,
+			limit: 100
 		} });
-		yield* Console.log(`Created project: ${project.name} (${project.id})`);
-		yield* writeProjectId(project.id);
-	}
-	yield* Console.log("Project linked successfully. ID saved to app.json.");
-}));
+		const existing = items.find((project) => project.slug === slug);
+		if (existing) {
+			yield* Console.log(`Found existing project: ${existing.name} (${existing.id})`);
+			yield* writeProjectId(existing.id);
+		} else {
+			yield* Console.log("No existing project found. Creating new project...");
+			const project = yield* api.projects.create({ payload: {
+				name,
+				slug
+			} });
+			yield* Console.log(`Created project: ${project.name} (${project.id})`);
+			yield* writeProjectId(project.id);
+		}
+		yield* Console.log("Project linked successfully. ID saved to app.json.");
+	}))
+});
 
 //#endregion
 //#region src/lib/browser-login.ts
@@ -4375,17 +4865,27 @@ const createBrowserLoginServer = (options = {}) => {
 	};
 };
 
+//#endregion
+//#region src/lib/prompts.ts
+const promptPassword = async (message) => {
+	const value = await password({ message });
+	if (isCancel(value)) {
+		cancel("Operation cancelled.");
+		process.exit(130);
+	}
+	return value;
+};
+
 //#endregion
 //#region src/application/login.ts
-const tokenPrompt = Prompt.password({ message: "Paste your API key (from dashboard > API Keys):" });
 const buildOpenBrowserCommand = (platform, url) => {
-	if (platform === "darwin") return Command$1.make("open", url);
-	if (platform === "win32") return Command$1.make("cmd", "/c", "start", "", url);
-	return Command$1.make("xdg-open", url);
+	if (platform === "darwin") return Command.make("open", url);
+	if (platform === "win32") return Command.make("cmd", "/c", "start", "", url);
+	return Command.make("xdg-open", url);
 };
 const openBrowser = (url) => Effect.gen(function* () {
 	const command = buildOpenBrowserCommand((yield* CliRuntime).platform, url);
-	if (!(yield* Command$1.exitCode(command).pipe(Effect.map((code) => code === 0), Effect.catchAll(() => Effect.succeed(false))))) yield* Console.log(`Open this URL manually:\n${url}`);
+	if (!(yield* Command.exitCode(command).pipe(Effect.map((code) => code === 0), Effect.catchAll(() => Effect.succeed(false))))) yield* Console.log(`Open this URL manually:\n${url}`);
 });
 const browserLogin = Effect.scoped(Effect.gen(function* () {
 	const configStore = yield* ConfigStore;
@@ -4405,7 +4905,7 @@ const manualLogin = Effect.gen(function* () {
 	yield* Console.log("Log in to better-update with an existing API key");
 	yield* Console.log("Get your API key from the dashboard > API Keys page");
 	yield* Console.log("");
-	const token = Redacted.value(yield* tokenPrompt);
+	const token = yield* Effect.promise(async () => promptPassword("Paste your API key (from dashboard > API Keys):"));
 	yield* (yield* AuthStore).saveToken(token);
 	yield* Console.log("");
 	yield* Console.log("Logged in successfully. Token saved to ~/.better-update/auth.json");
@@ -4420,198 +4920,298 @@ const runLogin = (options) => Effect.gen(function* () {
 
 //#endregion
 //#region src/commands/login.ts
-const manualApiKey = Options.boolean("api-key");
-const loginFailed = (cause) => exitWith(1, Cause.pretty(cause));
-const loginCommand = Command.make("login", { manualApiKey }, (opts) => runLogin({ manualApiKey: opts.manualApiKey }).pipe(Effect.catchAllCause(loginFailed)));
+const loginCommand = defineCommand({
+	meta: {
+		name: "login",
+		description: "Log in to better-update"
+	},
+	args: { "api-key": {
+		type: "boolean",
+		description: "Paste an API key manually instead of opening the browser"
+	} },
+	run: async ({ args }) => runEffect(runLogin({ manualApiKey: args["api-key"] ?? false }))
+});
 
 //#endregion
 //#region src/commands/logout.ts
-const logoutCommand = Command.make("logout", {}, () => Effect.gen(function* () {
-	yield* (yield* AuthStore).clearToken;
-	yield* Console.log("Logged out. Auth token removed.");
-}));
+const logoutCommand = defineCommand({
+	meta: {
+		name: "logout",
+		description: "Remove the stored auth token"
+	},
+	run: async () => runEffect(Effect.gen(function* () {
+		yield* (yield* AuthStore).clearToken;
+		yield* Console.log("Logged out. Auth token removed.");
+	}))
+});
 
 //#endregion
 //#region src/commands/projects.ts
-const handleErrors = makeCommandErrorHandler();
-const idArg = Args.text({ name: "id" });
-const nameOption = Options.text("name");
-const slugOption = Options.text("slug");
-const listCommand$1 = Command.make("list", {}, () => Effect.gen(function* () {
-	const { items } = yield* (yield* apiClient).projects.list({ urlParams: {
-		page: 1,
-		limit: 1e3
-	} });
-	if (items.length === 0) {
-		yield* Console.log("No projects found.");
-		return;
+const listCommand$1 = defineCommand({
+	meta: {
+		name: "list",
+		description: "List all projects"
+	},
+	run: async () => runEffect(Effect.gen(function* () {
+		const { items } = yield* (yield* apiClient).projects.list({ urlParams: {
+			page: 1,
+			limit: 1e3
+		} });
+		if (items.length === 0) {
+			yield* Console.log("No projects found.");
+			return;
+		}
+		yield* printTable([
+			"ID",
+			"Name",
+			"Slug",
+			"Created"
+		], items.map((project) => [
+			project.id,
+			project.name,
+			project.slug,
+			project.createdAt
+		]));
+	}))
+});
+const createCommand = defineCommand({
+	meta: {
+		name: "create",
+		description: "Create a new project"
+	},
+	args: {
+		name: {
+			type: "string",
+			required: true,
+			description: "Display name"
+		},
+		slug: {
+			type: "string",
+			required: true,
+			description: "URL-safe slug"
+		}
+	},
+	run: async ({ args }) => runEffect(Effect.gen(function* () {
+		const project = yield* (yield* apiClient).projects.create({ payload: {
+			name: args.name,
+			slug: args.slug
+		} });
+		yield* printKeyValue([
+			["ID", project.id],
+			["Name", project.name],
+			["Slug", project.slug],
+			["Created", project.createdAt]
+		]);
+	}))
+});
+const getCommand = defineCommand({
+	meta: {
+		name: "get",
+		description: "Show a project"
+	},
+	args: { id: {
+		type: "positional",
+		required: true,
+		description: "Project ID"
+	} },
+	run: async ({ args }) => runEffect(Effect.gen(function* () {
+		const project = yield* (yield* apiClient).projects.get({ path: { id: args.id } });
+		yield* printKeyValue([
+			["ID", project.id],
+			["Name", project.name],
+			["Slug", project.slug],
+			["Created", project.createdAt]
+		]);
+	}))
+});
+const renameCommand = defineCommand({
+	meta: {
+		name: "rename",
+		description: "Rename a project"
+	},
+	args: {
+		id: {
+			type: "positional",
+			required: true,
+			description: "Project ID"
+		},
+		name: {
+			type: "string",
+			required: true,
+			description: "New display name"
+		}
+	},
+	run: async ({ args }) => runEffect(Effect.gen(function* () {
+		const project = yield* (yield* apiClient).projects.rename({
+			path: { id: args.id },
+			payload: { name: args.name }
+		});
+		yield* Console.log(`Project renamed to "${project.name}".`);
+	}))
+});
+const deleteCommand$1 = defineCommand({
+	meta: {
+		name: "delete",
+		description: "Delete a project"
+	},
+	args: { id: {
+		type: "positional",
+		required: true,
+		description: "Project ID"
+	} },
+	run: async ({ args }) => runEffect(Effect.gen(function* () {
+		yield* (yield* apiClient).projects.delete({ path: { id: args.id } });
+		yield* Console.log(`Project ${args.id} deleted.`);
+	}))
+});
+const projectsCommand = defineCommand({
+	meta: {
+		name: "projects",
+		description: "Manage projects"
+	},
+	subCommands: {
+		list: listCommand$1,
+		create: createCommand,
+		get: getCommand,
+		rename: renameCommand,
+		delete: deleteCommand$1
 	}
-	yield* printTable([
-		"ID",
-		"Name",
-		"Slug",
-		"Created"
-	], items.map((project) => [
-		project.id,
-		project.name,
-		project.slug,
-		project.createdAt
-	]));
-}).pipe(handleErrors));
-const createCommand = Command.make("create", {
-	name: nameOption,
-	slug: slugOption
-}, (opts) => Effect.gen(function* () {
-	const project = yield* (yield* apiClient).projects.create({ payload: {
-		name: opts.name,
-		slug: opts.slug
-	} });
-	yield* printKeyValue([
-		["ID", project.id],
-		["Name", project.name],
-		["Slug", project.slug],
-		["Created", project.createdAt]
-	]);
-}).pipe(handleErrors));
-const getCommand = Command.make("get", { id: idArg }, (opts) => Effect.gen(function* () {
-	const project = yield* (yield* apiClient).projects.get({ path: { id: opts.id } });
-	yield* printKeyValue([
-		["ID", project.id],
-		["Name", project.name],
-		["Slug", project.slug],
-		["Created", project.createdAt]
-	]);
-}).pipe(handleErrors));
-const renameCommand = Command.make("rename", {
-	id: idArg,
-	name: nameOption
-}, (opts) => Effect.gen(function* () {
-	const project = yield* (yield* apiClient).projects.rename({
-		path: { id: opts.id },
-		payload: { name: opts.name }
-	});
-	yield* Console.log(`Project renamed to "${project.name}".`);
-}).pipe(handleErrors));
-const deleteCommand$1 = Command.make("delete", { id: idArg }, (opts) => Effect.gen(function* () {
-	yield* (yield* apiClient).projects.delete({ path: { id: opts.id } });
-	yield* Console.log(`Project ${opts.id} deleted.`);
-}).pipe(handleErrors));
-const projectsCommand = Command.make("projects", {}, () => Console.log("Manage projects. Run with --help for subcommands.")).pipe(Command.withSubcommands([
-	listCommand$1,
-	createCommand,
-	getCommand,
-	renameCommand,
-	deleteCommand$1
-]));
+});
 
 //#endregion
 //#region src/commands/status.ts
-const statusCommand = Command.make("status", {}, () => Effect.gen(function* () {
-	const projectId = yield* readProjectId;
-	const api = yield* apiClient;
-	const { project, credentials, builds } = yield* Effect.all({
-		project: api.projects.get({ path: { id: projectId } }),
-		credentials: listAllCredentials(api),
-		builds: api.builds.list({ urlParams: { projectId } })
-	}, { concurrency: "unbounded" });
-	yield* Console.log("Project");
-	yield* Console.log("-------");
-	yield* printKeyValue([
-		["Name", project.name],
-		["ID", project.id],
-		["Slug", project.slug],
-		["Created", project.createdAt]
-	]);
-	yield* Console.log("");
-	yield* Console.log("Credentials");
-	yield* Console.log("-----------");
-	const iosCreds = credentials.filter((cred) => cred.platform === "ios").length;
-	const androidCreds = credentials.filter((cred) => cred.platform === "android").length;
-	yield* printKeyValue([
-		["iOS", String(iosCreds)],
-		["Android", String(androidCreds)],
-		["Total", String(credentials.length)]
-	]);
-	yield* Console.log("");
-	yield* Console.log("Builds");
-	yield* Console.log("------");
-	yield* printKeyValue([["Total", String(builds.total)]]);
-}));
+const statusCommand = defineCommand({
+	meta: {
+		name: "status",
+		description: "Show project status (credentials, builds)"
+	},
+	run: async () => runEffect(Effect.gen(function* () {
+		const projectId = yield* readProjectId;
+		const api = yield* apiClient;
+		const { project, credentials, builds } = yield* Effect.all({
+			project: api.projects.get({ path: { id: projectId } }),
+			credentials: listAllCredentials(api),
+			builds: api.builds.list({ urlParams: { projectId } })
+		}, { concurrency: "unbounded" });
+		yield* Console.log("Project");
+		yield* Console.log("-------");
+		yield* printKeyValue([
+			["Name", project.name],
+			["ID", project.id],
+			["Slug", project.slug],
+			["Created", project.createdAt]
+		]);
+		yield* Console.log("");
+		yield* Console.log("Credentials");
+		yield* Console.log("-----------");
+		const iosCreds = credentials.filter((cred) => cred.platform === "ios").length;
+		const androidCreds = credentials.filter((cred) => cred.platform === "android").length;
+		yield* printKeyValue([
+			["iOS", String(iosCreds)],
+			["Android", String(androidCreds)],
+			["Total", String(credentials.length)]
+		]);
+		yield* Console.log("");
+		yield* Console.log("Builds");
+		yield* Console.log("------");
+		yield* printKeyValue([["Total", String(builds.total)]]);
+	}))
+});
 
 //#endregion
 //#region src/commands/update/helpers.ts
 var UpdateCommandError = class extends Data.TaggedError("UpdateCommandError") {};
-const handleUpdateCommandErrors = makeCommandErrorHandler({
+const updateErrorExtras = {
 	UpdateCommandError: 2,
 	BuildProfileError: 2,
 	RuntimeVersionError: 2,
 	UpdateRollbackError: 2,
 	UpdatePromoteError: 2
-});
+};
 const resolveNamedResourceId = (params) => resolveNamedResourceId$2(params, (message) => new UpdateCommandError({ message }));
 
 //#endregion
 //#region src/commands/update/delete.ts
-const groupId = Args.text({ name: "groupId" });
-const deleteCommand = Command.make("delete", { groupId }, (opts) => Effect.gen(function* () {
-	const result = yield* (yield* apiClient).updates.deleteGroup({ path: { groupId: opts.groupId } });
-	yield* Console.log(`Deleted ${String(result.deleted)} update(s) from group ${opts.groupId}.`);
-}).pipe(handleUpdateCommandErrors));
+const deleteCommand = defineCommand({
+	meta: {
+		name: "delete",
+		description: "Delete an update group"
+	},
+	args: { groupId: {
+		type: "positional",
+		required: true,
+		description: "Update group ID"
+	} },
+	run: async ({ args }) => runEffect(Effect.gen(function* () {
+		const result = yield* (yield* apiClient).updates.deleteGroup({ path: { groupId: args.groupId } });
+		yield* Console.log(`Deleted ${String(result.deleted)} update(s) from group ${args.groupId}.`);
+	}), updateErrorExtras)
+});
 
 //#endregion
 //#region src/commands/update/list.ts
-const branch$2 = Options.text("branch").pipe(Options.optional);
-const limit = Options.integer("limit").pipe(Options.withDefault(20));
-const listCommand = Command.make("list", {
-	branch: branch$2,
-	limit
-}, (opts) => Effect.gen(function* () {
-	const projectId = yield* readProjectId;
-	const api = yield* apiClient;
-	const { items: branches } = yield* api.branches.list({ urlParams: {
-		projectId,
-		page: 1,
-		limit: 1e3
-	} });
-	const branchId = yield* Option.match(opts.branch, {
-		onNone: () => Effect.succeed(void 0),
-		onSome: (branchName) => resolveNamedResourceId({
+const listCommand = defineCommand({
+	meta: {
+		name: "list",
+		description: "List recent updates"
+	},
+	args: {
+		branch: {
+			type: "string",
+			description: "Filter by branch name"
+		},
+		limit: {
+			type: "string",
+			default: "20",
+			description: "Max rows (default 20)"
+		}
+	},
+	run: async ({ args }) => runEffect(Effect.gen(function* () {
+		const limit = yield* parseLimit(args.limit, 20);
+		const projectId = yield* readProjectId;
+		const api = yield* apiClient;
+		const { items: branches } = yield* api.branches.list({ urlParams: {
+			projectId,
+			page: 1,
+			limit: 1e3
+		} });
+		const branchId = args.branch ? yield* resolveNamedResourceId({
 			items: branches,
 			kind: "Branch",
-			name: branchName
-		})
-	});
-	const { items } = yield* api.updates.list({ urlParams: {
-		projectId,
-		...branchId === void 0 ? {} : { branchId },
-		page: 1,
-		limit: opts.limit
-	} });
-	if (items.length === 0) {
-		yield* Console.log("No updates found.");
-		return;
-	}
-	const branchNames = new Map(branches.map((item) => [item.id, item.name]));
-	yield* printTable([
-		"Update ID",
-		"Group",
-		"Branch",
-		"Platform",
-		"Runtime",
-		"Rollout",
-		"Rollback",
-		"Created"
-	], items.map((item) => [
-		item.id,
-		item.groupId,
-		branchNames.get(item.branchId) ?? item.branchId,
-		item.platform,
-		item.runtimeVersion,
-		`${String(item.rolloutPercentage)}%`,
-		item.isRollback ? "yes" : "no",
-		item.createdAt
-	]));
-}).pipe(handleUpdateCommandErrors));
+			name: args.branch
+		}) : void 0;
+		const { items } = yield* api.updates.list({ urlParams: {
+			projectId,
+			...branchId === void 0 ? {} : { branchId },
+			page: 1,
+			limit
+		} });
+		if (items.length === 0) {
+			yield* Console.log("No updates found.");
+			return;
+		}
+		const branchNames = new Map(branches.map((item) => [item.id, item.name]));
+		yield* printTable([
+			"Update ID",
+			"Group",
+			"Branch",
+			"Platform",
+			"Runtime",
+			"Rollout",
+			"Rollback",
+			"Created"
+		], items.map((item) => [
+			item.id,
+			item.groupId,
+			branchNames.get(item.branchId) ?? item.branchId,
+			item.platform,
+			item.runtimeVersion,
+			`${String(item.rolloutPercentage)}%`,
+			item.isRollback ? "yes" : "no",
+			item.createdAt
+		]));
+	}), updateErrorExtras)
+});
 
 //#endregion
 //#region src/lib/signed-payloads.ts
@@ -4704,27 +5304,37 @@ const runUpdatePromote = (options) => Effect.gen(function* () {
 
 //#endregion
 //#region src/commands/update/promote.ts
-const updateId$3 = Args.text({ name: "updateId" });
-const channel = Options.text("channel");
-const manifestBodyFile$1 = Options.text("manifest-body-file").pipe(Options.optional);
-const signatureFile$2 = Options.text("signature-file").pipe(Options.optional);
-const certificateChainFile$2 = Options.text("certificate-chain-file").pipe(Options.optional);
-const promoteCommand = Command.make("promote", {
-	updateId: updateId$3,
-	channel,
-	manifestBodyFile: manifestBodyFile$1,
-	signatureFile: signatureFile$2,
-	certificateChainFile: certificateChainFile$2
-}, (opts) => Effect.gen(function* () {
-	const result = yield* runUpdatePromote({
-		updateId: opts.updateId,
-		channel: opts.channel,
-		manifestBodyFile: Option.getOrUndefined(opts.manifestBodyFile),
-		signatureFile: Option.getOrUndefined(opts.signatureFile),
-		certificateChainFile: Option.getOrUndefined(opts.certificateChainFile)
-	});
-	yield* Console.log(`Promoted update ${result.sourceUpdateId} to channel "${result.channel}" as update ${result.updateId}.`);
-}).pipe(handleUpdateCommandErrors));
+const promoteCommand = defineCommand({
+	meta: {
+		name: "promote",
+		description: "Promote an existing update to a channel"
+	},
+	args: {
+		updateId: {
+			type: "positional",
+			required: true,
+			description: "Source update ID"
+		},
+		channel: {
+			type: "string",
+			required: true,
+			description: "Target channel name"
+		},
+		"manifest-body-file": { type: "string" },
+		"signature-file": { type: "string" },
+		"certificate-chain-file": { type: "string" }
+	},
+	run: async ({ args }) => runEffect(Effect.gen(function* () {
+		const result = yield* runUpdatePromote({
+			updateId: args.updateId,
+			channel: args.channel,
+			manifestBodyFile: args["manifest-body-file"],
+			signatureFile: args["signature-file"],
+			certificateChainFile: args["certificate-chain-file"]
+		});
+		yield* Console.log(`Promoted update ${result.sourceUpdateId} to channel "${result.channel}" as update ${result.updateId}.`);
+	}), updateErrorExtras)
+});
 
 //#endregion
 //#region src/lib/expo-export.ts
@@ -4754,8 +5364,8 @@ const inferContentType = (fileExt, isLaunch) => {
 		default: return "application/octet-stream";
 	}
 };
-const makeBunxCommand = (...args) => Command$1.make("bunx", ...args);
-const runCommand = (cmd, step) => Command$1.exitCode(cmd.pipe(Command$1.stdout("inherit"), Command$1.stderr("inherit"))).pipe(Effect.mapError((cause) => new BuildFailedError({
+const makeBunxCommand = (...args) => Command.make("bunx", ...args);
+const runCommand = (cmd, step) => Command.exitCode(cmd.pipe(Command.stdout("inherit"), Command.stderr("inherit"))).pipe(Effect.mapError((cause) => new BuildFailedError({
 	step,
 	exitCode: 1,
 	message: `${step} failed to spawn: ${String(cause)}`
@@ -4766,7 +5376,7 @@ const runCommand = (cmd, step) => Command$1.exitCode(cmd.pipe(Command$1.stdout("
 }))));
 const readExpoPublicConfig = ({ projectRoot, envVars }) => Effect.gen(function* () {
 	const commandEnv = yield* (yield* CliRuntime).commandEnvironment(envVars);
-	const stdout = yield* Command$1.string(makeBunxCommand("expo", "config", "--type", "public", "--json").pipe(Command$1.workingDirectory(projectRoot), Command$1.env(commandEnv))).pipe(Effect.mapError((cause) => new UpdatePublishError({ message: `Failed to read Expo public config: ${String(cause)}` })));
+	const stdout = yield* Command.string(makeBunxCommand("expo", "config", "--type", "public", "--json").pipe(Command.workingDirectory(projectRoot), Command.env(commandEnv))).pipe(Effect.mapError((cause) => new UpdatePublishError({ message: `Failed to read Expo public config: ${String(cause)}` })));
 	const config = asRecord(yield* Effect.try({
 		try: () => JSON.parse(stdout),
 		catch: () => new UpdatePublishError({ message: "Expo public config output was not valid JSON." })
@@ -4786,7 +5396,7 @@ const runExpoExport = ({ projectRoot, exportDir, platform, envVars, clear }) =>
 		"--dump-assetmap"
 	];
 	if (clear) args.push("--clear");
-	return yield* runCommand(makeBunxCommand(...args).pipe(Command$1.workingDirectory(projectRoot), Command$1.env(commandEnv)), `expo export ${platform}`);
+	return yield* runCommand(makeBunxCommand(...args).pipe(Command.workingDirectory(projectRoot), Command.env(commandEnv)), `expo export ${platform}`);
 });
 const readExpoExportAssets = ({ exportDir, platform }) => Effect.gen(function* () {
 	const fs = yield* FileSystem.FileSystem;
@@ -5000,86 +5610,101 @@ const runUpdatePublish = (options) => Effect.scoped(Effect.gen(function* () {
 
 //#endregion
 //#region src/commands/update/publish.ts
-const branch$1 = Options.text("branch").pipe(Options.optional);
-const platform$1 = Options.choice("platform", [
-	"ios",
-	"android",
-	"all"
-]).pipe(Options.withDefault("all"));
-const message$1 = Options.text("message").pipe(Options.optional);
-const environment = Options.text("environment").pipe(Options.withDefault("production"));
-const auto = Options.boolean("auto").pipe(Options.withDefault(false));
-const clear = Options.boolean("clear");
-const rolloutPercentage = rolloutPercentageOption("rollout-percentage").pipe(Options.optional);
-const manifestBodyFile = Options.text("manifest-body-file").pipe(Options.optional);
-const signatureFile$1 = Options.text("signature-file").pipe(Options.optional);
-const certificateChainFile$1 = Options.text("certificate-chain-file").pipe(Options.optional);
-const manifestBodyFileIos = Options.text("manifest-body-file-ios").pipe(Options.optional);
-const signatureFileIos = Options.text("signature-file-ios").pipe(Options.optional);
-const certificateChainFileIos = Options.text("certificate-chain-file-ios").pipe(Options.optional);
-const manifestBodyFileAndroid = Options.text("manifest-body-file-android").pipe(Options.optional);
-const signatureFileAndroid = Options.text("signature-file-android").pipe(Options.optional);
-const certificateChainFileAndroid = Options.text("certificate-chain-file-android").pipe(Options.optional);
-const publishCommand = Command.make("publish", {
-	branch: branch$1,
-	platform: platform$1,
-	message: message$1,
-	environment,
-	auto,
-	clear,
-	rolloutPercentage,
-	manifestBodyFile,
-	signatureFile: signatureFile$1,
-	certificateChainFile: certificateChainFile$1,
-	manifestBodyFileIos,
-	signatureFileIos,
-	certificateChainFileIos,
-	manifestBodyFileAndroid,
-	signatureFileAndroid,
-	certificateChainFileAndroid
-}, (opts) => Effect.gen(function* () {
-	const result = yield* runUpdatePublish({
-		branch: Option.getOrUndefined(opts.branch),
-		platform: opts.platform,
-		message: Option.getOrUndefined(opts.message),
-		auto: opts.auto,
-		environment: opts.environment,
-		clear: opts.clear,
-		rolloutPercentage: Option.getOrUndefined(opts.rolloutPercentage),
-		manifestBodyFile: Option.getOrUndefined(opts.manifestBodyFile),
-		signatureFile: Option.getOrUndefined(opts.signatureFile),
-		certificateChainFile: Option.getOrUndefined(opts.certificateChainFile),
-		manifestBodyFileIos: Option.getOrUndefined(opts.manifestBodyFileIos),
-		signatureFileIos: Option.getOrUndefined(opts.signatureFileIos),
-		certificateChainFileIos: Option.getOrUndefined(opts.certificateChainFileIos),
-		manifestBodyFileAndroid: Option.getOrUndefined(opts.manifestBodyFileAndroid),
-		signatureFileAndroid: Option.getOrUndefined(opts.signatureFileAndroid),
-		certificateChainFileAndroid: Option.getOrUndefined(opts.certificateChainFileAndroid)
-	});
-	yield* Console.log(`Published update group ${result.groupId} to branch "${result.branch}".`);
-	yield* Console.log("");
-	yield* printTable([
-		"Platform",
-		"Update ID",
-		"Runtime Version",
-		"Uploaded",
-		"Reused"
-	], result.results.map((entry) => [
-		entry.platform,
-		entry.updateId,
-		entry.runtimeVersion,
-		String(entry.uploadedAssets),
-		String(entry.deduplicatedAssets)
-	]));
-}).pipe(Effect.catchTags({
-	AuthRequiredError: (error) => exitWith(3, error.message),
-	ProjectNotLinkedError: (error) => exitWith(4, error.message),
-	BuildProfileError: (error) => exitWith(2, error.message),
-	RuntimeVersionError: (error) => exitWith(2, error.message),
-	EnvExportError: (error) => exitWith(7, error.message),
-	BuildFailedError: (error) => exitWith(6, error.message),
-	UpdatePublishError: (error) => exitWith(7, error.message)
-})));
+const PUBLISH_EXIT_EXTRAS = {
+	BuildProfileError: 2,
+	RuntimeVersionError: 2,
+	EnvExportError: 7,
+	BuildFailedError: 6,
+	UpdatePublishError: 7
+};
+const publishCommand = defineCommand({
+	meta: {
+		name: "publish",
+		description: "Publish a new OTA update group"
+	},
+	args: {
+		branch: {
+			type: "string",
+			description: "Target branch name"
+		},
+		platform: {
+			type: "enum",
+			options: [
+				"ios",
+				"android",
+				"all"
+			],
+			default: "all",
+			description: "Platform(s) to publish"
+		},
+		message: {
+			type: "string",
+			description: "Optional update message"
+		},
+		environment: {
+			type: "string",
+			default: "production",
+			description: "Env vars scope"
+		},
+		auto: {
+			type: "boolean",
+			description: "Skip prompts (for CI)"
+		},
+		clear: {
+			type: "boolean",
+			description: "Drop existing assets before upload"
+		},
+		"rollout-percentage": {
+			type: "string",
+			description: "Initial rollout percentage (1-100)"
+		},
+		"manifest-body-file": { type: "string" },
+		"signature-file": { type: "string" },
+		"certificate-chain-file": { type: "string" },
+		"manifest-body-file-ios": { type: "string" },
+		"signature-file-ios": { type: "string" },
+		"certificate-chain-file-ios": { type: "string" },
+		"manifest-body-file-android": { type: "string" },
+		"signature-file-android": { type: "string" },
+		"certificate-chain-file-android": { type: "string" }
+	},
+	run: async ({ args }) => runEffect(Effect.gen(function* () {
+		const rolloutPercentage = args["rollout-percentage"] ? yield* parseRolloutPercentage(args["rollout-percentage"], "rollout-percentage") : void 0;
+		const result = yield* runUpdatePublish({
+			branch: args.branch,
+			platform: args.platform,
+			message: args.message,
+			auto: args.auto ?? false,
+			environment: args.environment,
+			clear: args.clear ?? false,
+			rolloutPercentage,
+			manifestBodyFile: args["manifest-body-file"],
+			signatureFile: args["signature-file"],
+			certificateChainFile: args["certificate-chain-file"],
+			manifestBodyFileIos: args["manifest-body-file-ios"],
+			signatureFileIos: args["signature-file-ios"],
+			certificateChainFileIos: args["certificate-chain-file-ios"],
+			manifestBodyFileAndroid: args["manifest-body-file-android"],
+			signatureFileAndroid: args["signature-file-android"],
+			certificateChainFileAndroid: args["certificate-chain-file-android"]
+		});
+		yield* Console.log(`Published update group ${result.groupId} to branch "${result.branch}".`);
+		yield* Console.log("");
+		yield* printTable([
+			"Platform",
+			"Update ID",
+			"Runtime Version",
+			"Uploaded",
+			"Reused"
+		], result.results.map((entry) => [
+			entry.platform,
+			entry.updateId,
+			entry.runtimeVersion,
+			String(entry.uploadedAssets),
+			String(entry.deduplicatedAssets)
+		]));
+	}), PUBLISH_EXIT_EXTRAS)
+});
 
 //#endregion
 //#region ../../packages/expo-protocol/src/index.ts
@@ -5186,121 +5811,179 @@ const runUpdateRollback = (options) => Effect.gen(function* () {
 
 //#endregion
 //#region src/commands/update/rollback.ts
-const branch = Options.text("branch");
-const platform = Options.choice("platform", [
-	"ios",
-	"android",
-	"all"
-]).pipe(Options.withDefault("all"));
-const message = Options.text("message").pipe(Options.optional);
-const commitTime = Options.text("commit-time").pipe(Options.optional);
-const directiveBodyFile = Options.text("directive-body-file").pipe(Options.optional);
-const signatureFile = Options.text("signature-file").pipe(Options.optional);
-const certificateChainFile = Options.text("certificate-chain-file").pipe(Options.optional);
-const rollbackCommand = Command.make("rollback", {
-	branch,
-	platform,
-	message,
-	commitTime,
-	directiveBodyFile,
-	signatureFile,
-	certificateChainFile
-}, (opts) => Effect.gen(function* () {
-	const result = yield* runUpdateRollback({
-		branch: opts.branch,
-		platform: opts.platform,
-		message: Option.getOrUndefined(opts.message),
-		commitTime: Option.getOrUndefined(opts.commitTime),
-		directiveBodyFile: Option.getOrUndefined(opts.directiveBodyFile),
-		signatureFile: Option.getOrUndefined(opts.signatureFile),
-		certificateChainFile: Option.getOrUndefined(opts.certificateChainFile)
-	});
-	yield* Console.log(`Created rollback group ${result.groupId} on branch "${result.branch}" at ${result.commitTime}.`);
-	yield* Console.log("");
-	yield* printTable([
-		"Platform",
-		"Update ID",
-		"Runtime Version"
-	], result.results.map((entry) => [
-		entry.platform,
-		entry.updateId,
-		entry.runtimeVersion
-	]));
-}).pipe(handleUpdateCommandErrors));
+const rollbackCommand = defineCommand({
+	meta: {
+		name: "rollback",
+		description: "Roll back updates on a branch"
+	},
+	args: {
+		branch: {
+			type: "string",
+			required: true,
+			description: "Branch to roll back"
+		},
+		platform: {
+			type: "enum",
+			options: [
+				"ios",
+				"android",
+				"all"
+			],
+			default: "all",
+			description: "Platform(s) to roll back"
+		},
+		message: { type: "string" },
+		"commit-time": { type: "string" },
+		"directive-body-file": { type: "string" },
+		"signature-file": { type: "string" },
+		"certificate-chain-file": { type: "string" }
+	},
+	run: async ({ args }) => runEffect(Effect.gen(function* () {
+		const result = yield* runUpdateRollback({
+			branch: args.branch,
+			platform: args.platform,
+			message: args.message,
+			commitTime: args["commit-time"],
+			directiveBodyFile: args["directive-body-file"],
+			signatureFile: args["signature-file"],
+			certificateChainFile: args["certificate-chain-file"]
+		});
+		yield* Console.log(`Created rollback group ${result.groupId} on branch "${result.branch}" at ${result.commitTime}.`);
+		yield* Console.log("");
+		yield* printTable([
+			"Platform",
+			"Update ID",
+			"Runtime Version"
+		], result.results.map((entry) => [
+			entry.platform,
+			entry.updateId,
+			entry.runtimeVersion
+		]));
+	}), updateErrorExtras)
+});
 
 //#endregion
 //#region src/commands/update/rollout/complete.ts
-const updateId$2 = Args.text({ name: "updateId" });
-const completeCommand = Command.make("complete", { updateId: updateId$2 }, (opts) => Effect.gen(function* () {
-	const result = yield* (yield* apiClient).updates.completeRollout({ path: { id: opts.updateId } });
-	yield* Console.log(`Completed rollout for ${opts.updateId}. Current rollout is ${String(result.rolloutPercentage)}%.`);
-}).pipe(handleUpdateCommandErrors));
+const completeCommand = defineCommand({
+	meta: {
+		name: "complete",
+		description: "Complete the rollout for an update"
+	},
+	args: { updateId: {
+		type: "positional",
+		required: true,
+		description: "Update ID"
+	} },
+	run: async ({ args }) => runEffect(Effect.gen(function* () {
+		const result = yield* (yield* apiClient).updates.completeRollout({ path: { id: args.updateId } });
+		yield* Console.log(`Completed rollout for ${args.updateId}. Current rollout is ${String(result.rolloutPercentage)}%.`);
+	}), updateErrorExtras)
+});
 
 //#endregion
 //#region src/commands/update/rollout/revert.ts
-const updateId$1 = Args.text({ name: "updateId" });
-const revertCommand = Command.make("revert", { updateId: updateId$1 }, (opts) => Effect.gen(function* () {
-	const result = yield* (yield* apiClient).updates.revertRollout({ path: { id: opts.updateId } });
-	yield* Console.log(`Reverted rollout for ${opts.updateId}. Current rollout is ${String(result.rolloutPercentage)}%.`);
-}).pipe(handleUpdateCommandErrors));
+const revertCommand = defineCommand({
+	meta: {
+		name: "revert",
+		description: "Revert the rollout for an update"
+	},
+	args: { updateId: {
+		type: "positional",
+		required: true,
+		description: "Update ID"
+	} },
+	run: async ({ args }) => runEffect(Effect.gen(function* () {
+		const result = yield* (yield* apiClient).updates.revertRollout({ path: { id: args.updateId } });
+		yield* Console.log(`Reverted rollout for ${args.updateId}. Current rollout is ${String(result.rolloutPercentage)}%.`);
+	}), updateErrorExtras)
+});
 
 //#endregion
 //#region src/commands/update/rollout/set.ts
-const updateId = Args.text({ name: "updateId" });
-const percentage = rolloutPercentageOption("percentage");
-const setCommand = Command.make("set", {
-	updateId,
-	percentage
-}, (opts) => Effect.gen(function* () {
-	const result = yield* (yield* apiClient).updates.editRollout({
-		path: { id: opts.updateId },
-		payload: { percentage: opts.percentage }
-	});
-	yield* Console.log(`Updated rollout for ${opts.updateId} to ${String(result.rolloutPercentage)}%.`);
-}).pipe(handleUpdateCommandErrors));
+const setCommand = defineCommand({
+	meta: {
+		name: "set",
+		description: "Set the rollout percentage for an update"
+	},
+	args: {
+		updateId: {
+			type: "positional",
+			required: true,
+			description: "Update ID"
+		},
+		percentage: {
+			type: "string",
+			required: true,
+			description: "Rollout percentage (1-100)"
+		}
+	},
+	run: async ({ args }) => runEffect(Effect.gen(function* () {
+		const percentage = yield* parseRolloutPercentage(args.percentage, "percentage");
+		const result = yield* (yield* apiClient).updates.editRollout({
+			path: { id: args.updateId },
+			payload: { percentage }
+		});
+		yield* Console.log(`Updated rollout for ${args.updateId} to ${String(result.rolloutPercentage)}%.`);
+	}), updateErrorExtras)
+});
 
 //#endregion
 //#region src/commands/update/rollout/index.ts
-const rolloutCommand = Command.make("rollout", {}, () => Console.log("Manage per-update rollouts. Run with --help for subcommands.")).pipe(Command.withSubcommands([
-	setCommand,
-	completeCommand,
-	revertCommand
-]));
+const rolloutCommand = defineCommand({
+	meta: {
+		name: "rollout",
+		description: "Manage per-update rollouts"
+	},
+	subCommands: {
+		set: setCommand,
+		complete: completeCommand,
+		revert: revertCommand
+	}
+});
 
 //#endregion
 //#region src/commands/update/index.ts
-const updateCommand = Command.make("update", {}, () => Console.log("Manage OTA updates. Run with --help for subcommands.")).pipe(Command.withSubcommands([
-	publishCommand,
-	listCommand,
-	deleteCommand,
-	promoteCommand,
-	rollbackCommand,
-	rolloutCommand
-]));
+const updateCommand = defineCommand({
+	meta: {
+		name: "update",
+		description: "Manage OTA updates"
+	},
+	subCommands: {
+		publish: publishCommand,
+		list: listCommand,
+		delete: deleteCommand,
+		promote: promoteCommand,
+		rollback: rollbackCommand,
+		rollout: rolloutCommand
+	}
+});
 
 //#endregion
 //#region src/index.ts
-const command = Command.make("better-update", {}, () => Console.log("better-update CLI - Run with --help to see available commands")).pipe(Command.withSubcommands([
-	loginCommand,
-	logoutCommand,
-	initCommand,
-	statusCommand,
-	projectsCommand,
-	branchesCommand,
-	channelsCommand,
-	buildCommand,
-	buildsCommand,
-	credentialsCommand,
-	envCommand,
-	fingerprintCommand,
-	updateCommand,
-	analyticsCommand,
-	auditLogsCommand
-]));
-Command.run(command, {
-	name: "better-update",
-	version: "0.1.0"
-})(process.argv).pipe(Effect.provide(CliLive), NodeRuntime.runMain);
+await runMain(defineCommand({
+	meta: {
+		name: "better-update",
+		version: "0.1.0",
+		description: "Publish OTA updates and builds for Expo apps"
+	},
+	subCommands: {
+		login: loginCommand,
+		logout: logoutCommand,
+		init: initCommand,
+		status: statusCommand,
+		projects: projectsCommand,
+		branches: branchesCommand,
+		channels: channelsCommand,
+		build: buildCommand,
+		builds: buildsCommand,
+		credentials: credentialsCommand,
+		env: envCommand,
+		fingerprint: fingerprintCommand,
+		update: updateCommand,
+		analytics: analyticsCommand,
+		"audit-logs": auditLogsCommand
+	}
+}));
 
 //#endregion
 export {  };