@akterjs/cli 0.0.0-stage → 0.1.0

package/dist/registry/cloud-served.pure.mjs

@@ -0,0 +1,31 @@
+import { R as some, T as join, j as map, l as filter, r as contains, u as findFirst } from "../Array-B4kuTQeW.mjs";
+import { t as match } from "../Boolean-kILIvmhE.mjs";
+import { _ as isSome, b as map$1, c as flatten, cn as isString, f as getOrElse, h as isNone, i as filter$1, o as flatMap, r as exists, u as fromNullishOr, w as some$1 } from "../Option-DkxSnBhp.mjs";
+import { nt as decodeOption, or as fromEntries, pt as fromJsonString, sr as get, y as Json } from "../Schema-MiKt5K1v.mjs";
+// src/registry/cloud-served.pure.ts
+const loopbackHosts = [
+	"localhost",
+	"127.0.0.1",
+	"[::1]"
+];
+const renamed = [["forkId", "commandId"]];
+const renamedFrom = (name) => map$1(findFirst(renamed, ([field]) => field === name), ([, flag]) => flag);
+const keyFields = ["into", "key"];
+const JsonText = fromJsonString(Json);
+const servedBy = (operations) => (actor) => findFirst(operations, ({ command }) => join(command, " ") === join(actor.command, " "));
+const isLocalApp = (url) => exists(flatMap(url, (given) => fromNullishOr(globalThis.URL.parse(given)?.hostname)), (host) => contains(loopbackHosts, host));
+const cloudOnlyFields = ({ actor, cloud }) => filter(cloud.fields, ({ name }) => !some(actor.fields, (field) => field === name) && isNone(renamedFrom(name)));
+const keyText = (text) => getOrElse(filter$1(decodeOption(JsonText)(text), isString), () => text);
+const textOf = (name) => (text) => match(contains(keyFields, name), {
+	onFalse: () => text,
+	onTrue: () => keyText(text)
+});
+const givenIn = (values) => (flag) => flatten(get(values, flag));
+const valueOf = ({ minted, values }) => (name) => {
+	const given = givenIn(values);
+	const renaming = renamedFrom(name);
+	if (isSome(renaming)) return some$1(getOrElse(given(renaming.value), () => minted));
+	return map$1(given(name), textOf(name));
+};
+const cloudValuesOf = (filled) => fromEntries(map(filled.cloud.fields, ({ name }) => [name, valueOf(filled)(name)]));
+export { cloudOnlyFields, cloudValuesOf, isLocalApp, servedBy };

package/dist/registry/operation-call.service.mjs

