@proxy-checkout/cli 0.1.0-prx-128.104.1

package/dist/cjs/errors.d.cts

@@ -0,0 +1,20 @@
+export declare const cliExitCodes: {
+    readonly authentication: 3;
+    readonly conflict: 6;
+    readonly dependency: 7;
+    readonly internal: 10;
+    readonly interrupted: 8;
+    readonly network: 4;
+    readonly permission: 5;
+    readonly success: 0;
+    readonly usage: 2;
+};
+export type CliExitCode = (typeof cliExitCodes)[keyof typeof cliExitCodes];
+export declare class CliError extends Error {
+    readonly code: string;
+    readonly exitCode: CliExitCode;
+    readonly details?: Record<string, unknown> | undefined;
+    constructor(message: string, code: string, exitCode: CliExitCode, details?: Record<string, unknown> | undefined);
+}
+export declare function usageError(message: string, details?: Record<string, unknown>): CliError;
+export declare function asCliError(error: unknown): CliError;

package/dist/cjs/errors.d.ts

@@ -0,0 +1,20 @@
+export declare const cliExitCodes: {
+    readonly authentication: 3;
+    readonly conflict: 6;
+    readonly dependency: 7;
+    readonly internal: 10;
+    readonly interrupted: 8;
+    readonly network: 4;
+    readonly permission: 5;
+    readonly success: 0;
+    readonly usage: 2;
+};
+export type CliExitCode = (typeof cliExitCodes)[keyof typeof cliExitCodes];
+export declare class CliError extends Error {
+    readonly code: string;
+    readonly exitCode: CliExitCode;
+    readonly details?: Record<string, unknown> | undefined;
+    constructor(message: string, code: string, exitCode: CliExitCode, details?: Record<string, unknown> | undefined);
+}
+export declare function usageError(message: string, details?: Record<string, unknown>): CliError;
+export declare function asCliError(error: unknown): CliError;

package/dist/cjs/errors.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CliError = exports.cliExitCodes = void 0;
+exports.usageError = usageError;
+exports.asCliError = asCliError;
+exports.cliExitCodes = {
+    authentication: 3,
+    conflict: 6,
+    dependency: 7,
+    internal: 10,
+    interrupted: 8,
+    network: 4,
+    permission: 5,
+    success: 0,
+    usage: 2,
+};
+class CliError extends Error {
+    code;
+    exitCode;
+    details;
+    constructor(message, code, exitCode, details) {
+        super(message);
+        this.code = code;
+        this.exitCode = exitCode;
+        this.details = details;
+    }
+}
+exports.CliError = CliError;
+function usageError(message, details) {
+    return new CliError(message, "usage_error", exports.cliExitCodes.usage, details);
+}
+function asCliError(error) {
+    if (error instanceof CliError) {
+        return error;
+    }
+    if (isStructurallyValidCliError(error)) {
+        return new CliError(error.message, error.code, error.exitCode, error.details);
+    }
+    return new CliError("Unexpected CLI error", "internal_error", exports.cliExitCodes.internal, {
+        error_class: error instanceof Error ? error.name : typeof error,
+    });
+}
+function isStructurallyValidCliError(error) {
+    return (error instanceof Error &&
+        typeof error.code === "string" &&
+        error.code?.length !== 0 &&
+        Object.values(exports.cliExitCodes).includes(error.exitCode) &&
+        (error.details === undefined ||
+            (typeof error.details === "object" &&
+                error.details !== null &&
+                !Array.isArray(error.details))));
+}

package/dist/cjs/http-client.d.cts

@@ -0,0 +1,25 @@
+export interface ProxyApiErrorBody {
+    error?: {
+        code?: string;
+        message?: string;
+        request_id?: string;
+    };
+}
+export declare class ProxyApiClient {
+    readonly baseUrl: string;
+    private readonly token?;
+    private readonly fetchImpl;
+    constructor(baseUrl: string, token?: string | undefined, fetchImpl?: typeof fetch);
+    request<T>(path: string, options?: {
+        body?: unknown;
+        method?: "DELETE" | "GET" | "PATCH" | "POST";
+        signal?: AbortSignal;
+    }): Promise<T>;
+    oauthRequest<T>(path: string, body: unknown, options?: {
+        signal?: AbortSignal;
+    }): Promise<{
+        body: T | Record<string, unknown>;
+        ok: boolean;
+        status: number;
+    }>;
+}

package/dist/cjs/http-client.d.ts

