@keystrokehq/cli 0.0.1

package/dist/keystroke.mjs

@@ -0,0 +1,707 @@
+#!/usr/bin/env node
+
+import { Command, CommanderError, Option } from "commander";
+import * as fs from "node:fs";
+import * as fsPromises from "node:fs/promises";
+import * as os from "node:os";
+import * as path$1 from "node:path";
+import { z } from "zod";
+import { log } from "@clack/prompts";
+//#region package.json
+var version = "0.0.1";
+//#endregion
+//#region src/command-registry.ts
+const ROOT_OPTIONS_WITH_VALUES = new Set([
+	"--api-key",
+	"--base-url",
+	"--org"
+]);
+const ROOT_VERSION_FLAGS = new Set(["-V", "--version"]);
+const lazyCommandDefinitions = [
+	{
+		name: "agents",
+		loadCommand: async () => (await import("./agents-CZJGxVqV.mjs")).createAgentsCommand()
+	},
+	{
+		name: "api-keys",
+		loadCommand: async () => (await import("./api-keys-D2lgguuY.mjs")).createApiKeysCommand()
+	},
+	{
+		name: "auth",
+		loadCommand: async () => (await import("./auth-DN2VusyU.mjs")).createAuthCommand()
+	},
+	{
+		name: "connect",
+		loadCommand: async () => (await import("./connect-BUXkeH0F.mjs")).createConnectCommand()
+	},
+	{
+		name: "credentials",
+		loadCommand: async () => (await import("./credentials-CvmjU0lK.mjs")).createCredentialsCommand(),
+		copyInheritedSettings: true
+	},
+	{
+		name: "org",
+		loadCommand: async () => (await import("./org-xLzBtt2_.mjs")).createOrgCommand()
+	},
+	{
+		name: "deploy",
+		loadCommand: async () => (await import("./deploy-BOPIpRWm.mjs")).createDeployCommand()
+	},
+	{
+		name: "init",
+		loadCommand: async () => (await import("./init-DpMCotSK.mjs")).createInitCommand()
+	},
+	{
+		name: "integrations",
+		loadCommand: async () => (await import("./integrations-DlatPK4W.mjs")).createIntegrationsCommand()
+	},
+	{
+		name: "logs",
+		loadCommand: async () => (await import("./logs-BEg9L5l8.mjs")).createLogsCommand()
+	},
+	{
+		name: "projects",
+		loadCommand: async () => (await import("./projects-Cjb7sovS.mjs")).createProjectsCommand()
+	},
+	{
+		name: "runs",
+		loadCommand: async () => (await import("./runs-D9hNLb9A.mjs")).createRunsCommand()
+	},
+	{
+		name: "skills",
+		loadCommand: async () => (await import("./skills.command-CrjI2dN9.mjs")).createSkillsCommand()
+	},
+	{
+		name: "sync",
+		loadCommand: async () => (await import("./sync-BL_Mo5st.mjs")).createSyncCommand()
+	},
+	{
+		name: "test",
+		loadCommand: async () => (await import("./test-BHTgR3UA.mjs")).createTestCommand()
+	},
+	{
+		name: "workflows",
+		loadCommand: async () => (await import("./workflows-g9z87AJJ.mjs")).createWorkflowsCommand()
+	}
+];
+function selectCommandRegistration(argv, commandNames = new Set(lazyCommandDefinitions.map((definition) => definition.name))) {
+	const firstCommand = readFirstNonOption(argv, 0);
+	if (!firstCommand) return argv.some((arg) => ROOT_VERSION_FLAGS.has(arg)) ? { kind: "none" } : { kind: "all" };
+	if (firstCommand.value === "help") {
+		const helpTarget = readFirstNonOption(argv, firstCommand.index + 1);
+		return helpTarget && commandNames.has(helpTarget.value) ? {
+			kind: "selected",
+			name: helpTarget.value
+		} : { kind: "all" };
+	}
+	return commandNames.has(firstCommand.value) ? {
+		kind: "selected",
+		name: firstCommand.value
+	} : { kind: "all" };
+}
+async function registerCommandsForArgv(program, argv, definitions = lazyCommandDefinitions) {
+	const selection = selectCommandRegistration(argv, new Set(definitions.map((definition) => definition.name)));
+	const selectedDefinitions = selection.kind === "none" ? [] : selection.kind === "all" ? definitions : definitions.filter((definition) => definition.name === selection.name);
+	for (const definition of selectedDefinitions) {
+		const command = await definition.loadCommand();
+		if (definition.copyInheritedSettings) command.copyInheritedSettings(program);
+		program.addCommand(command);
+	}
+}
+function readFirstNonOption(argv, startIndex) {
+	for (let index = startIndex; index < argv.length; index += 1) {
+		const arg = argv[index];
+		if (!arg) continue;
+		if (arg === "--") return null;
+		if (arg.startsWith("--")) {
+			const [flag] = arg.split("=", 1);
+			if (flag && ROOT_OPTIONS_WITH_VALUES.has(flag) && !arg.includes("=")) index += 1;
+			continue;
+		}
+		if (arg.startsWith("-")) continue;
+		return {
+			value: arg,
+			index
+		};
+	}
+	return null;
+}
+//#endregion
+//#region src/lib/cli-errors.ts
+var CliExitError = class extends Error {
+	exitCode;
+	reported;
+	constructor(message, options = {}) {
+		super(message, options.cause !== void 0 ? { cause: options.cause } : void 0);
+		this.name = "CliExitError";
+		this.exitCode = options.exitCode ?? 1;
+		this.reported = options.reported ?? false;
+	}
+	markReported() {
+		this.reported = true;
+		return this;
+	}
+};
+function throwReportedCliExit(message, options = {}) {
+	throw new CliExitError(message, {
+		...options,
+		reported: true
+	});
+}
+var InputValidationError = class extends CliExitError {
+	constructor(message, options = {}) {
+		super(message, options);
+		this.name = "InputValidationError";
+	}
+};
+var WorkflowResolutionError = class extends CliExitError {
+	constructor(message, options = {}) {
+		super(message, options);
+		this.name = "WorkflowResolutionError";
+	}
+};
+var ProjectNotFoundError = class extends CliExitError {
+	constructor(message, options = {}) {
+		super(message, options);
+		this.name = "ProjectNotFoundError";
+	}
+};
+var AuthenticationError = class extends CliExitError {
+	constructor(message, options = {}) {
+		super(message, options);
+		this.name = "AuthenticationError";
+	}
+};
+//#endregion
+//#region src/commands/auth/auth.constants.ts
+const CLI_AUTH_COMMAND = "keystroke auth";
+const CALLBACK_LOOPBACK_HOST = "127.0.0.1";
+const CALLBACK_PATH = "/callback";
+const CALLBACK_LOOPBACK_ORIGIN = `http://${CALLBACK_LOOPBACK_HOST}`;
+const AUTH_TIMEOUT_SECONDS = {
+	min: 30,
+	max: 900,
+	default: 180
+};
+const AUTH_URL_PATH = "/auth/device";
+//#endregion
+//#region src/lib/error-utils.ts
+/** Extract a human-readable message from any error value. */
+function toErrorMessage(error) {
+	if (error instanceof Error) return error.message;
+	return String(error);
+}
+/**
+* Builds a combined string from error.message + error.cause.message + error.cause.code
+* for broad pattern matching against network/auth keywords.
+*/
+function getFullErrorMessage(error) {
+	const parts = [toErrorMessage(error)];
+	if (error instanceof Error && error.cause) {
+		const c = error.cause;
+		if (typeof c?.message === "string") parts.push(c.message);
+		if (typeof c?.code === "string") parts.push(c.code);
+	}
+	return parts.join(" ").toLowerCase();
+}
+const NETWORK_ERROR_PATTERNS = [
+	"network",
+	"fetch",
+	"econnrefused",
+	"econnreset",
+	"enotfound",
+	"etimedout",
+	"timeout",
+	"timed out",
+	"connection refused",
+	"unable to reach",
+	"unable to connect",
+	"getaddrinfo",
+	"failed to fetch",
+	"connection reset",
+	"is the computer"
+];
+const AUTH_ERROR_PATTERNS = [
+	"401",
+	"unauthorized",
+	"403",
+	"forbidden",
+	"expired",
+	"invalid api key",
+	"invalid token",
+	"invalid credentials",
+	"invalid authentication"
+];
+/** True when the error looks like a network/connection failure rather than an API response. */
+function isNetworkError(error) {
+	const status = getHttpStatus(error);
+	if (status !== null) {
+		if (status === 502 || status === 503 || status === 504) return true;
+		return false;
+	}
+	const msg = getFullErrorMessage(error);
+	return NETWORK_ERROR_PATTERNS.some((p) => msg.includes(p));
+}
+/** True when the error indicates an authentication/authorization failure (401, 403, expired key, etc.). */
+function isAuthError(error) {
+	const status = getHttpStatus(error);
+	if (status !== null) return status === 401 || status === 403;
+	const msg = toErrorMessage(error).toLowerCase();
+	return AUTH_ERROR_PATTERNS.some((p) => msg.includes(p));
+}
+/** The hint message shown when auth fails. */
+const AUTH_HINT = `Run \`${CLI_AUTH_COMMAND}\` to authenticate.`;
+/** The hint message shown when auth needs re-authentication. */
+const REAUTH_HINT = `Run \`${CLI_AUTH_COMMAND}\` to re-authenticate.`;
+function isHttpError(error) {
+	if (typeof error !== "object" || error === null || !("response" in error)) return false;
+	const resp = error.response;
+	if (typeof resp !== "object" || resp === null) return false;
+	return typeof resp.status === "number";
+}
+function getHttpStatus(error) {
+	if (!isHttpError(error)) return null;
+	return error.response.status;
+}
+async function getApiErrorCode(error) {
+	if (!isHttpError(error)) return null;
+	if (typeof error.response.clone !== "function") return null;
+	try {
+		const body = await error.response.clone().json();
+		return typeof body.errorCode === "string" ? body.errorCode : null;
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/lib/tty.ts
+function isTTY() {
+	return process.stdout.isTTY === true;
+}
+//#endregion
+//#region src/lib/terminal.ts
+const ANSI = {
+	reset: "\x1B[0m",
+	bold: "\x1B[1m",
+	dim: "\x1B[2m",
+	red: "\x1B[31m",
+	cyan: "\x1B[36m",
+	green: "\x1B[32m",
+	yellow: "\x1B[33m"
+};
+function style(text, color) {
+	if (!isTTY()) return text;
+	return `${color}${text}${ANSI.reset}`;
+}
+//#endregion
+//#region src/lib/logger.ts
+/**
+* Original console methods, saved before any patching.
+* Used by ui.ts to always write to the real terminal regardless of capture.
+*/
+const originalConsole = {
+	log: console.log.bind(console),
+	info: console.info.bind(console),
+	warn: console.warn.bind(console),
+	error: console.error.bind(console),
+	debug: console.debug.bind(console)
+};
+let stream = null;
+let debugMode = false;
+/** When true, do not open or write the log file (avoids races after {@link logger.close}). */
+let loggingClosed = false;
+const KEYSTROKE_CREDENTIALS_DIR = ".keystroke";
+const KEYSTROKE_LOGS_DIR = "logs";
+const KEYSTROKE_LOG_FILE = "cli.jsonl";
+const MAX_LOG_LINES = 25e4;
+const MAX_PRUNE_READ_BYTES = 32 * 1024 * 1024;
+const DEBUG_PREFIXES = {
+	debug: "[DEBUG]",
+	info: "[INFO]",
+	warn: "[WARN]",
+	error: "[ERROR]"
+};
+const LEVEL_MAP = {
+	log: "info",
+	info: "info",
+	warn: "warn",
+	error: "error",
+	debug: "debug"
+};
+function ensureStream() {
+	if (loggingClosed) return null;
+	if (!stream) {
+		const logFilePath = getLogFilePath();
+		fs.mkdirSync(path$1.dirname(logFilePath), { recursive: true });
+		stream = fs.createWriteStream(logFilePath, { flags: "a" });
+		stream.on("error", () => {});
+	}
+	return stream;
+}
+function getLogFilePath(homeDir = os.homedir()) {
+	return path$1.join(homeDir, KEYSTROKE_CREDENTIALS_DIR, KEYSTROKE_LOGS_DIR, KEYSTROKE_LOG_FILE);
+}
+async function readTailForPrune(filePath) {
+	const handle = await fsPromises.open(filePath, "r");
+	try {
+		const stats = await handle.stat();
+		const bytesToRead = Math.min(stats.size, MAX_PRUNE_READ_BYTES);
+		if (bytesToRead <= 0) return "";
+		const start = Math.max(0, stats.size - bytesToRead);
+		const buffer = Buffer.alloc(bytesToRead);
+		const { bytesRead } = await handle.read(buffer, 0, bytesToRead, start);
+		let content = buffer.subarray(0, bytesRead).toString("utf8");
+		if (start > 0) {
+			const firstNewline = content.indexOf("\n");
+			if (firstNewline === -1) return "";
+			content = content.slice(firstNewline + 1);
+		}
+		return content;
+	} finally {
+		await handle.close();
+	}
+}
+async function pruneLogFile() {
+	const filePath = getLogFilePath();
+	let content;
+	try {
+		content = await readTailForPrune(filePath);
+	} catch {
+		return;
+	}
+	const lines = content.split("\n");
+	if (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+	if (lines.length <= MAX_LOG_LINES) return;
+	const kept = lines.slice(lines.length - MAX_LOG_LINES);
+	await fsPromises.writeFile(filePath, `${kept.join("\n")}\n`);
+}
+function formatTimestamp() {
+	const now = /* @__PURE__ */ new Date();
+	return `${String(now.getHours()).padStart(2, "0")}:${String(now.getMinutes()).padStart(2, "0")}:${String(now.getSeconds()).padStart(2, "0")}.${String(now.getMilliseconds()).padStart(3, "0")}`;
+}
+function write(level, message, meta) {
+	if (loggingClosed) return;
+	const entry = {
+		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+		level,
+		message,
+		...meta !== void 0 ? { meta } : {}
+	};
+	const s = ensureStream();
+	if (s && !s.destroyed && s.writable) try {
+		s.write(`${JSON.stringify(entry)}\n`);
+	} catch {}
+	if (debugMode) {
+		const ts = formatTimestamp();
+		const prefix = DEBUG_PREFIXES[level];
+		const formatted = meta ? `${ts} ${prefix} ${message} ${JSON.stringify(meta)}` : `${ts} ${prefix} ${message}`;
+		originalConsole.info(style(formatted, ANSI.dim));
+	}
+}
+/**
+* Patches global console methods to capture output from third-party
+* and workspace packages. Captured output is always written to the
+* log file and only forwarded to the real console when --debug is active.
+*/
+function installConsoleCapture() {
+	for (const method of [
+		"log",
+		"info",
+		"warn",
+		"error",
+		"debug"
+	]) {
+		const level = LEVEL_MAP[method] ?? "info";
+		const original = originalConsole[method];
+		console[method] = (...args) => {
+			write(level, `[captured] ${args.map(String).join(" ")}`);
+			if (debugMode) original(...args);
+		};
+	}
+}
+/**
+* Initialize the logger: install console capture and prune the log file.
+* Call once at CLI startup.
+*/
+function initLogger() {
+	installConsoleCapture();
+	pruneLogFile().catch((error) => {
+		if (process.env.KEYSTROKE_DEBUG_LOGGER === "1") {
+			const message = error instanceof Error ? error.message : String(error);
+			originalConsole.warn(`[logger] Failed to prune CLI log file: ${message}`);
+		}
+	});
+}
+const logger = {
+	debug: (msg, meta) => write("debug", msg, meta),
+	info: (msg, meta) => write("info", msg, meta),
+	warn: (msg, meta) => write("warn", msg, meta),
+	error: (msg, meta) => write("error", msg, meta),
+	/** Enable or disable debug mode (shows all log entries in the console). */
+	setDebug(enabled) {
+		debugMode = enabled;
+	},
+	/** Stop accepting log writes and tear down the log file stream. */
+	close() {
+		loggingClosed = true;
+		if (stream) {
+			stream.end();
+			stream = null;
+		}
+	}
+};
+//#endregion
+//#region src/lib/cli-telemetry.ts
+const TELEMETRY_TIMEOUT_MS = 2500;
+let state = null;
+let lastFailureError;
+function isTruthyEnv(v) {
+	return v === "1" || v?.toLowerCase() === "true";
+}
+/**
+* Opt-in CLI telemetry. In CI, only `KEYSTROKE_TELEMETRY=1` enables (not `true`).
+*/
+function isCliTelemetryEnabled() {
+	const procEnv = process.env;
+	const raw = procEnv.KEYSTROKE_TELEMETRY;
+	if (!isTruthyEnv(raw)) return false;
+	if ((procEnv.CI === "true" || procEnv.CI === "1") && raw !== "1") return false;
+	return true;
+}
+/** Exported for unit tests — stable dotted command id (e.g. `keystroke.workflows.deploy`). */
+function cliTelemetryCommandPath(cmd) {
+	const parts = [];
+	let current = cmd;
+	while (current) {
+		const name = current.name();
+		if (name) parts.unshift(name);
+		current = current.parent ?? null;
+	}
+	const path = parts.join(".");
+	return path.length > 0 ? path : "keystroke";
+}
+function registerCliTelemetryHooks(program) {
+	program.hook("preAction", (_thisCommand, actionCommand) => {
+		beginCliTelemetryRun(cliTelemetryCommandPath(actionCommand));
+	});
+}
+function captureCliTelemetryFailure(error) {
+	lastFailureError = error;
+}
+function beginCliTelemetryRun(command) {
+	state = {
+		startMs: Date.now(),
+		command
+	};
+	lastFailureError = void 0;
+}
+function captureCliTelemetryResolvedContext(ctx) {
+	if (!state) return;
+	state.apiKey = ctx.apiKey;
+	state.baseUrl = ctx.baseUrl;
+	state.organizationId = ctx.organizationId;
+}
+function nodeRuntimeLabel() {
+	if (process.versions.bun) return `bun/${process.versions.bun}`;
+	return `node/${process.version}`;
+}
+/** Maps thrown values to coarse telemetry error families (no raw messages in payload). */
+function cliTelemetryErrorFamilyFromError(error) {
+	if (error instanceof AuthenticationError) return "auth";
+	const candidate = error instanceof CliExitError && error.cause !== void 0 ? error.cause : error;
+	if (candidate instanceof AuthenticationError) return "auth";
+	if (isNetworkError(candidate)) return "network";
+	if (isAuthError(candidate)) return "auth";
+	const msg = toErrorMessage(candidate).toLowerCase();
+	if (candidate instanceof CliExitError && (msg.includes("cancel") || msg.includes("abort"))) return "user_abort";
+	if (msg.includes("not found") || msg.includes("404")) return "not_found";
+	if (msg.includes("invalid") || msg.includes("validation") || msg.includes("zod")) return "validation";
+	if (candidate !== void 0) return "unknown";
+}
+async function sendTelemetryEvent(body, ctx) {
+	const url = `${ctx.baseUrl.replace(/\/$/, "")}/api/v1/cli/telemetry`;
+	const headers = {
+		"Content-Type": "application/json",
+		Authorization: `Bearer ${ctx.apiKey}`
+	};
+	if (ctx.organizationId && /^[0-9a-f-]{36}$/i.test(ctx.organizationId)) headers["X-Organization-Id"] = ctx.organizationId;
+	const controller = new AbortController();
+	const timeout = setTimeout(() => controller.abort(), TELEMETRY_TIMEOUT_MS);
+	try {
+		const res = await fetch(url, {
+			method: "POST",
+			headers,
+			body: JSON.stringify(body),
+			signal: controller.signal
+		});
+		if (!res.ok) logger.debug("CLI telemetry request failed", { status: res.status });
+	} catch (error) {
+		logger.debug("CLI telemetry send error", { error: toErrorMessage(error) });
+	} finally {
+		clearTimeout(timeout);
+	}
+}
+async function flushCliTelemetryForExit(exitCode) {
+	if (!isCliTelemetryEnabled() || !state) return;
+	const { apiKey, baseUrl, organizationId } = state;
+	if (!apiKey || !baseUrl) return;
+	const durationMs = Math.max(0, Date.now() - state.startMs);
+	const payload = {
+		event: "cli.command.completed",
+		cliVersion: version,
+		command: state.command,
+		exitCode,
+		durationMs,
+		os: process.platform,
+		arch: process.arch,
+		nodeRuntime: nodeRuntimeLabel()
+	};
+	if (exitCode !== 0) {
+		const family = cliTelemetryErrorFamilyFromError(lastFailureError);
+		if (family) payload.errorFamily = family;
+	}
+	await sendTelemetryEvent(payload, {
+		baseUrl,
+		apiKey,
+		organizationId
+	});
+}
+z.object({
+	apiKey: z.string().optional(),
+	baseUrl: z.string().optional(),
+	debug: z.boolean().optional(),
+	org: z.string().optional()
+});
+const GLOBAL_OPTIONS_CONFIG = {
+	apiKey: {
+		flag: "--api-key <key>",
+		description: "Keystroke API Key (overrides KEYSTROKE_API_KEY env)"
+	},
+	baseUrl: {
+		flag: "--base-url <url>",
+		description: "Keystroke API URL (overrides SERVER_URL env)"
+	},
+	debug: {
+		flag: "--debug",
+		description: "Show all diagnostic logs in the console"
+	},
+	org: {
+		flag: "--org <id>",
+		description: "Organization ID (overrides KEYSTROKE_ORG_ID and stored credentials)"
+	}
+};
+/**
+* Creates fresh hidden Option instances for a subcommand.
+*
+* With `enablePositionalOptions` on the root program, Commander only parses
+* options declared on the command they appear after. This factory lets every
+* subcommand accept global flags at any position without showing them in
+* per-command --help output.
+*
+* Returns new instances each call to avoid shared mutable state.
+*/
+function createHiddenGlobalOptions() {
+	return Object.values(GLOBAL_OPTIONS_CONFIG).map((cfg) => new Option(cfg.flag).hideHelp());
+}
+//#endregion
+//#region src/lib/ui.ts
+const ui = {
+	/** Blank line separator */
+	br: () => {
+		originalConsole.info("");
+		logger.info("");
+	},
+	/** Primary informational text — raw, no prefix (used for tables, structured output) */
+	text: (msg) => {
+		originalConsole.info(msg);
+		logger.info(msg);
+	},
+	/** Section header */
+	header: (msg) => {
+		log.info(msg);
+		logger.info(msg);
+	},
+	/** Success message */
+	success: (msg) => {
+		log.success(msg);
+		logger.info(msg);
+	},
+	/** Warning message */
+	warn: (msg) => {
+		log.warn(msg);
+		logger.warn(msg);
+	},
+	/** Error message */
+	error: (msg) => {
+		log.error(msg);
+		logger.error(msg);
+	},
+	/** Secondary/hint text */
+	hint: (msg) => {
+		log.message(msg);
+		logger.info(msg);
+	}
+};
+//#endregion
+//#region src/index.ts
+/**
+* Keystroke CLI Entry Point
+*/
+function getRunMode() {
+	const url = import.meta.url;
+	return url.includes("/dist/") || url.endsWith(".mjs") ? "built" : "source";
+}
+async function flushWritableStream(stream) {
+	if (stream.destroyed || !stream.writable) return;
+	await new Promise((resolve) => {
+		stream.write("", () => resolve());
+	});
+}
+async function allowBufferedOutputToFlush() {
+	await Promise.all([flushWritableStream(process.stdout), flushWritableStream(process.stderr)]);
+	await new Promise((resolve) => setTimeout(resolve, 0));
+}
+function shouldLogCliStartup(argv) {
+	return argv[0] !== "logs";
+}
+function resolveCliExitCode(error) {
+	if (error instanceof CommanderError) return error.exitCode;
+	if (error instanceof CliExitError) return error.exitCode;
+	return 1;
+}
+async function runCli() {
+	initLogger();
+	if (process.argv.includes("--debug")) logger.setDebug(true);
+	if (shouldLogCliStartup(process.argv.slice(2))) logger.info("CLI started", {
+		argv: process.argv.slice(2),
+		runMode: getRunMode()
+	});
+	const program = new Command().name("keystroke").description("Keystroke CLI - Headless workflow management").version(version).enablePositionalOptions();
+	program.exitOverride();
+	for (const cfg of Object.values(GLOBAL_OPTIONS_CONFIG)) program.option(cfg.flag, cfg.description);
+	await registerCommandsForArgv(program, process.argv.slice(2));
+	registerCliTelemetryHooks(program);
+	await program.parseAsync(process.argv);
+}
+async function main() {
+	let exitCode = 0;
+	let failure;
+	try {
+		await runCli();
+	} catch (error) {
+		exitCode = resolveCliExitCode(error);
+		failure = error;
+		if (!(error instanceof CliExitError) && !(error instanceof CommanderError)) ui.error(`Error: ${toErrorMessage(error)}`);
+	}
+	if (failure) captureCliTelemetryFailure(failure);
+	await flushCliTelemetryForExit(exitCode);
+	await allowBufferedOutputToFlush();
+	await new Promise((resolve) => {
+		setImmediate(resolve);
+	});
+	logger.close();
+	process.exit(exitCode);
+}
+main();
+//#endregion
+export { CliExitError as C, throwReportedCliExit as D, WorkflowResolutionError as E, AuthenticationError as S, ProjectNotFoundError as T, AUTH_URL_PATH as _, originalConsole as a, CALLBACK_PATH as b, isTTY as c, getApiErrorCode as d, getHttpStatus as f, AUTH_TIMEOUT_SECONDS as g, toErrorMessage as h, logger as i, AUTH_HINT as l, isNetworkError as m, createHiddenGlobalOptions as n, ANSI as o, isAuthError as p, captureCliTelemetryResolvedContext as r, style as s, ui as t, REAUTH_HINT as u, CALLBACK_LOOPBACK_HOST as v, InputValidationError as w, CLI_AUTH_COMMAND as x, CALLBACK_LOOPBACK_ORIGIN as y };