@@ -0,0 +1,262 @@
+import { R as some, T as join } from "../Array-B4kuTQeW.mjs";
+import { t as match } from "../Boolean-kILIvmhE.mjs";
+import { n as log, t as error } from "../Console-BKHUkH6a.mjs";
+import { At as provideContext, B as flatMap, Dt as orElseSucceed, Et as orDie, Gn as mergeAll, Gt as scoped, T as context, Vn as effect, W as fnUntraced, Xt as succeed, aa as Service, et as gen, ht as mapError, in as timeout, l as as, qn as provideMerge, x as catchTag } from "../Effect-CKFpqbmw.mjs";
+import { t as FileSystem } from "../FileSystem-4pPcEb_i.mjs";
+import { C as orElse, S as none, _ as isSome, b as map, cn as isString, f as getOrElse, h as isNone, i as filter, in as isNumber, o as flatMap$1, p as getOrNull, t as all, v as liftPredicate, w as some$1, x as match$1 } from "../Option-DkxSnBhp.mjs";
+import { at as decodeUnknownEffect, b as JsonObject, cr as getSomes, gr as union, lr as has, mr as set, pt as fromJsonString, q as Uint8ArrayFromBase64, sr as get, st as encodeEffect, tt as decodeEffect, y as Json } from "../Schema-MiKt5K1v.mjs";
+import { t as Stdio } from "../Stdio-KylmOBX_.mjs";
+import { M as mkString, T as make, i as decodeText, z as run } from "../Stream-bK9QIETN.mjs";
+import { h as startsWith, p as slice } from "../String-q5dcsVe4.mjs";
+import { f as HttpClient, g as mapRequest, y as isHttpMethod } from "../cloud-client.adapter-Cy1BjDbG.mjs";
+import { E as setUrlParams, S as prependUrl, T as setUrlParam, d as acceptJson, p as bodyJson, w as setHeaders, y as make$1 } from "../HttpClientResponse-D5ZKICVV.mjs";
+import { CliExitError } from "../terminal/cli-exit.errors.mjs";
+import { Credentials } from "../credentials/credentials.service.mjs";
+import { t as CloudClient } from "../cloud-client.adapter-DOVMoYAj.mjs";
+import { Approval } from "./approval.service.mjs";
+import { i as validInput, n as parseInput, r as targetOf, t as checkedSchema } from "../operation-input.pure-CS9iUhqK.mjs";
+import { errorLine, joinedPages, printJson, reported, retryHint, unanswered } from "./operation-output.pure.mjs";
+import { RunnerExitedError } from "../runner-exited.errors.mjs";
+// src/registry/operation-call.service.ts
+const approvalHeader = "akter-approval";
+const callWait = "2 minutes";
+const firstSuccess = 200;
+const firstRedirect = 300;
+const confirmationRequired = 428;
+const fromFile = "@";
+const fromStdin = "-";
+const JsonText = fromJsonString(Json);
+const Base64 = Uint8ArrayFromBase64;
+const commandName = (operation) => `akter ${join(operation.command, " ")}`;
+const unreadable = (message) => () => CliExitError.make({
+	code: CliExitError.codes.usage,
+	message,
+	reason: "InvalidInput"
+});
+const unreadableAnswer = (operation) => () => CliExitError.make({
+	code: CliExitError.codes.unavailable,
+	message: `The API's answer to ${commandName(operation)} could not be read.`,
+	reason: "ResponseUnreadable"
+});
+const mismatch = (operation) => (failure) => CliExitError.make({
+	code: CliExitError.codes.failed,
+	message: `The API's answer to ${commandName(operation)} doesn't match its schema, so this CLI and the API disagree:\n${failure.message}`,
+	reason: "ResponseMismatch"
+});
+const readText = fnUntraced(function* readText(raw) {
+	if (raw === fromStdin) {
+		const stdio = yield* Stdio;
+		return yield* mkString(decodeText(stdio.stdin)).pipe(mapError(unreadable("Could not read --input from stdin.")));
+	}
+	if (!startsWith(fromFile)(raw)) return raw;
+	const file = slice(1)(raw);
+	return yield* (yield* FileSystem).readFileString(file).pipe(mapError(unreadable(`Could not read --input from ${file}.`)));
+});
+const inputOf = fnUntraced(function* inputOf(operation, options) {
+	const base = yield* match$1(options.input, {
+		onNone: () => succeed({}),
+		onSome: (raw) => flatMap(readText(raw), parseInput)
+	});
+	const assembled = union(base, getSomes(options.values), (_given, flag) => flag);
+	if (!some(operation.fields, (field) => field.name === "organization") || has(assembled, "organization")) return assembled;
+	const organization = yield* Credentials.use((credentials) => credentials.organization(none()));
+	return match$1(organization, {
+		onNone: () => assembled,
+		onSome: (name) => set(assembled, "organization", name)
+	});
+});
+const printBinary = fnUntraced(function* printBinary({ json, operation, response }) {
+	const buffer = yield* response.arrayBuffer.pipe(mapError(unreadableAnswer(operation)));
+	const bytes = new Uint8Array(buffer);
+	if (json) {
+		const encoded = yield* encodeEffect(Base64)(bytes).pipe(orDie);
+		return yield* printJson(true)(encoded);
+	}
+	const stdio = yield* Stdio;
+	return yield* run(make(bytes), stdio.stdout({ endOnDone: false })).pipe(orDie);
+});
+const checkedAnswer = fnUntraced(function* checkedAnswer(operation, response) {
+	const value = yield* response.json.pipe(mapError(unreadableAnswer(operation)));
+	const schema = yield* checkedSchema(operation.success.schema);
+	yield* decodeEffect(schema)(value).pipe(mapError(mismatch(operation)));
+	return value;
+});
+const printSuccess = fnUntraced(function* printSuccess(answer) {
+	const { json, operation, response } = answer;
+	if (operation.success.kind === "binary") return yield* printBinary(answer);
+	if (operation.success.kind === "empty") return yield* match(json, {
+		onFalse: () => log(`Done: ${commandName(operation)}.`),
+		onTrue: () => log("null")
+	});
+	const value = yield* checkedAnswer(operation, response);
+	return yield* printJson(json)(value);
+});
+const bodyOf = fnUntraced(function* bodyOf(response) {
+	const text = yield* response.text.pipe(orElseSucceed(() => ""));
+	return yield* decodeEffect(JsonText)(text).pipe(orElseSucceed(() => text));
+});
+const printRefusal = fnUntraced(function* printRefusal({ json, operation, response }, body) {
+	const code = CliExitError.ofStatus(response.status);
+	if (json) yield* printJson(true)(body);
+	else {
+		const hint = retryHint({
+			...operation.annotations,
+			status: response.status
+		});
+		yield* error(`${commandName(operation)} failed: ${errorLine({
+			body,
+			status: response.status
+		})}${hint}`);
+	}
+	return yield* RunnerExitedError.make({ code });
+});
+const methodOf = (operation) => getOrElse(liftPredicate(operation.method, isHttpMethod), () => "GET");
+const requestFor = ({ operation, options, request }) => {
+	const approvalHeaders = match$1(options.approval, {
+		onNone: () => ({}),
+		onSome: (token) => ({ [approvalHeader]: token })
+	});
+	const base = make$1(methodOf(operation))(request.path).pipe(setUrlParams(request.query), acceptJson, setHeaders(approvalHeaders));
+	return match$1(request.body, {
+		onNone: () => succeed(base),
+		onSome: (body) => orDie(bodyJson(base, body))
+	});
+};
+const printPlan = ({ operation, options, request }) => printJson(options.json)({
+	body: getOrNull(request.body),
+	dryRun: true,
+	method: operation.method,
+	operation: operation.id,
+	path: request.path,
+	query: request.query
+});
+const organizationOf = (input) => filter(get(input, "organization"), isString);
+const approvalAsked = fnUntraced(function* approvalAsked(planned, answer, body) {
+	const required = (yield* Approval).isRequired(body);
+	const unapproved = isNone(planned.options.approval) && answer.response.status === confirmationRequired;
+	return all({
+		organization: organizationOf(planned.input),
+		required
+	}).pipe(filter(() => unapproved), map(({ organization, required: asked }) => ({
+		command: commandName(planned.operation),
+		organization,
+		required: asked
+	})));
+});
+const attempt = fnUntraced(function* attempt(planned, http) {
+	const { operation, options } = planned;
+	const response = yield* flatMap(requestFor(planned), http.execute).pipe(timeout(callWait), mapError((failure) => unanswered({
+		command: commandName(operation),
+		failure,
+		wait: callWait
+	})));
+	const answer = {
+		json: options.json,
+		operation,
+		response
+	};
+	if (response.status >= firstSuccess && response.status < firstRedirect) return yield* as(printSuccess(answer), none());
+	const body = yield* bodyOf(response);
+	const asked = yield* approvalAsked(planned, answer, body);
+	if (isSome(asked)) return some$1({
+		...asked.value,
+		http
+	});
+	return yield* printRefusal(answer, body);
+}, scoped);
+const nextOf = (page) => flatMap$1(get(page, "next"), (next) => orElse(liftPredicate(next, isString), () => map(liftPredicate(next, isNumber), String)));
+const pageAfter = fnUntraced(function* pageAfter(planned, http, after) {
+	const { operation, options } = planned;
+	const first = yield* requestFor(planned);
+	const request = match$1(after, {
+		onNone: () => first,
+		onSome: (cursor) => setUrlParam(first, "after", cursor)
+	});
+	const response = yield* http.execute(request).pipe(timeout(callWait), mapError((failure) => unanswered({
+		command: commandName(operation),
+		failure,
+		wait: callWait
+	})));
+	if (response.status < firstSuccess || response.status >= firstRedirect) {
+		const body = yield* bodyOf(response);
+		return yield* printRefusal({
+			json: options.json,
+			operation,
+			response
+		}, body);
+	}
+	const value = yield* checkedAnswer(operation, response);
+	return yield* decodeUnknownEffect(JsonObject)(value).pipe(mapError(mismatch(operation)));
+}, scoped);
+const everyPage = fnUntraced(function* everyPage(planned, http) {
+	const first = yield* pageAfter(planned, http, none());
+	const rest = [];
+	let next = nextOf(first);
+	while (isSome(next)) {
+		const page = yield* pageAfter(planned, http, next);
+		rest.push(page);
+		next = nextOf(page);
+	}
+	return yield* printJson(planned.options.json)(joinedPages([first, ...rest]));
+});
+const approved = fnUntraced(function* approved(planned, http) {
+	const asked = yield* attempt(planned, http);
+	if (isNone(asked)) return;
+	const token = yield* Approval.use((approval) => approval.token(asked.value));
+	yield* attempt({
+		...planned,
+		options: {
+			...planned.options,
+			approval: some$1(token)
+		}
+	}, http);
+});
+const sendOn = fnUntraced(function* sendOn(planned, http) {
+	if (planned.options.all) return yield* everyPage(planned, http);
+	return yield* approved(planned, http);
+});
+const send = fnUntraced(function* send(planned) {
+	const url = yield* Credentials.use((credentials) => credentials.url(planned.options.url));
+	if (!planned.operation.secured) {
+		const http = yield* HttpClient;
+		return yield* sendOn(planned, mapRequest(http, prependUrl(url.href)));
+	}
+	const credential = yield* Credentials.use((credentials) => credentials.credentialFor(url));
+	const cloud = yield* CloudClient.use((factory) => factory.connect({
+		apiKey: credential.secret,
+		url
+	}));
+	return yield* sendOn(planned, cloud.http);
+});
+const callOperation = fnUntraced(function* callOperation(operation, options) {
+	const input = yield* inputOf(operation, options);
+	const { input: valid, request } = yield* validInput({
+		input,
+		operation
+	});
+	if (options.dryRun) return yield* printPlan({
+		input: valid,
+		operation,
+		options,
+		request
+	});
+	const command = commandName(operation);
+	yield* Approval.use((approval) => approval.confirm({
+		command,
+		needed: operation.annotations.confirm && isNone(options.approval),
+		question: `${operation.description} Run ${command} for ${targetOf(operation)(valid)}?`
+	}));
+	return yield* send({
+		input: valid,
+		operation,
+		options,
+		request
+	});
+});
+var OperationCall = class extends Service()("@akterjs/cli/registry/operation-call.service/OperationCall", { make: gen(function* makeOperationCall() {
+	const context$1 = yield* context();
+	return { call: (operation, options) => callOperation(operation, options).pipe(catchTag("CliExitError", reported(options.json)), provideContext(context$1)) };
+}) }) {
+	static layer = effect(this, this.make).pipe(provideMerge(mergeAll(Credentials.layer, CloudClient.layer, Approval.layer)));
+};
+export { OperationCall };

