@prospera/eprospera-cli 0.1.0

package/dist/src/polling/watch.js

@@ -0,0 +1,86 @@
+import { ExitCodes, ExitError } from "../errors.js";
+const DEFAULT_TIMEOUT_MS = 30 * 60 * 1000;
+const DEFAULT_INITIAL_INTERVAL_MS = 30 * 1000;
+const DEFAULT_MAX_INTERVAL_MS = 5 * 60 * 1000;
+const BACKOFF_AFTER_MS = 10 * 60 * 1000;
+const SUCCESS_STATUSES = new Set(["Approved"]);
+const FAILURE_STATUSES = new Set(["Rejected", "PaymentFailed", "Payment Failed"]);
+export async function watchApplication(fetchApplication, options = {}) {
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const initialIntervalMs = options.initialIntervalMs ?? DEFAULT_INITIAL_INTERVAL_MS;
+    const maxIntervalMs = options.maxIntervalMs ?? DEFAULT_MAX_INTERVAL_MS;
+    const now = options.now ?? Date.now;
+    const sleep = options.sleep ?? defaultSleep;
+    const startedAt = now();
+    let lastStatus;
+    let lastApplication;
+    for (;;) {
+        const application = await fetchApplication();
+        lastApplication = application;
+        const status = application.statusId;
+        if (status !== lastStatus) {
+            await options.onTransition?.(application);
+            lastStatus = status;
+        }
+        if (status && SUCCESS_STATUSES.has(status)) {
+            return { application, terminal: "approved" };
+        }
+        if (status && FAILURE_STATUSES.has(status)) {
+            throw new ExitError({
+                code: "TERMINAL_FAILURE_STATE",
+                message: `Application entered terminal failure state ${status}.`,
+                exitCode: ExitCodes.TerminalFailure,
+                details: application,
+            });
+        }
+        const elapsedMs = now() - startedAt;
+        if (elapsedMs >= timeoutMs) {
+            throw new ExitError({
+                code: "WATCH_TIMEOUT",
+                message: `Application did not reach a terminal success state within ${formatDuration(timeoutMs)}.`,
+                exitCode: ExitCodes.Timeout,
+                details: lastApplication ?? null,
+            });
+        }
+        const intervalMs = elapsedMs < BACKOFF_AFTER_MS ? initialIntervalMs : maxIntervalMs;
+        await sleep(Math.min(intervalMs, timeoutMs - elapsedMs));
+    }
+}
+export function parseDurationMs(value, fallbackMs) {
+    if (!value) {
+        return fallbackMs;
+    }
+    const match = /^(\d+)(ms|s|m|h)$/.exec(value.trim());
+    if (!match) {
+        throw new ExitError({
+            code: "INVALID_DURATION",
+            message: `Invalid duration ${value}. Use values such as 30s, 30m, or 1h.`,
+            exitCode: ExitCodes.Usage,
+        });
+    }
+    const amount = Number(match[1]);
+    const unit = match[2];
+    if (unit === "ms") {
+        return amount;
+    }
+    if (unit === "s") {
+        return amount * 1000;
+    }
+    if (unit === "m") {
+        return amount * 60 * 1000;
+    }
+    return amount * 60 * 60 * 1000;
+}
+function formatDuration(ms) {
+    if (ms % (60 * 1000) === 0) {
+        return `${ms / (60 * 1000)}m`;
+    }
+    if (ms % 1000 === 0) {
+        return `${ms / 1000}s`;
+    }
+    return `${ms}ms`;
+}
+function defaultSleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+//# sourceMappingURL=watch.js.map

package/dist/src/prompts/confirm.d.ts

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

package/dist/src/prompts/confirm.js

@@ -0,0 +1,19 @@
+import { confirm } from "@inquirer/prompts";
+import { terminalCapabilities } from "../output/tty.js";
+export async function confirmAction(message, globals, deps = {}) {
+    if (globals.yes) {
+        return true;
+    }
+    const capabilities = terminalCapabilities({
+        json: globals.json,
+        raw: globals.raw,
+        noAutoJson: globals.autoJson === false,
+        quiet: globals.quiet,
+        env: deps.env,
+    }, deps.streams);
+    if (!capabilities.interactive) {
+        return true;
+    }
+    return deps.promptConfirm?.(message) ?? confirm({ message, default: false });
+}
+//# sourceMappingURL=confirm.js.map