@@ -0,0 +1,25 @@
+export interface ProxyApiErrorBody {
+    error?: {
+        code?: string;
+        message?: string;
+        request_id?: string;
+    };
+}
+export declare class ProxyApiClient {
+    readonly baseUrl: string;
+    private readonly token?;
+    private readonly fetchImpl;
+    constructor(baseUrl: string, token?: string | undefined, fetchImpl?: typeof fetch);
+    request<T>(path: string, options?: {
+        body?: unknown;
+        method?: "DELETE" | "GET" | "PATCH" | "POST";
+        signal?: AbortSignal;
+    }): Promise<T>;
+    oauthRequest<T>(path: string, body: unknown, options?: {
+        signal?: AbortSignal;
+    }): Promise<{
+        body: T | Record<string, unknown>;
+        ok: boolean;
+        status: number;
+    }>;
+}

package/dist/cjs/http-client.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProxyApiClient = void 0;
+const errors_js_1 = require("./errors.js");
+const requestTimeoutMs = 30_000;
+class ProxyApiClient {
+    baseUrl;
+    token;
+    fetchImpl;
+    constructor(baseUrl, token, fetchImpl = fetch) {
+        this.baseUrl = baseUrl;
+        this.token = token;
+        this.fetchImpl = fetchImpl;
+    }
+    async request(path, options = {}) {
+        let response;
+        try {
+            response = await this.fetchImpl(new URL(path, `${this.baseUrl}/`), {
+                body: options.body === undefined ? undefined : JSON.stringify(options.body),
+                method: options.method ?? "GET",
+                redirect: "manual",
+                signal: requestSignal(options.signal),
+                headers: {
+                    accept: "application/json",
+                    ...(options.body === undefined ? {} : { "content-type": "application/json" }),
+                    ...(this.token ? { authorization: `Bearer ${this.token}` } : {}),
+                },
+            });
+        }
+        catch (error) {
+            if (options.signal?.aborted)
+                throw commandInterrupted();
+            throw new errors_js_1.CliError("Could not reach the Proxy API", "cli_network_error", errors_js_1.cliExitCodes.network, { error_class: error instanceof Error ? error.name : typeof error });
+        }
+        const body = await readJson(response);
+        if (!response.ok) {
+            const errorBody = isRecord(body) ? body : {};
+            const code = errorBody.error?.code ?? `http_${response.status}`;
+            const message = errorBody.error?.message ?? `Proxy API request failed with HTTP ${response.status}`;
+            throw new errors_js_1.CliError(message, code, exitCodeForStatus(response.status), {
+                request_id: errorBody.error?.request_id,
+                status: response.status,
+            });
+        }
+        return body;
+    }
+    async oauthRequest(path, body, options = {}) {
+        let response;
+        try {
+            response = await this.fetchImpl(new URL(path, `${this.baseUrl}/`), {
+                body: JSON.stringify(body),
+                headers: { accept: "application/json", "content-type": "application/json" },
+                method: "POST",
+                redirect: "manual",
+                signal: requestSignal(options.signal),
+            });
+        }
+        catch (error) {
+            if (options.signal?.aborted)
+                throw commandInterrupted();
+            throw new errors_js_1.CliError("Could not reach the Proxy authentication service", "cli_network_error", errors_js_1.cliExitCodes.network, { error_class: error instanceof Error ? error.name : typeof error });
+        }
+        return {
+            body: (await readJson(response)),
+            ok: response.ok,
+            status: response.status,
+        };
+    }
+}
+exports.ProxyApiClient = ProxyApiClient;
+function requestSignal(signal) {
+    const timeout = AbortSignal.timeout(requestTimeoutMs);
+    return signal ? AbortSignal.any([signal, timeout]) : timeout;
+}
+function commandInterrupted() {
+    return new errors_js_1.CliError("CLI command interrupted", "cli_command_interrupted", errors_js_1.cliExitCodes.interrupted);
+}
+function exitCodeForStatus(status) {
+    if (status === 401)
+        return errors_js_1.cliExitCodes.authentication;
+    if (status === 403)
+        return errors_js_1.cliExitCodes.permission;
+    if (status === 409)
+        return errors_js_1.cliExitCodes.conflict;
+    if (status >= 500 || status === 429)
+        return errors_js_1.cliExitCodes.network;
+    return errors_js_1.cliExitCodes.usage;
+}
+async function readJson(response) {
+    const text = await response.text();
+    if (!text)
+        return {};
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        throw new errors_js_1.CliError("Proxy API returned an invalid response", "cli_invalid_api_response", errors_js_1.cliExitCodes.network, { status: response.status });
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/cjs/index.d.cts

@@ -0,0 +1,5 @@
+export { cliVersion, type RunCliOptions, runCli } from "./cli.js";
+export { type CommandOptionSchema, type CommandSchema, commandSchemaDocument, commandSchemas, findCommandSchema, llmsFullDocument, } from "./command-schema.js";
+export { CliConfigStore, type CliProfile, type ResolvedCredential } from "./config.js";
+export { CliError, type CliExitCode, cliExitCodes } from "./errors.js";
+export declare const packageName = "@proxy-checkout/cli";

package/dist/cjs/index.d.ts

@@ -0,0 +1,5 @@
+export { cliVersion, type RunCliOptions, runCli } from "./cli.js";
+export { type CommandOptionSchema, type CommandSchema, commandSchemaDocument, commandSchemas, findCommandSchema, llmsFullDocument, } from "./command-schema.js";
+export { CliConfigStore, type CliProfile, type ResolvedCredential } from "./config.js";
+export { CliError, type CliExitCode, cliExitCodes } from "./errors.js";
+export declare const packageName = "@proxy-checkout/cli";

package/dist/cjs/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.packageName = exports.cliExitCodes = exports.CliError = exports.CliConfigStore = exports.llmsFullDocument = exports.findCommandSchema = exports.commandSchemas = exports.commandSchemaDocument = exports.runCli = exports.cliVersion = void 0;
+var cli_js_1 = require("./cli.js");
+Object.defineProperty(exports, "cliVersion", { enumerable: true, get: function () { return cli_js_1.cliVersion; } });
+Object.defineProperty(exports, "runCli", { enumerable: true, get: function () { return cli_js_1.runCli; } });
+var command_schema_js_1 = require("./command-schema.js");
+Object.defineProperty(exports, "commandSchemaDocument", { enumerable: true, get: function () { return command_schema_js_1.commandSchemaDocument; } });
+Object.defineProperty(exports, "commandSchemas", { enumerable: true, get: function () { return command_schema_js_1.commandSchemas; } });
+Object.defineProperty(exports, "findCommandSchema", { enumerable: true, get: function () { return command_schema_js_1.findCommandSchema; } });
+Object.defineProperty(exports, "llmsFullDocument", { enumerable: true, get: function () { return command_schema_js_1.llmsFullDocument; } });
+var config_js_1 = require("./config.js");
+Object.defineProperty(exports, "CliConfigStore", { enumerable: true, get: function () { return config_js_1.CliConfigStore; } });
+var errors_js_1 = require("./errors.js");
+Object.defineProperty(exports, "CliError", { enumerable: true, get: function () { return errors_js_1.CliError; } });
+Object.defineProperty(exports, "cliExitCodes", { enumerable: true, get: function () { return errors_js_1.cliExitCodes; } });
+exports.packageName = "@proxy-checkout/cli";

package/dist/cjs/output.d.cts

@@ -0,0 +1,19 @@
+import type { Readable, Writable } from "node:stream";
+import type { CliError } from "./errors.js";
+export type OutputFormat = "human" | "json" | "jsonl";
+export interface CliIo {
+    isTTY: boolean;
+    stderr: Pick<Writable, "write">;
+    stdin: Readable;
+    stdout: Pick<Writable, "write">;
+}
+export declare class CliOutput {
+    readonly format: OutputFormat;
+    private readonly io;
+    constructor(format: OutputFormat, io: CliIo);
+    result(value: unknown, human: string): void;
+    event(type: string, value: Record<string, unknown>, human: string): void;
+    notice(message: string): void;
+    error(error: CliError): void;
+}
+export declare function redactText(value: string): string;

package/dist/cjs/output.d.ts

@@ -0,0 +1,19 @@
+import type { Readable, Writable } from "node:stream";
+import type { CliError } from "./errors.js";
+export type OutputFormat = "human" | "json" | "jsonl";
+export interface CliIo {
+    isTTY: boolean;
+    stderr: Pick<Writable, "write">;
+    stdin: Readable;
+    stdout: Pick<Writable, "write">;
+}
+export declare class CliOutput {
+    readonly format: OutputFormat;
+    private readonly io;
+    constructor(format: OutputFormat, io: CliIo);
+    result(value: unknown, human: string): void;
+    event(type: string, value: Record<string, unknown>, human: string): void;
+    notice(message: string): void;
+    error(error: CliError): void;
+}
+export declare function redactText(value: string): string;

package/dist/cjs/output.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CliOutput = void 0;
+exports.redactText = redactText;
+class CliOutput {
+    format;
+    io;
+    constructor(format, io) {
+        this.format = format;
+        this.io = io;
+    }
+    result(value, human) {
+        this.io.stdout.write(this.format === "human" ? `${human}\n` : `${safeJson(value)}\n`);
+    }
+    event(type, value, human) {
+        this.io.stdout.write(this.format === "human" ? `${human}\n` : `${safeJson({ type, ...redactObject(value) })}\n`);
+    }
+    notice(message) {
+        if (this.format === "human") {
+            this.io.stderr.write(`${redactText(message)}\n`);
+        }
+    }
+    error(error) {
+        if (this.format === "human") {
+            this.io.stderr.write(`Error: ${redactText(error.message)} (${error.code})\n`);
+            return;
+        }
+        this.io.stderr.write(`${safeJson({
+            error: {
+                code: error.code,
+                details: redactObject(error.details ?? {}),
+                message: redactText(error.message),
+            },
+        })}\n`);
+    }
+}
+exports.CliOutput = CliOutput;
+function redactText(value) {
+    return value
+        .replace(/\b(?:pcli|sk|rk)_(?:test|live)_[A-Za-z0-9_-]+\b/g, "[REDACTED_PROXY_CREDENTIAL]")
+        .replace(/\bwhsec_[A-Za-z0-9_-]+\b/g, "[REDACTED_WEBHOOK_SECRET]")
+        .replace(/\bBearer\s+[A-Za-z0-9._~-]+\b/gi, "Bearer [REDACTED]");
+}
+function safeJson(value) {
+    return JSON.stringify(redactUnknown(value));
+}
+function redactUnknown(value) {
+    if (typeof value === "string") {
+        return redactText(value);
+    }
+    if (Array.isArray(value)) {
+        return value.map(redactUnknown);
+    }
+    if (value && typeof value === "object") {
+        return redactObject(value);
+    }
+    return value;
+}
+function redactObject(value) {
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+        key,
+        isSensitiveKey(key) ? "[REDACTED]" : redactUnknown(item),
+    ]));
+}
+function isSensitiveKey(key) {
+    const normalized = key.toLowerCase();
+    return (normalized === "authorization" ||
+        normalized === "credential" ||
+        normalized === "secret" ||
+        normalized === "token" ||
+        normalized.endsWith("_credential") ||
+        normalized.endsWith("_secret") ||
+        normalized.endsWith("_signature") ||
+        normalized.endsWith("_token") ||
+        normalized.endsWith("-signature"));
+}

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist/cjs/webhooks.d.cts