package/dist/registry/operation-input.pure.mjs

@@ -0,0 +1 @@
+export { t as checkedSchema, n as parseInput, r as targetOf, i as validInput } from "../operation-input.pure-CS9iUhqK.mjs";

package/dist/registry/operation-output.pure.mjs

@@ -0,0 +1,91 @@
+import { D as lastNonEmpty, T as join, j as map, p as flatMap, w as isReadonlyArrayNonEmpty } from "../Array-B4kuTQeW.mjs";
+import { t as match } from "../Boolean-kILIvmhE.mjs";
+import { B as flatMap$1, Et as orDie, M as fail, o as andThen, ti as isTimeoutError } from "../Effect-CKFpqbmw.mjs";
+import { n as log, t as error } from "../Console-BKHUkH6a.mjs";
+import { Tn as pipe, cn as isString, d as fromUndefinedOr, f as getOrElse, i as filter, x as match$1 } from "../Option-DkxSnBhp.mjs";
+import { b as JsonObject, ct as encodeOption, fr as map$1, hr as toEntries, mt as is, n as ArraySchema, pr as remove, pt as fromJsonString, sr as get, st as encodeEffect, y as Json } from "../Schema-MiKt5K1v.mjs";
+import { v as trim } from "../String-q5dcsVe4.mjs";
+import { CliExitError } from "../terminal/cli-exit.errors.mjs";
+import { TokenRefreshError } from "../deploy/auth/token-refresh.errors.mjs";
+import { DeployFailedError } from "../deploy/deploy-failed.errors.mjs";
+import { RunnerExitedError } from "../runner-exited.errors.mjs";
+// src/registry/operation-output.pure.ts
+const compact = encodeEffect(fromJsonString(Json));
+const pretty = encodeEffect(fromJsonString(Json, { space: 2 }));
+const compactOption = encodeOption(fromJsonString(Json));
+const encodeExit = encodeEffect(CliExitError);
+const compactJson = (value) => orDie(compact(value));
+const prettyJson = (value) => orDie(pretty(value));
+const exitJson = (failure) => flatMap$1(orDie(encodeExit(failure)), compactJson);
+const shown = (value) => {
+	if (isString(value)) return value;
+	return getOrElse(compactOption(value), () => "");
+};
+const errorLine = ({ body, status }) => {
+	if (!is(JsonObject)(body)) return trim(`HTTP ${status} ${shown(body)}`);
+	const tag = pipe(get(body, "_tag"), filter(isString), getOrElse(() => "Error"));
+	const fields = pipe(toEntries(remove(body, "_tag")), map(([key, value]) => `${key}: ${shown(value)}`));
+	if (isReadonlyArrayNonEmpty(fields)) return `HTTP ${status} ${tag} (${join(fields, ", ")})`;
+	return `HTTP ${status} ${tag}`;
+};
+const unavailableStatus = 503;
+/**
+* After a 503 an idempotent change may have stopped partway, as erasing an actor can between releasing its files and
+* destroying its key (FK6); running it again finishes it.
+*/
+const retryHint = ({ idempotent, readOnly, status }) => {
+	if (status === unavailableStatus && idempotent && !readOnly) return ". It may have stopped partway, and it is safe to repeat: run the same command again.";
+	return "";
+};
+const unavailable = (message) => CliExitError.make({
+	code: CliExitError.codes.unavailable,
+	message,
+	reason: "Unavailable"
+});
+const signInCode = (failure) => match$1(fromUndefinedOr(failure.status), {
+	onNone: () => CliExitError.codes.unavailable,
+	onSome: CliExitError.ofStatus
+});
+/**
+* A token exchange that failed, with the exit code of what failed it: 3 only when the API refused the key (401 or
+* 403), and 5 when it couldn't answer, answered 5xx, or a refresh failed, since trying again may succeed.
+*/
+const signInFailure = (failure) => {
+	if (is(TokenRefreshError)(failure)) return unavailable(failure.message);
+	const message = `Signing in failed: ${failure.message}`;
+	return CliExitError.make({
+		code: signInCode(failure),
+		message,
+		reason: "SignInFailed"
+	});
+};
+const unanswered = ({ command, failure, wait }) => {
+	if (is(DeployFailedError)(failure) || is(TokenRefreshError)(failure)) return signInFailure(failure);
+	if (isTimeoutError(failure)) return unavailable(`${command} got no answer within ${wait}; the request may still have run.`);
+	return unavailable(`${command} could not reach the API: ${failure.message}`);
+};
+const printJson = (json) => (value) => {
+	const text = match(json, {
+		onFalse: () => prettyJson(value),
+		onTrue: () => compactJson(value)
+	});
+	return flatMap$1(text, (line) => log(line));
+};
+const JsonArray = ArraySchema(Json);
+const arrayAt = (page, key) => getOrElse(filter(get(page, key), is(JsonArray)), () => []);
+const joinedPages = (pages) => {
+	const last = lastNonEmpty(pages);
+	const joined = map$1(last, (value, key) => match(is(JsonArray)(value), {
+		onFalse: () => value,
+		onTrue: () => flatMap(pages, (page) => arrayAt(page, key))
+	}));
+	return remove(joined, "next");
+};
+const reported = (json) => (failure) => {
+	const printed = match(json, {
+		onFalse: () => error(failure.message),
+		onTrue: () => flatMap$1(exitJson(failure), (line) => log(line))
+	});
+	return andThen(printed, fail(RunnerExitedError.make({ code: failure.code })));
+};
+export { compactJson, errorLine, exitJson, joinedPages, printJson, reported, retryHint, signInFailure, unanswered };