package/dist/src/scopes/check.d.ts

@@ -0,0 +1,17 @@
+import type { CredentialKind } from "../credentials/types.js";
+export declare const SCOPE_REFERENCE_URL = "https://docs.eprospera.com/agent-keys.html#scope-reference";
+export type ScopeCredential = {
+    kind: CredentialKind;
+    scopes: readonly string[];
+};
+export type ScopeCheckOptions = {
+    skipScopeCheck?: boolean;
+};
+export type ScopeCheckResult = {
+    ok: true;
+} | {
+    ok: false;
+    missing: string;
+};
+export declare function checkCommandScope(commandId: string, credential: ScopeCredential | undefined, options?: ScopeCheckOptions): ScopeCheckResult;
+export declare function assertCommandScope(commandId: string, credential: ScopeCredential | undefined, options?: ScopeCheckOptions): void;

package/dist/src/scopes/check.js

@@ -0,0 +1,64 @@
+import { ExitCodes, ExitError } from "../errors.js";
+import { getCommandScope } from "./map.js";
+export const SCOPE_REFERENCE_URL = "https://docs.eprospera.com/agent-keys.html#scope-reference";
+export function checkCommandScope(commandId, credential, options = {}) {
+    const requirement = getCommandScope(commandId);
+    if (!requirement || !requiresCredential(requirement)) {
+        return { ok: true };
+    }
+    if (!credential) {
+        throw new ExitError({
+            code: "NO_CREDENTIAL",
+            message: "No API credential configured.",
+            exitCode: ExitCodes.Authentication,
+        });
+    }
+    if (requirement.credentialTypes && !requirement.credentialTypes.includes(credential.kind)) {
+        throw new ExitError({
+            code: "UNSUPPORTED_CREDENTIAL_TYPE",
+            message: `Command ${commandId} does not support ${credential.kind} credentials.`,
+            exitCode: ExitCodes.Authorization,
+            details: {
+                command: commandId,
+                credentialKind: credential.kind,
+                allowedCredentialTypes: requirement.credentialTypes,
+            },
+        });
+    }
+    if (options.skipScopeCheck) {
+        return { ok: true };
+    }
+    const requiredScope = requiredScopeForCredential(credential.kind, requirement);
+    if (requiredScope && !credential.scopes.includes(requiredScope)) {
+        return { ok: false, missing: requiredScope };
+    }
+    return { ok: true };
+}
+export function assertCommandScope(commandId, credential, options = {}) {
+    const result = checkCommandScope(commandId, credential, options);
+    if (!result.ok) {
+        throw new ExitError({
+            code: "MISSING_SCOPE",
+            message: `Credential is missing required scope ${result.missing}. See ${SCOPE_REFERENCE_URL}.`,
+            exitCode: ExitCodes.Authorization,
+            details: {
+                command: commandId,
+                missing: result.missing,
+                scopeReference: SCOPE_REFERENCE_URL,
+            },
+        });
+    }
+}
+function requiresCredential(requirement) {
+    return Boolean(requirement.requiredScope || requirement.oauthScope || requirement.credentialTypes?.length);
+}
+function requiredScopeForCredential(kind, requirement) {
+    if (kind === "ak") {
+        return requirement.requiredScope;
+    }
+    if (kind === "oauth") {
+        return requirement.oauthScope;
+    }
+    return undefined;
+}
+//# sourceMappingURL=check.js.map

package/dist/src/scopes/map.d.ts