@@ -0,0 +1,81 @@
+import type { CliOutput } from "./output.js";
+export interface WebhookEndpointRecord {
+    event_schema_version: string;
+    event_types: string[] | null;
+    id: string;
+    url: string;
+}
+export interface WebhookListenerRecord {
+    created_at: string;
+    event_schema_version: string;
+    event_types: string[] | null;
+    heartbeat_interval_seconds: number;
+    id: string;
+    last_heartbeat_at: string;
+    lease_expires_at: string;
+    source_webhook_endpoint_id: string;
+    status: "active" | "archived";
+}
+interface DeliveryClaim {
+    attempt_id: string;
+    attempt_number: number;
+    body: string;
+    headers: Record<string, string>;
+    kind: "delivery" | "replay";
+    replay_outbox_event_id: string | null;
+    webhook_delivery_id: string;
+}
+export declare class ProxyWebhooksClient {
+    private readonly api;
+    constructor(apiBaseUrl: string, token: string, fetchImpl?: typeof fetch);
+    listEndpoints(): Promise<WebhookEndpointRecord[]>;
+    createListener(sourceEndpointId: string): Promise<WebhookListenerRecord>;
+    getListener(listenerId: string): Promise<WebhookListenerRecord>;
+    heartbeat(listenerId: string): Promise<WebhookListenerRecord>;
+    close(listenerId: string): Promise<WebhookListenerRecord>;
+    listDeliveries(listenerId: string, limit?: number): Promise<unknown[]>;
+    replay(listenerId: string, deliveryId: string, reason: string): Promise<unknown>;
+    claim(listenerId: string, selection?: {
+        deliveryId?: string;
+        replayOutboxEventId?: string;
+    }): Promise<DeliveryClaim | null>;
+    complete(attemptId: string, input: {
+        durationMs: number;
+        errorClass: "network_error" | "timeout" | null;
+        responseStatusCode: number | null;
+    }): Promise<unknown>;
+    createStripeIngress(listenerId: string, webhookSecret: string, pspConfigId?: string): Promise<{
+        expires_at: string;
+        id: string;
+        inbound_url: string;
+        merchant_psp_config_id: string;
+    }>;
+}
+export declare function runListener(input: {
+    client: ProxyWebhooksClient;
+    forwardTo: string;
+    maxEvents: number;
+    output: CliOutput;
+    pspConfigId?: string;
+    signal: AbortSignal;
+    sourceEndpointId: string;
+    stripe: boolean;
+}): Promise<{
+    forwarded: number;
+    listener: WebhookListenerRecord;
+}>;
+export declare function forwardSelectedDelivery(input: {
+    client: ProxyWebhooksClient;
+    deliveryId?: string;
+    forwardTo: string;
+    listenerId: string;
+    replayOutboxEventId?: string;
+    signal?: AbortSignal;
+}): Promise<{
+    attempt_id: string;
+    attempt_number: number;
+    completion: unknown;
+    kind: DeliveryClaim["kind"];
+    webhook_delivery_id: string;
+}>;
+export {};