package/dist/registry/served-command.config.mjs

@@ -0,0 +1,57 @@
+import { T as join, j as map } from "../Array-B4kuTQeW.mjs";
+import { a as option, i as String } from "../Config-B6OND9WR.mjs";
+import { Dt as orElseSucceed, W as fnUntraced, dt as map$1 } from "../Effect-CKFpqbmw.mjs";
+import { C as orElse, S as none, x as match } from "../Option-DkxSnBhp.mjs";
+import { or as fromEntries } from "../Schema-MiKt5K1v.mjs";
+import { f as optional, i as withDescription$1, l as String$1, m as withDescription, r as unlisted, t as make } from "../Command-Dzq9KM-h.mjs";
+import { t as SecureRandom } from "../SecureRandom-B_U4ysO3.mjs";
+import { t as kebab } from "../operation-registry.pure-DVC8EDgj.mjs";
+import { cloudOnlyFields, cloudValuesOf, isLocalApp } from "./cloud-served.pure.mjs";
+import { OperationCall } from "./operation-call.service.mjs";
+// src/registry/served-command.config.ts
+const approval = String$1("approval").pipe(optional, withDescription("On Akter Cloud, a token from an approved request, to run this without a person at the terminal"));
+const cloudFlag = (field) => String$1(kebab(field.name)).pipe(optional, withDescription(`On Akter Cloud: ${field.description}`));
+const appUrlOf = (flag) => map$1(option(String("AKTER_APP_URL")).pipe(orElseSucceed(() => none())), (configured) => orElse(flag, () => configured));
+const onCloud = fnUntraced(function* onCloud({ cloud }, options) {
+	const minted = yield* SecureRandom.use((random) => random.uuidV7());
+	const values = cloudValuesOf({
+		cloud,
+		minted,
+		values: {
+			...options.fields,
+			...options.cloud
+		}
+	});
+	return yield* OperationCall.use((service) => service.call(cloud, {
+		all: false,
+		approval: options.approval,
+		dryRun: options.dryRun,
+		input: none(),
+		json: options.json,
+		url: none(),
+		values
+	}));
+});
+const servedDescription = (served) => {
+	const flags = map(cloudOnlyFields(served), ({ name }) => `--${kebab(name)}`);
+	return `${served.actor.description} On akter dev it goes to the app at --url. On Akter Cloud it is the Cloud API's ${served.cloud.id}, an operator action: pass ${join(flags, ", ")} instead of --url, and a person confirms it, or --approval carries an approved token.`;
+};
+const servedCommandOf = ({ flags, local, served }) => {
+	const [, name] = served.actor.command;
+	const cloud = fromEntries(map(cloudOnlyFields(served), (field) => [field.name, cloudFlag(field)]));
+	const routed = fnUntraced(function* routed(options) {
+		const appUrl = yield* appUrlOf(options.url);
+		if (isLocalApp(appUrl)) return yield* local(options);
+		return yield* onCloud(served, options);
+	});
+	const command = make(name, {
+		...flags,
+		approval,
+		cloud
+	}, routed).pipe(withDescription$1(servedDescription(served)));
+	return match(served.cloud.flag, {
+		onNone: () => command,
+		onSome: () => unlisted(command)
+	});
+};
+export { servedCommandOf };

