@prospera/eprospera-cli 0.1.0

package/dist/src/commands/runtime.d.ts

@@ -0,0 +1,56 @@
+import { readFile } from "node:fs/promises";
+import { type ZodType, z } from "zod";
+import { type EProsperaApiClient, type RetryOptions } from "../api/client.js";
+import { type CliConfig, type ConfigStoreOptions } from "../config/store.js";
+import { type ResolveCredentialOptions } from "../credentials/resolve.js";
+import type { CredentialSource, ResolvedCredential, StoredCredential } from "../credentials/types.js";
+import { type OutputStreams, type PrintOptions } from "../output/format.js";
+export type GlobalOptions = {
+    json?: boolean;
+    raw?: boolean;
+    fields?: string;
+    quiet?: boolean;
+    yes?: boolean;
+    apiKey?: string;
+    dryRun?: boolean;
+    autoJson?: boolean;
+    skipScopeCheck?: boolean;
+};
+export type RuntimeDependencies = {
+    env?: NodeJS.ProcessEnv;
+    fetch?: (input: Request) => Promise<Response>;
+    retry?: RetryOptions;
+    idempotencyKey?: () => string;
+    streams?: OutputStreams;
+    cwd?: string;
+    readFile?: typeof readFile;
+    now?: () => number;
+    sleep?: (ms: number) => Promise<void>;
+    loadStoredCredential?: ResolveCredentialOptions["loadStoredCredential"];
+    saveStoredCredential?: (credential: StoredCredential) => Promise<CredentialSource>;
+    deleteStoredCredential?: () => Promise<boolean>;
+    configStore?: ConfigStoreOptions;
+    promptPassword?: (message: string) => Promise<string>;
+    promptInput?: (message: string) => Promise<string>;
+    promptConfirm?: (message: string) => Promise<boolean>;
+};
+export type AuthenticatedContext = {
+    api: EProsperaApiClient;
+    credential: ResolvedCredential;
+    output: PrintOptions;
+    globals: GlobalOptions;
+};
+export declare const uuidSchema: z.ZodString;
+export declare const nonEmptyStringSchema: z.ZodString;
+export declare const rpnSchema: z.ZodString;
+export declare function authenticatedContext(commandId: string, globals: GlobalOptions, deps?: RuntimeDependencies): Promise<AuthenticatedContext>;
+export declare function outputOptions(globals: GlobalOptions, deps?: RuntimeDependencies): PrintOptions;
+export declare function resolveRuntimeBaseUrl(env: NodeJS.ProcessEnv, config: CliConfig): string;
+export declare function configStoreOptions(deps?: RuntimeDependencies): ConfigStoreOptions;
+export declare function parseInput<T>(schema: ZodType<T>, value: unknown): T;
+export declare function readJsonFile<T>(filePath: string, schema: ZodType<T>, deps?: RuntimeDependencies): Promise<T>;
+export declare function printDryRun(request: {
+    method: string;
+    path: string;
+    body?: unknown;
+}, globals: GlobalOptions, deps?: RuntimeDependencies): void;

package/dist/src/commands/runtime.js