package/dist/cjs/webhooks.d.ts

@@ -0,0 +1,81 @@
+import type { CliOutput } from "./output.js";
+export interface WebhookEndpointRecord {
+    event_schema_version: string;
+    event_types: string[] | null;
+    id: string;
+    url: string;
+}
+export interface WebhookListenerRecord {
+    created_at: string;
+    event_schema_version: string;
+    event_types: string[] | null;
+    heartbeat_interval_seconds: number;
+    id: string;
+    last_heartbeat_at: string;
+    lease_expires_at: string;
+    source_webhook_endpoint_id: string;
+    status: "active" | "archived";
+}
+interface DeliveryClaim {
+    attempt_id: string;
+    attempt_number: number;
+    body: string;
+    headers: Record<string, string>;
+    kind: "delivery" | "replay";
+    replay_outbox_event_id: string | null;
+    webhook_delivery_id: string;
+}
+export declare class ProxyWebhooksClient {
+    private readonly api;
+    constructor(apiBaseUrl: string, token: string, fetchImpl?: typeof fetch);
+    listEndpoints(): Promise<WebhookEndpointRecord[]>;
+    createListener(sourceEndpointId: string): Promise<WebhookListenerRecord>;
+    getListener(listenerId: string): Promise<WebhookListenerRecord>;
+    heartbeat(listenerId: string): Promise<WebhookListenerRecord>;
+    close(listenerId: string): Promise<WebhookListenerRecord>;
+    listDeliveries(listenerId: string, limit?: number): Promise<unknown[]>;
+    replay(listenerId: string, deliveryId: string, reason: string): Promise<unknown>;
+    claim(listenerId: string, selection?: {
+        deliveryId?: string;
+        replayOutboxEventId?: string;
+    }): Promise<DeliveryClaim | null>;
+    complete(attemptId: string, input: {
+        durationMs: number;
+        errorClass: "network_error" | "timeout" | null;
+        responseStatusCode: number | null;
+    }): Promise<unknown>;
+    createStripeIngress(listenerId: string, webhookSecret: string, pspConfigId?: string): Promise<{
+        expires_at: string;
+        id: string;
+        inbound_url: string;
+        merchant_psp_config_id: string;
+    }>;
+}
+export declare function runListener(input: {
+    client: ProxyWebhooksClient;
+    forwardTo: string;
+    maxEvents: number;
+    output: CliOutput;
+    pspConfigId?: string;
+    signal: AbortSignal;
+    sourceEndpointId: string;
+    stripe: boolean;
+}): Promise<{
+    forwarded: number;
+    listener: WebhookListenerRecord;
+}>;
+export declare function forwardSelectedDelivery(input: {
+    client: ProxyWebhooksClient;
+    deliveryId?: string;
+    forwardTo: string;
+    listenerId: string;
+    replayOutboxEventId?: string;
+    signal?: AbortSignal;
+}): Promise<{
+    attempt_id: string;
+    attempt_number: number;
+    completion: unknown;
+    kind: DeliveryClaim["kind"];
+    webhook_delivery_id: string;
+}>;
+export {};