package/dist/runner-exited.errors.mjs

@@ -0,0 +1,10 @@
+import { n as errorReported, t as errorExitCode } from "./Runtime-BInIAwK3.mjs";
+import { v as Int, z as TaggedError } from "./Schema-MiKt5K1v.mjs";
+// src/runner-exited.errors.ts
+var RunnerExitedError = class extends TaggedError()("RunnerExitedError", { code: Int }) {
+	[errorReported] = false;
+	get [errorExitCode]() {
+		return this.code;
+	}
+};
+export { RunnerExitedError };

package/dist/terminal/cli-exit.errors.mjs

@@ -0,0 +1,38 @@
+import { r as contains } from "../Array-B4kuTQeW.mjs";
+import { t as errorExitCode } from "../Runtime-BInIAwK3.mjs";
+import { F as String, v as Int, z as TaggedError } from "../Schema-MiKt5K1v.mjs";
+// src/terminal/cli-exit.errors.ts
+const exitCodes = {
+	authentication: 3,
+	confirmation: 4,
+	failed: 1,
+	unavailable: 5,
+	usage: 2
+};
+const badRequest = 400;
+const unauthorized = 401;
+const forbidden = 403;
+const timedOut = 408;
+const unprocessable = 422;
+const preconditionRequired = 428;
+const tooManyRequests = 429;
+const firstServerError = 500;
+const exitCodeOf = (status) => {
+	if (contains([badRequest, unprocessable], status)) return exitCodes.usage;
+	if (contains([unauthorized, forbidden], status)) return exitCodes.authentication;
+	if (status === preconditionRequired) return exitCodes.confirmation;
+	if (contains([timedOut, tooManyRequests], status) || status >= firstServerError) return exitCodes.unavailable;
+	return exitCodes.failed;
+};
+var CliExitError = class extends TaggedError()("CliExitError", {
+	code: Int,
+	message: String,
+	reason: String
+}) {
+	static codes = exitCodes;
+	static ofStatus = exitCodeOf;
+	get [errorExitCode]() {
+		return this.code;
+	}
+};
+export { CliExitError };