@@ -0,0 +1,81 @@
+import type { CredentialKind } from "../credentials/types.js";
+export type CommandScopeRequirement = {
+    requiredScope?: string;
+    oauthScope?: string;
+    credentialTypes?: readonly CredentialKind[];
+};
+declare const commandScopes: {
+    readonly "entity.verify": {
+        readonly requiredScope: "agent:verify_rpn";
+        readonly credentialTypes: readonly ["ak", "sk"];
+    };
+    readonly "entity.search": {
+        readonly requiredScope: "agent:registry.search";
+        readonly credentialTypes: readonly ["ak", "sk"];
+    };
+    readonly "entity.get": {
+        readonly requiredScope: "agent:entity.read";
+        readonly credentialTypes: readonly ["ak", "sk"];
+    };
+    readonly "entity.documents": {
+        readonly requiredScope: "agent:entity.documents.read";
+        readonly credentialTypes: readonly ["ak", "sk"];
+    };
+    readonly "application.list": {
+        readonly requiredScope: "agent:entity.application.read";
+        readonly credentialTypes: readonly ["ak", "sk"];
+    };
+    readonly "application.create": {
+        readonly requiredScope: "agent:entity.application.create";
+        readonly credentialTypes: readonly ["ak", "sk"];
+    };
+    readonly "application.get": {
+        readonly requiredScope: "agent:entity.application.read";
+        readonly credentialTypes: readonly ["ak", "sk"];
+    };
+    readonly "application.pay": {
+        readonly requiredScope: "agent:entity.application.pay";
+        readonly credentialTypes: readonly ["ak", "sk"];
+    };
+    readonly "application.watch": {
+        readonly requiredScope: "agent:entity.application.read";
+        readonly credentialTypes: readonly ["ak", "sk"];
+    };
+    readonly "me.profile": {
+        readonly requiredScope: "agent:person.details.read";
+        readonly oauthScope: "eprospera:person.details.read";
+        readonly credentialTypes: readonly ["ak", "oauth"];
+    };
+    readonly "me.residency": {
+        readonly requiredScope: "agent:person.residency.read";
+        readonly oauthScope: "eprospera:person.residency.read";
+        readonly credentialTypes: readonly ["ak", "oauth"];
+    };
+    readonly "me.id-verification": {
+        readonly requiredScope: "agent:person.id_verification.read";
+        readonly oauthScope: "eprospera:person.id_verification.read";
+        readonly credentialTypes: readonly ["ak", "oauth"];
+    };
+    readonly "auth.login": {
+        readonly credentialTypes: readonly ["ak", "sk"];
+    };
+    readonly "auth.whoami": {
+        readonly credentialTypes: readonly ["ak", "sk", "oauth"];
+    };
+    readonly "auth.logout": {
+        readonly credentialTypes: readonly ["ak", "sk", "oauth"];
+    };
+    readonly "config.get": {};
+    readonly "config.set": {};
+    readonly "config.list": {};
+    readonly "config.unset": {};
+    readonly "completion.bash": {};
+    readonly "completion.zsh": {};
+    readonly "completion.fish": {};
+    readonly "completion.powershell": {};
+    readonly schema: {};
+};
+export type CommandId = keyof typeof commandScopes;
+export declare const COMMAND_SCOPES: Record<CommandId, CommandScopeRequirement>;
+export declare function getCommandScope(commandId: string): CommandScopeRequirement | undefined;
+export {};

package/dist/src/scopes/map.js

@@ -0,0 +1,76 @@
+const commandScopes = {
+    "entity.verify": {
+        requiredScope: "agent:verify_rpn",
+        credentialTypes: ["ak", "sk"],
+    },
+    "entity.search": {
+        requiredScope: "agent:registry.search",
+        credentialTypes: ["ak", "sk"],
+    },
+    "entity.get": {
+        requiredScope: "agent:entity.read",
+        credentialTypes: ["ak", "sk"],
+    },
+    "entity.documents": {
+        requiredScope: "agent:entity.documents.read",
+        credentialTypes: ["ak", "sk"],
+    },
+    "application.list": {
+        requiredScope: "agent:entity.application.read",
+        credentialTypes: ["ak", "sk"],
+    },
+    "application.create": {
+        requiredScope: "agent:entity.application.create",
+        credentialTypes: ["ak", "sk"],
+    },
+    "application.get": {
+        requiredScope: "agent:entity.application.read",
+        credentialTypes: ["ak", "sk"],
+    },
+    "application.pay": {
+        requiredScope: "agent:entity.application.pay",
+        credentialTypes: ["ak", "sk"],
+    },
+    "application.watch": {
+        requiredScope: "agent:entity.application.read",
+        credentialTypes: ["ak", "sk"],
+    },
+    "me.profile": {
+        requiredScope: "agent:person.details.read",
+        oauthScope: "eprospera:person.details.read",
+        credentialTypes: ["ak", "oauth"],
+    },
+    "me.residency": {
+        requiredScope: "agent:person.residency.read",
+        oauthScope: "eprospera:person.residency.read",
+        credentialTypes: ["ak", "oauth"],
+    },
+    "me.id-verification": {
+        requiredScope: "agent:person.id_verification.read",
+        oauthScope: "eprospera:person.id_verification.read",
+        credentialTypes: ["ak", "oauth"],
+    },
+    "auth.login": {
+        credentialTypes: ["ak", "sk"],
+    },
+    "auth.whoami": {
+        credentialTypes: ["ak", "sk", "oauth"],
+    },
+    "auth.logout": {
+        credentialTypes: ["ak", "sk", "oauth"],
+    },
+    "config.get": {},
+    "config.set": {},
+    "config.list": {},
+    "config.unset": {},
+    "completion.bash": {},
+    "completion.zsh": {},
+    "completion.fish": {},
+    "completion.powershell": {},
+    schema: {},
+};
+export const COMMAND_SCOPES = commandScopes;
+export function getCommandScope(commandId) {
+    return COMMAND_SCOPES[commandId];
+}
+//# sourceMappingURL=map.js.map