@@ -0,0 +1,101 @@
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { z } from "zod";
+import { createApiClient, resolveBaseUrl, } from "../api/client.js";
+import { loadConfig } from "../config/store.js";
+import { resolveCredential } from "../credentials/resolve.js";
+import { ExitCodes, ExitError } from "../errors.js";
+import { print } from "../output/format.js";
+import { assertCommandScope } from "../scopes/check.js";
+export const uuidSchema = z.string().uuid();
+export const nonEmptyStringSchema = z.string().trim().min(1);
+export const rpnSchema = z
+    .string()
+    .regex(/^[89]\d{13}$/, "RPN must be 14 digits starting with 8 or 9.");
+export async function authenticatedContext(commandId, globals, deps = {}) {
+    const env = deps.env ?? process.env;
+    const config = await loadConfig(configStoreOptions(deps));
+    const credential = await resolveCredential({
+        apiKey: globals.apiKey,
+        env,
+        store: configStoreOptions(deps),
+        loadStoredCredential: deps.loadStoredCredential,
+    });
+    assertCommandScope(commandId, credential, { skipScopeCheck: globals.skipScopeCheck });
+    return {
+        api: createApiClient({
+            baseUrl: resolveRuntimeBaseUrl(env, config),
+            env,
+            token: credential.token,
+            fetch: deps.fetch,
+            retry: deps.retry,
+            idempotencyKey: deps.idempotencyKey,
+        }),
+        credential,
+        output: outputOptions(globals, deps),
+        globals,
+    };
+}
+export function outputOptions(globals, deps = {}) {
+    return {
+        json: globals.json,
+        raw: globals.raw,
+        fields: globals.fields,
+        quiet: globals.quiet,
+        noAutoJson: globals.autoJson === false,
+        env: deps.env,
+        streams: deps.streams,
+    };
+}
+export function resolveRuntimeBaseUrl(env, config) {
+    if (env.EPROSPERA_BASE_URL?.trim()) {
+        return resolveBaseUrl(env);
+    }
+    if (config["api.baseUrl"]) {
+        return trimTrailingSlash(config["api.baseUrl"]);
+    }
+    return resolveBaseUrl(env);
+}
+export function configStoreOptions(deps = {}) {
+    const store = deps.configStore ?? {};
+    return {
+        ...store,
+        env: store.env ?? deps.env,
+    };
+}
+export function parseInput(schema, value) {
+    const result = schema.safeParse(value);
+    if (result.success) {
+        return result.data;
+    }
+    throw new ExitError({
+        code: "INVALID_USAGE",
+        message: result.error.issues.map((issue) => issue.message).join("; "),
+        exitCode: ExitCodes.Usage,
+        details: result.error.issues,
+    });
+}
+export async function readJsonFile(filePath, schema, deps = {}) {
+    const reader = deps.readFile ?? readFile;
+    const absolutePath = resolve(deps.cwd ?? process.cwd(), filePath);
+    let parsed;
+    try {
+        parsed = JSON.parse(await reader(absolutePath, "utf8"));
+    }
+    catch (error) {
+        throw new ExitError({
+            code: "INVALID_JSON_FILE",
+            message: `Could not read valid JSON from ${filePath}.`,
+            exitCode: ExitCodes.Validation,
+            cause: error,
+        });
+    }
+    return parseInput(schema, parsed);
+}
+export function printDryRun(request, globals, deps = {}) {
+    print({ dryRun: true, request }, outputOptions(globals, deps));
+}
+function trimTrailingSlash(value) {
+    return value.replace(/\/+$/, "");
+}
+//# sourceMappingURL=runtime.js.map

package/dist/src/commands/schema.d.ts

@@ -0,0 +1,2 @@
+import { type GlobalOptions, type RuntimeDependencies } from "./runtime.js";
+export declare function runSchema(globals: GlobalOptions, deps?: RuntimeDependencies): Promise<void>;

package/dist/src/commands/schema.js

@@ -0,0 +1,13 @@
+import { parse } from "yaml";
+import { print } from "../output/format.js";
+import { readPackageFile } from "./files.js";
+import { outputOptions } from "./runtime.js";
+export async function runSchema(globals, deps = {}) {
+    const source = await readPackageFile("cli.ocs.yaml", import.meta.url);
+    if (globals.json || globals.raw) {
+        print(parse(source), outputOptions(globals, deps));
+        return;
+    }
+    (deps.streams?.stdout ?? process.stdout).write(source.endsWith("\n") ? source : `${source}\n`);
+}
+//# sourceMappingURL=schema.js.map

package/dist/src/config/store.d.ts

@@ -0,0 +1,14 @@
+export declare const CONFIG_SERVICE = "eprospera-cli";
+export declare const CONFIG_FILE_NAME = "config.json";
+export declare const SUPPORTED_CONFIG_KEYS: readonly ["api.baseUrl"];
+export type ConfigKey = (typeof SUPPORTED_CONFIG_KEYS)[number];
+export type CliConfig = Partial<Record<ConfigKey, string>>;
+export type ConfigStoreOptions = {
+    env?: NodeJS.ProcessEnv;
+    homeDir?: string;
+};
+export declare function loadConfig(options?: ConfigStoreOptions): Promise<CliConfig>;
+export declare function setConfigValue(key: ConfigKey, value: string, options?: ConfigStoreOptions): Promise<CliConfig>;
+export declare function unsetConfigValue(key: ConfigKey, options?: ConfigStoreOptions): Promise<boolean>;
+export declare function assertConfigKey(value: string): ConfigKey;
+export declare function getConfigFilePath(options?: ConfigStoreOptions): string;

package/dist/src/config/store.js