package/dist/terminal/cli-failure.pure.mjs

@@ -0,0 +1,31 @@
+import { n as log, t as error } from "../Console-BKHUkH6a.mjs";
+import { B as flatMap, W as fnUntraced, Xt as succeed, _n as when } from "../Effect-CKFpqbmw.mjs";
+import { r as getErrorExitCode } from "../Runtime-BInIAwK3.mjs";
+import { mt as is } from "../Schema-MiKt5K1v.mjs";
+import { t as Stdio } from "../Stdio-KylmOBX_.mjs";
+import { a as ShowHelp } from "../CliError-Cf5xqkkj.mjs";
+import { exitJson } from "../registry/operation-output.pure.mjs";
+import { RunnerExitedError } from "../runner-exited.errors.mjs";
+import { CliExitError } from "./cli-exit.errors.mjs";
+// src/terminal/cli-failure.pure.ts
+const isShowHelp = is(ShowHelp);
+const isExit = is(CliExitError);
+const isRunnerExit = is(RunnerExitedError);
+const noErrors = 0;
+const asExit = (failure) => {
+	if (isExit(failure)) return failure;
+	return CliExitError.make({
+		code: getErrorExitCode(failure),
+		message: failure.message,
+		reason: "Failed"
+	});
+};
+const reportFailure = fnUntraced(function* reportFailure(failure) {
+	if (isShowHelp(failure)) return yield* when(RunnerExitedError.make({ code: CliExitError.codes.usage }), succeed(failure.errors.length > noErrors));
+	if (isRunnerExit(failure)) return yield* failure;
+	const exit = asExit(failure);
+	if ((yield* Stdio.use((stdio) => stdio.args)).includes("--json")) yield* flatMap(exitJson(exit), log);
+	else yield* error(exit.message);
+	return yield* RunnerExitedError.make({ code: exit.code });
+});
+export { reportFailure };