package/dist/src/version.d.ts

@@ -0,0 +1 @@
+export declare const VERSION: string;

package/dist/src/version.js

@@ -0,0 +1,35 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+const BUNDLED_VERSION = "__EPROSPERA_CLI_VERSION__";
+export const VERSION = readPackageVersion() ?? BUNDLED_VERSION;
+function readPackageVersion() {
+    let currentDir = dirname(fileURLToPath(import.meta.url));
+    for (;;) {
+        const packageJsonPath = join(currentDir, "package.json");
+        if (existsSync(packageJsonPath)) {
+            const version = parsePackageVersion(packageJsonPath);
+            if (version) {
+                return version;
+            }
+        }
+        const parentDir = dirname(currentDir);
+        if (parentDir === currentDir) {
+            return undefined;
+        }
+        currentDir = parentDir;
+    }
+}
+function parsePackageVersion(packageJsonPath) {
+    try {
+        const value = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+        if (value.name === "@prospera/eprospera-cli" && typeof value.version === "string") {
+            return value.version;
+        }
+    }
+    catch {
+        return undefined;
+    }
+    return undefined;
+}
+//# sourceMappingURL=version.js.map

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@prospera/eprospera-cli",
+  "version": "0.1.0",
+  "description": "TypeScript CLI for the e-Prospera public API.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Honduras-Prospera-inc/eprospera-cli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Honduras-Prospera-inc/eprospera-cli/issues"
+  },
+  "homepage": "https://github.com/Honduras-Prospera-inc/eprospera-cli#readme",
+  "bin": {
+    "eprospera": "bin/eprospera.js"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "bundle": "pnpm run build && tsx scripts/build-bundle.ts",
+    "check": "biome check . && tsc --noEmit",
+    "gen:all": "pnpm run gen:api && pnpm run gen:docs && pnpm run gen:completions",
+    "gen:api": "tsx scripts/gen-api-client.ts",
+    "gen:completions": "tsx scripts/gen-completions.ts",
+    "gen:docs": "tsx scripts/gen-docs.ts",
+    "pack:smoke": "tsx scripts/smoke-packed-install.ts",
+    "prepare": "simple-git-hooks",
+    "test": "vitest run",
+    "test:e2e": "vitest run test/e2e",
+    "typecheck": "tsc --noEmit",
+    "validate:ocs": "tsx scripts/validate-ocs.ts"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "MIT",
+  "engines": {
+    "node": ">=20"
+  },
+  "packageManager": "pnpm@10.33.4",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "devDependencies": {
+    "@biomejs/biome": "^2.4.15",
+    "@changesets/cli": "^2.31.0",
+    "@types/node": "^25.9.1",
+    "@vercel/ncc": "^0.38.4",
+    "ajv": "^8.20.0",
+    "execa": "^9.6.1",
+    "msw": "^2.14.6",
+    "openapi-typescript": "^7.13.0",
+    "simple-git-hooks": "^2.13.1",
+    "tsx": "^4.22.3",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.7"
+  },
+  "dependencies": {
+    "@inquirer/prompts": "^8.4.3",
+    "cli-table3": "^0.6.5",
+    "commander": "^14.0.3",
+    "keytar": "^7.9.0",
+    "openapi-fetch": "^0.17.0",
+    "ora": "^9.4.0",
+    "picocolors": "^1.1.1",
+    "yaml": "^2.9.0",
+    "zod": "^4.4.3"
+  },
+  "simple-git-hooks": {
+    "pre-commit": "pnpm run gen:all"
+  }
+}