@@ -0,0 +1,99 @@
+import { constants } from "node:fs";
+import { access, chmod, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { z } from "zod";
+import { ExitCodes, ExitError } from "../errors.js";
+export const CONFIG_SERVICE = "eprospera-cli";
+export const CONFIG_FILE_NAME = "config.json";
+export const SUPPORTED_CONFIG_KEYS = ["api.baseUrl"];
+const configSchema = z
+    .object({
+    "api.baseUrl": z.string().url().optional(),
+})
+    .strict();
+export async function loadConfig(options = {}) {
+    const filePath = getConfigFilePath(options);
+    let text;
+    try {
+        text = await readFile(filePath, "utf8");
+    }
+    catch (error) {
+        if (isNodeError(error) && error.code === "ENOENT") {
+            return {};
+        }
+        throw configError("CONFIG_UNREADABLE", "Local configuration could not be read.", error);
+    }
+    try {
+        return configSchema.parse(JSON.parse(text));
+    }
+    catch (error) {
+        throw configError("CONFIG_INVALID", "Local configuration is invalid.", error);
+    }
+}
+export async function setConfigValue(key, value, options = {}) {
+    const next = { ...(await loadConfig(options)), [key]: value };
+    await saveConfig(configSchema.parse(next), options);
+    return next;
+}
+export async function unsetConfigValue(key, options = {}) {
+    const current = await loadConfig(options);
+    const existed = key in current;
+    delete current[key];
+    if (Object.keys(current).length === 0) {
+        await deleteConfig(options);
+    }
+    else {
+        await saveConfig(current, options);
+    }
+    return existed;
+}
+export function assertConfigKey(value) {
+    if (SUPPORTED_CONFIG_KEYS.includes(value)) {
+        return value;
+    }
+    throw new ExitError({
+        code: "INVALID_CONFIG_KEY",
+        message: `Unsupported config key ${value}. Supported keys: ${SUPPORTED_CONFIG_KEYS.join(", ")}.`,
+        exitCode: ExitCodes.Usage,
+    });
+}
+export function getConfigFilePath(options = {}) {
+    return join(getConfigDir(options), CONFIG_FILE_NAME);
+}
+function getConfigDir(options = {}) {
+    const xdgConfigHome = options.env?.XDG_CONFIG_HOME?.trim();
+    return join(xdgConfigHome || join(options.homeDir ?? homedir(), ".config"), CONFIG_SERVICE);
+}
+async function saveConfig(config, options) {
+    const filePath = getConfigFilePath(options);
+    await mkdir(dirname(filePath), { recursive: true, mode: 0o700 });
+    await chmod(dirname(filePath), 0o700);
+    await writeFile(filePath, `${JSON.stringify(config, null, 2)}\n`, { mode: 0o600 });
+    await chmod(filePath, 0o600);
+}
+async function deleteConfig(options) {
+    const filePath = getConfigFilePath(options);
+    try {
+        await access(filePath, constants.F_OK);
+        await rm(filePath);
+    }
+    catch (error) {
+        if (isNodeError(error) && error.code === "ENOENT") {
+            return;
+        }
+        throw configError("CONFIG_UNWRITABLE", "Local configuration could not be updated.", error);
+    }
+}
+function configError(code, message, cause) {
+    return new ExitError({
+        code,
+        message,
+        exitCode: code === "CONFIG_INVALID" ? ExitCodes.Validation : ExitCodes.Generic,
+        cause,
+    });
+}
+function isNodeError(value) {
+    return value instanceof Error && "code" in value;
+}
+//# sourceMappingURL=store.js.map

package/dist/src/credentials/resolve.d.ts

@@ -0,0 +1,15 @@
+import { type CredentialStoreOptions } from "./store.js";
+import type { CredentialKind, ResolvedCredential, StoredCredential } from "./types.js";
+type LoadableCredential = StoredCredential & {
+    source?: Extract<ResolvedCredential["source"], "keytar" | "file">;
+};
+export type ResolveCredentialOptions = {
+    apiKey?: string;
+    env?: NodeJS.ProcessEnv;
+    now?: () => number;
+    store?: CredentialStoreOptions;
+    loadStoredCredential?: () => Promise<LoadableCredential | undefined>;
+};
+export declare function resolveCredential(options?: ResolveCredentialOptions): Promise<ResolvedCredential>;
+export declare function inferCredentialKind(token: string): CredentialKind;
+export {};

package/dist/src/credentials/resolve.js

@@ -0,0 +1,63 @@
+import { ExitCodes, ExitError } from "../errors.js";
+import { loadCredential } from "./store.js";
+export async function resolveCredential(options = {}) {
+    const env = options.env ?? process.env;
+    const flagToken = normalizeToken(options.apiKey);
+    if (flagToken) {
+        return credentialFromToken(flagToken, "flag");
+    }
+    const envToken = normalizeToken(env.EPROSPERA_API_KEY);
+    if (envToken) {
+        return credentialFromToken(envToken, "env");
+    }
+    const stored = await loadStoredCredential(options);
+    if (!stored) {
+        throw new ExitError({
+            code: "NO_CREDENTIAL",
+            message: "No API credential configured. Pass --api-key, set EPROSPERA_API_KEY, or run eprospera auth login.",
+            exitCode: ExitCodes.Authentication,
+        });
+    }
+    if (isExpired(stored, options.now ?? Date.now)) {
+        throw new ExitError({
+            code: "EXPIRED_CREDENTIAL",
+            message: "Stored credential has expired. Run eprospera auth login again.",
+            exitCode: ExitCodes.Authentication,
+        });
+    }
+    return {
+        ...stored,
+        source: stored.source ?? "keytar",
+    };
+}
+export function inferCredentialKind(token) {
+    if (token.startsWith("ak-")) {
+        return "ak";
+    }
+    if (token.startsWith("sk-")) {
+        return "sk";
+    }
+    return "sk";
+}
+function credentialFromToken(token, source) {
+    return {
+        kind: inferCredentialKind(token),
+        token,
+        scopes: [],
+        source,
+    };
+}
+async function loadStoredCredential(options) {
+    if (options.loadStoredCredential) {
+        return options.loadStoredCredential();
+    }
+    return loadCredential(options.store);
+}
+function normalizeToken(value) {
+    const token = value?.trim();
+    return token && token.length > 0 ? token : undefined;
+}
+function isExpired(credential, now) {
+    return credential.expiresAt !== undefined && credential.expiresAt <= now();
+}
+//# sourceMappingURL=resolve.js.map

package/dist/src/credentials/store.d.ts

@@ -0,0 +1,22 @@
+import { type CredentialSource, type StoredCredential } from "./types.js";
+export declare const CREDENTIAL_SERVICE = "eprospera-cli";
+export declare const CREDENTIAL_ACCOUNT = "default";
+export declare const CREDENTIAL_FILE_NAME = "credentials.json";
+export type KeytarAdapter = {
+    getPassword(service: string, account: string): Promise<string | null>;
+    setPassword(service: string, account: string, password: string): Promise<void>;
+    deletePassword(service: string, account: string): Promise<boolean>;
+};
+export type CredentialStoreOptions = {
+    env?: NodeJS.ProcessEnv;
+    homeDir?: string;
+    keytar?: KeytarAdapter | null;
+};
+export type LoadedCredential = StoredCredential & {
+    source: Extract<CredentialSource, "keytar" | "file">;
+};
+export declare function loadCredential(options?: CredentialStoreOptions): Promise<LoadedCredential | undefined>;
+export declare function saveCredential(credential: StoredCredential, options?: CredentialStoreOptions): Promise<CredentialSource>;
+export declare function deleteCredential(options?: CredentialStoreOptions): Promise<boolean>;
+export declare function getCredentialConfigDir(options?: CredentialStoreOptions): string;
+export declare function getCredentialFilePath(options?: CredentialStoreOptions): string;

package/dist/src/credentials/store.js

@@ -0,0 +1,184 @@
+import { constants } from "node:fs";
+import { access, chmod, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { ExitCodes, ExitError } from "../errors.js";
+import { isCredentialKind } from "./types.js";
+export const CREDENTIAL_SERVICE = "eprospera-cli";
+export const CREDENTIAL_ACCOUNT = "default";
+export const CREDENTIAL_FILE_NAME = "credentials.json";
+export async function loadCredential(options = {}) {
+    const keytar = await resolveKeytar(options);
+    if (keytar) {
+        const encoded = await loadKeytarCredential(keytar);
+        if (encoded) {
+            return { ...parseStoredCredential(encoded, "keytar"), source: "keytar" };
+        }
+    }
+    const encoded = await loadFileCredential(options);
+    return encoded ? { ...parseStoredCredential(encoded, "file"), source: "file" } : undefined;
+}
+export async function saveCredential(credential, options = {}) {
+    const encoded = `${JSON.stringify(normalizeStoredCredential(credential), null, 2)}\n`;
+    const keytar = await resolveKeytar(options);
+    if (keytar) {
+        try {
+            await keytar.setPassword(CREDENTIAL_SERVICE, CREDENTIAL_ACCOUNT, encoded);
+            await deleteFileCredential(options);
+            return "keytar";
+        }
+        catch {
+            // Fall through to the plaintext store when the OS keychain is unavailable.
+        }
+    }
+    await saveFileCredential(encoded, options);
+    return "file";
+}
+export async function deleteCredential(options = {}) {
+    let deleted = false;
+    const keytar = await resolveKeytar(options);
+    if (keytar) {
+        try {
+            deleted = (await keytar.deletePassword(CREDENTIAL_SERVICE, CREDENTIAL_ACCOUNT)) || deleted;
+        }
+        catch {
+            // Still attempt to clean up the fallback file.
+        }
+    }
+    return (await deleteFileCredential(options)) || deleted;
+}
+export function getCredentialConfigDir(options = {}) {
+    const xdgConfigHome = options.env?.XDG_CONFIG_HOME?.trim();
+    return join(xdgConfigHome || join(options.homeDir ?? homedir(), ".config"), CREDENTIAL_SERVICE);
+}
+export function getCredentialFilePath(options = {}) {
+    return join(getCredentialConfigDir(options), CREDENTIAL_FILE_NAME);
+}
+async function resolveKeytar(options) {
+    if (options.keytar !== undefined) {
+        return options.keytar ?? undefined;
+    }
+    try {
+        // Keep keytar optional in ncc bundles so standalone artifacts can use file fallback.
+        const keytarPackageName = ["keytar"].join("");
+        const keytarModule = (await import(keytarPackageName));
+        return unwrapKeytarModule(keytarModule);
+    }
+    catch {
+        return undefined;
+    }
+}
+function unwrapKeytarModule(module) {
+    if (isKeytarAdapter(module)) {
+        return module;
+    }
+    if (isRecord(module) && isKeytarAdapter(module.default)) {
+        return module.default;
+    }
+    return undefined;
+}
+async function loadKeytarCredential(keytar) {
+    try {
+        return (await keytar.getPassword(CREDENTIAL_SERVICE, CREDENTIAL_ACCOUNT)) ?? undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function loadFileCredential(options) {
+    const filePath = getCredentialFilePath(options);
+    try {
+        return await readFile(filePath, "utf8");
+    }
+    catch (error) {
+        if (isNodeError(error) && error.code === "ENOENT") {
+            return undefined;
+        }
+        throw credentialError("CREDENTIAL_STORE_UNREADABLE", "Stored credentials could not be read.", error);
+    }
+}
+async function saveFileCredential(encoded, options) {
+    const filePath = getCredentialFilePath(options);
+    await ensureCredentialDirectory(dirname(filePath));
+    await writeFile(filePath, encoded, { mode: 0o600 });
+    await chmod(filePath, 0o600);
+}
+async function deleteFileCredential(options) {
+    const filePath = getCredentialFilePath(options);
+    try {
+        await access(filePath, constants.F_OK);
+        await rm(filePath);
+        return true;
+    }
+    catch (error) {
+        if (isNodeError(error) && error.code === "ENOENT") {
+            return false;
+        }
+        throw credentialError("CREDENTIAL_STORE_UNWRITABLE", "Stored credentials could not be deleted.", error);
+    }
+}
+async function ensureCredentialDirectory(dirPath) {
+    await mkdir(dirPath, { recursive: true, mode: 0o700 });
+    await chmod(dirPath, 0o700);
+}
+function parseStoredCredential(encoded, source) {
+    let parsed;
+    try {
+        parsed = JSON.parse(encoded);
+    }
+    catch (error) {
+        throw credentialError("INVALID_CREDENTIAL", `Stored ${source} credential is not valid JSON.`, error);
+    }
+    return normalizeStoredCredential(parsed);
+}
+function normalizeStoredCredential(value) {
+    if (!isRecord(value) || !isCredentialKind(value.kind) || !nonEmptyString(value.token)) {
+        throw credentialError("INVALID_CREDENTIAL", "Stored credential is malformed. Run eprospera auth login again.");
+    }
+    return {
+        kind: value.kind,
+        token: value.token.trim(),
+        refreshToken: optionalString(value.refreshToken),
+        scopes: stringArray(value.scopes),
+        expiresAt: optionalFiniteNumber(value.expiresAt),
+        owner: optionalString(value.owner),
+    };
+}
+function credentialError(code, message, cause) {
+    return new ExitError({
+        code,
+        message,
+        exitCode: ExitCodes.Authentication,
+        cause,
+    });
+}
+function nonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function optionalString(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value : undefined;
+}
+function optionalFiniteNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function stringArray(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter((item) => typeof item === "string" && item.length > 0);
+}
+function isKeytarAdapter(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    return (typeof value.getPassword === "function" &&
+        typeof value.setPassword === "function" &&
+        typeof value.deletePassword === "function");
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+function isNodeError(value) {
+    return value instanceof Error && "code" in value;
+}
+//# sourceMappingURL=store.js.map

package/dist/src/credentials/types.d.ts

@@ -0,0 +1,15 @@
+export declare const CredentialKinds: readonly ["ak", "sk", "oauth"];
+export type CredentialKind = (typeof CredentialKinds)[number];
+export type StoredCredential = {
+    kind: CredentialKind;
+    token: string;
+    refreshToken?: string;
+    scopes: string[];
+    expiresAt?: number;
+    owner?: string;
+};
+export type CredentialSource = "flag" | "env" | "keytar" | "file";
+export type ResolvedCredential = StoredCredential & {
+    source: CredentialSource;
+};
+export declare function isCredentialKind(value: unknown): value is CredentialKind;

package/dist/src/credentials/types.js

@@ -0,0 +1,5 @@
+export const CredentialKinds = ["ak", "sk", "oauth"];
+export function isCredentialKind(value) {
+    return typeof value === "string" && CredentialKinds.includes(value);
+}
+//# sourceMappingURL=types.js.map

package/dist/src/errors.d.ts

@@ -0,0 +1,39 @@
+export declare const ExitCodes: {
+    readonly Success: 0;
+    readonly Generic: 1;
+    readonly Usage: 2;
+    readonly Authentication: 3;
+    readonly Authorization: 4;
+    readonly NotFound: 5;
+    readonly Conflict: 6;
+    readonly RateLimit: 7;
+    readonly Validation: 8;
+    readonly Timeout: 9;
+    readonly TerminalFailure: 10;
+};
+export type ExitCode = (typeof ExitCodes)[keyof typeof ExitCodes];
+export type ErrorDetails = unknown;
+export type ErrorEnvelope = {
+    error: {
+        code: string;
+        message: string;
+        httpStatus?: number;
+        details?: ErrorDetails;
+    };
+};
+export type ExitErrorOptions = {
+    code: string;
+    message: string;
+    exitCode: ExitCode;
+    httpStatus?: number;
+    details?: ErrorDetails;
+    cause?: unknown;
+};
+export declare class ExitError extends Error {
+    readonly code: string;
+    readonly exitCode: ExitCode;
+    readonly httpStatus?: number;
+    readonly details?: ErrorDetails;
+    constructor(options: ExitErrorOptions);
+    toEnvelope(): ErrorEnvelope;
+}

package/dist/src/errors.js

@@ -0,0 +1,38 @@
+export const ExitCodes = {
+    Success: 0,
+    Generic: 1,
+    Usage: 2,
+    Authentication: 3,
+    Authorization: 4,
+    NotFound: 5,
+    Conflict: 6,
+    RateLimit: 7,
+    Validation: 8,
+    Timeout: 9,
+    TerminalFailure: 10,
+};
+export class ExitError extends Error {
+    code;
+    exitCode;
+    httpStatus;
+    details;
+    constructor(options) {
+        super(options.message, { cause: options.cause });
+        this.name = "ExitError";
+        this.code = options.code;
+        this.exitCode = options.exitCode;
+        this.httpStatus = options.httpStatus;
+        this.details = options.details;
+    }
+    toEnvelope() {
+        return {
+            error: {
+                code: this.code,
+                message: this.message,
+                httpStatus: this.httpStatus,
+                details: this.details,
+            },
+        };
+    }
+}
+//# sourceMappingURL=errors.js.map

package/dist/src/index.d.ts

@@ -0,0 +1,4 @@
+import { Command } from "commander";
+import type { RuntimeDependencies } from "./commands/runtime.js";
+export declare function createProgram(deps?: RuntimeDependencies): Command;
+export declare function runCli(argv?: readonly string[], deps?: RuntimeDependencies): Promise<number>;