package/dist/terminal/confirm.adapter.mjs

@@ -0,0 +1,27 @@
+import { At as provideContext, T as context, Vn as effect, W as fnUntraced, Xt as succeed, aa as Service, et as gen, x as catchTag } from "../Effect-CKFpqbmw.mjs";
+import { d as run, n as Confirm, t as TerminalCapabilities } from "../TerminalCapabilities-w_44MAca.mjs";
+import { CliExitError } from "./cli-exit.errors.mjs";
+// src/terminal/confirm.adapter.ts
+const declined = () => CliExitError.make({
+	code: CliExitError.codes.confirmation,
+	message: "Not confirmed, so nothing was changed.",
+	reason: "NotConfirmed"
+});
+const ask = fnUntraced(function* ask({ question, unattended }) {
+	const { canPrompt } = yield* TerminalCapabilities;
+	if (!canPrompt) return yield* CliExitError.make({
+		code: CliExitError.codes.confirmation,
+		message: unattended,
+		reason: "ConfirmationRequired"
+	});
+	const confirmed = yield* run(Confirm({ message: question })).pipe(catchTag("QuitError", () => succeed(false)));
+	if (!confirmed) return yield* declined();
+	return confirmed;
+});
+var Confirmation = class extends Service()("@akterjs/cli/terminal/confirm.adapter/Confirmation", { make: gen(function* makeConfirmation() {
+	const context$1 = yield* context();
+	return { confirm: (question) => provideContext(ask(question), context$1) };
+}) }) {
+	static layer = effect(this, this.make);
+};
+export { Confirmation };

package/package.json

@@ -1,6 +1,64 @@
 {
   "name": "@akterjs/cli",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "description": "The akter command: local engine, deploy, branch, restore, history, export, migrate and bench.",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Rika-Labs/akter.git",
+    "directory": "packages/cli"
+  },
+  "bin": {
+    "akter": "./dist/akter.cli.mjs"
+  },
+  "files": [
+    "dist",
+    "legal"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "imports": {
+    "#src/*": "./dist/*.mjs"
+  },
+  "exports": {
+    "./program": "./dist/command/akter-program.config.mjs",
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "dependencies": {
+    "esbuild": "0.28.2"
+  },
+  "devDependencies": {
+    "@akterjs/client": "0.1.0",
+    "@akterjs/cloud-api": "file:../../../akter-cloud/packages/cloud-api",
+    "@akterjs/effect": "0.1.0",
+    "@effect/openapi-generator": "4.1.2",
+    "@effect/platform-node": "4.1.2",
+    "@effect/vitest": "4.1.2",
+    "effect": "4.1.2",
+    "mutant-cafe": "0.1.6",
+    "publint": "0.3.25",
+    "tsdown": "0.23.5",
+    "vitest": "5.1.0"
+  },
+  "peerDependencies": {
+    "@effect/platform-node": "4.1.2",
+    "effect": "4.1.2"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "scripts": {
+    "generate": "bun --conditions=@akterjs/source scripts/generate-client.cli.ts",
+    "typecheck": "effect-tsgo tsrs --noEmit -p tsconfig.json",
+    "lint": "effect-tsgo --tsrs-lint oxlint -c ../../oxlint.config.ts --type-aware --tsconfig tsconfig.json src scripts tests",
+    "test": "vitest run",
+    "build": "tsdown",
+    "measure:startup": "bun scripts/measure-startup.cli.ts",
+    "mutants": "GIT_DIR=$(git rev-parse --absolute-git-dir) VITEST_MAX_WORKERS=1 mutant-cafe --advisory && node ../../node_modules/@rikalabs/rules/src/mutants/mutants.cli.mjs --all",
+    "mutants:diff": "git diff --relative main...HEAD | GIT_DIR=$(git rev-parse --absolute-git-dir) VITEST_MAX_WORKERS=1 mutant-cafe --in-diff /dev/stdin --advisory && node ../../node_modules/@rikalabs/rules/src/mutants/mutants.cli.mjs"
+  }
 }