@proxy-checkout/cli 0.1.0-prx-128.104.1

package/dist/esm/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/esm/http-client.js

@@ -0,0 +1,98 @@
+import { CliError, cliExitCodes } from "./errors.js";
+const requestTimeoutMs = 30_000;
+export 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 CliError("Could not reach the Proxy API", "cli_network_error", 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 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 CliError("Could not reach the Proxy authentication service", "cli_network_error", cliExitCodes.network, { error_class: error instanceof Error ? error.name : typeof error });
+        }
+        return {
+            body: (await readJson(response)),
+            ok: response.ok,
+            status: response.status,
+        };
+    }
+}
+function requestSignal(signal) {
+    const timeout = AbortSignal.timeout(requestTimeoutMs);
+    return signal ? AbortSignal.any([signal, timeout]) : timeout;
+}
+function commandInterrupted() {
+    return new CliError("CLI command interrupted", "cli_command_interrupted", cliExitCodes.interrupted);
+}
+function exitCodeForStatus(status) {
+    if (status === 401)
+        return cliExitCodes.authentication;
+    if (status === 403)
+        return cliExitCodes.permission;
+    if (status === 409)
+        return cliExitCodes.conflict;
+    if (status >= 500 || status === 429)
+        return cliExitCodes.network;
+    return cliExitCodes.usage;
+}
+async function readJson(response) {
+    const text = await response.text();
+    if (!text)
+        return {};
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        throw new CliError("Proxy API returned an invalid response", "cli_invalid_api_response", cliExitCodes.network, { status: response.status });
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/esm/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/esm/index.js

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

package/dist/esm/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/esm/output.js

@@ -0,0 +1,71 @@
+export 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`);
+    }
+}
+export 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/esm/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 {};

package/dist/esm/webhooks.js

@@ -0,0 +1,337 @@
+import { spawn } from "node:child_process";
+import { CliError, cliExitCodes } from "./errors.js";
+import { ProxyApiClient } from "./http-client.js";
+import { redactText } from "./output.js";
+const claimPollIntervalMs = 1_000;
+const heartbeatIntervalMs = 30_000;
+const localForwardTimeoutMs = 30_000;
+const stripeEvents = [
+    "checkout.session.completed",
+    "customer.subscription.deleted",
+    "customer.subscription.updated",
+    "invoice.paid",
+    "invoice.payment_failed",
+    "payment_intent.canceled",
+    "payment_intent.payment_failed",
+    "payment_intent.succeeded",
+].join(",");
+export class ProxyWebhooksClient {
+    api;
+    constructor(apiBaseUrl, token, fetchImpl) {
+        this.api = new ProxyApiClient(apiBaseUrl, token, fetchImpl);
+    }
+    async listEndpoints() {
+        return (await this.api.request("/cli/webhook-endpoints")).webhook_endpoints;
+    }
+    async createListener(sourceEndpointId) {
+        return (await this.api.request("/cli/webhook-listeners", {
+            body: { source_webhook_endpoint_id: sourceEndpointId },
+            method: "POST",
+        })).listener;
+    }
+    async getListener(listenerId) {
+        return (await this.api.request(`/cli/webhook-listeners/${encodeURIComponent(listenerId)}`)).listener;
+    }
+    async heartbeat(listenerId) {
+        return (await this.api.request(`/cli/webhook-listeners/${encodeURIComponent(listenerId)}/heartbeat`, { method: "POST" })).listener;
+    }
+    async close(listenerId) {
+        return (await this.api.request(`/cli/webhook-listeners/${encodeURIComponent(listenerId)}/close`, { method: "POST" })).listener;
+    }
+    async listDeliveries(listenerId, limit) {
+        const query = limit ? `?${new URLSearchParams({ limit: String(limit) })}` : "";
+        return (await this.api.request(`/cli/webhook-listeners/${encodeURIComponent(listenerId)}/deliveries${query}`)).deliveries;
+    }
+    async replay(listenerId, deliveryId, reason) {
+        return this.api.request(`/cli/webhook-listeners/${encodeURIComponent(listenerId)}/deliveries/${encodeURIComponent(deliveryId)}/replay`, { body: { reason }, method: "POST" });
+    }
+    async claim(listenerId, selection = {}) {
+        return (await this.api.request(`/cli/webhook-listeners/${encodeURIComponent(listenerId)}/claims`, {
+            method: "POST",
+            body: {
+                ...(selection.deliveryId ? { delivery_id: selection.deliveryId } : {}),
+                ...(selection.replayOutboxEventId
+                    ? { replay_outbox_event_id: selection.replayOutboxEventId }
+                    : {}),
+            },
+        })).claim;
+    }
+    async complete(attemptId, input) {
+        return this.api.request(`/cli/webhook-delivery-attempts/${encodeURIComponent(attemptId)}/complete`, {
+            method: "POST",
+            body: {
+                duration_ms: input.durationMs,
+                error_class: input.errorClass,
+                response_status_code: input.responseStatusCode,
+            },
+        });
+    }
+    async createStripeIngress(listenerId, webhookSecret, pspConfigId) {
+        return (await this.api.request(`/cli/webhook-listeners/${encodeURIComponent(listenerId)}/stripe-ingress`, {
+            method: "POST",
+            body: {
+                ...(pspConfigId ? { psp_config_id: pspConfigId } : {}),
+                webhook_secret: webhookSecret,
+            },
+        })).stripe_ingress;
+    }
+}
+export async function runListener(input) {
+    const destination = validateLoopbackDestination(input.forwardTo);
+    const listener = await input.client.createListener(input.sourceEndpointId);
+    let stripeProcess;
+    let forwarded = 0;
+    let heartbeatFailure;
+    const heartbeatTimer = setInterval(() => {
+        void input.client.heartbeat(listener.id).catch((error) => {
+            heartbeatFailure = error;
+        });
+    }, heartbeatIntervalMs);
+    input.output.event("listener.started", { forward_to: destination.toString(), listener }, `Listening for Proxy test webhooks on ${listener.id}; forwarding to ${destination}`);
+    try {
+        if (input.signal.aborted)
+            throw listenerInterrupted();
+        if (input.stripe) {
+            const webhookSecret = await captureStripeWebhookSecret(input.signal);
+            const ingress = await input.client.createStripeIngress(listener.id, webhookSecret, input.pspConfigId);
+            stripeProcess = startStripeListener(ingress.inbound_url, input.output);
+            input.output.event("stripe.started", {
+                expires_at: ingress.expires_at,
+                ingress_id: ingress.id,
+                merchant_psp_config_id: ingress.merchant_psp_config_id,
+            }, "Stripe CLI test webhook orchestration is active.");
+        }
+        if (input.signal.aborted)
+            throw listenerInterrupted();
+        while (!input.signal.aborted && (input.maxEvents === 0 || forwarded < input.maxEvents)) {
+            if (heartbeatFailure) {
+                throw heartbeatFailure;
+            }
+            if (stripeProcess && (stripeProcess.exitCode !== null || stripeProcess.signalCode)) {
+                throw new CliError("Stripe CLI listener exited unexpectedly", "stripe_cli_exited", cliExitCodes.dependency, { exit_code: stripeProcess.exitCode, signal: stripeProcess.signalCode });
+            }
+            const claim = await input.client.claim(listener.id);
+            if (!claim) {
+                await abortableDelay(claimPollIntervalMs, input.signal);
+                continue;
+            }
+            const completion = await forwardClaim(input.client, claim, destination, input.signal);
+            forwarded += 1;
+            input.output.event("delivery.forwarded", {
+                attempt_id: claim.attempt_id,
+                attempt_number: claim.attempt_number,
+                completion,
+                kind: claim.kind,
+                webhook_delivery_id: claim.webhook_delivery_id,
+            }, `Forwarded ${claim.kind} ${claim.webhook_delivery_id} (${formatCompletion(completion)}).`);
+        }
+        if (input.signal.aborted)
+            throw listenerInterrupted();
+        return { forwarded, listener };
+    }
+    finally {
+        clearInterval(heartbeatTimer);
+        if (stripeProcess && stripeProcess.exitCode === null && !stripeProcess.signalCode) {
+            stripeProcess.kill("SIGTERM");
+            await waitForExit(stripeProcess, 2_000);
+            if (stripeProcess.exitCode === null && !stripeProcess.signalCode) {
+                stripeProcess.kill("SIGKILL");
+            }
+        }
+        try {
+            const closed = await input.client.close(listener.id);
+            input.output.event("listener.closed", { listener: closed }, `Closed local webhook listener ${listener.id}.`);
+        }
+        catch (error) {
+            input.output.event("listener.cleanup_failed", {
+                error_class: error instanceof Error ? error.name : typeof error,
+                listener_id: listener.id,
+            }, `Could not confirm cleanup for listener ${listener.id}; its short lease will expire automatically.`);
+        }
+    }
+}
+export async function forwardSelectedDelivery(input) {
+    const claim = await input.client.claim(input.listenerId, {
+        ...(input.deliveryId ? { deliveryId: input.deliveryId } : {}),
+        ...(input.replayOutboxEventId ? { replayOutboxEventId: input.replayOutboxEventId } : {}),
+    });
+    if (!claim) {
+        throw new CliError("Selected delivery or replay is not currently claimable", "cli_delivery_not_claimable", cliExitCodes.conflict);
+    }
+    const completion = await forwardClaim(input.client, claim, validateLoopbackDestination(input.forwardTo), input.signal);
+    return {
+        attempt_id: claim.attempt_id,
+        attempt_number: claim.attempt_number,
+        completion,
+        kind: claim.kind,
+        webhook_delivery_id: claim.webhook_delivery_id,
+    };
+}
+async function forwardClaim(client, claim, destination, signal) {
+    const startedAt = Date.now();
+    let errorClass = null;
+    let responseStatusCode = null;
+    try {
+        const timeoutSignal = AbortSignal.timeout(localForwardTimeoutMs);
+        const response = await fetch(destination, {
+            body: claim.body,
+            headers: claim.headers,
+            method: "POST",
+            redirect: "manual",
+            signal: signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal,
+        });
+        responseStatusCode = response.status;
+        await response.body?.cancel().catch(() => undefined);
+    }
+    catch (error) {
+        errorClass =
+            !signal?.aborted &&
+                error instanceof Error &&
+                (error.name === "AbortError" || error.name === "TimeoutError")
+                ? "timeout"
+                : "network_error";
+    }
+    return client.complete(claim.attempt_id, {
+        durationMs: Math.min(Date.now() - startedAt, 300_000),
+        errorClass,
+        responseStatusCode,
+    });
+}
+async function captureStripeWebhookSecret(signal) {
+    const result = await captureProcess("stripe", ["listen", "--events", stripeEvents, "--print-secret"], signal, 30_000);
+    if (signal.aborted)
+        throw listenerInterrupted();
+    const match = `${result.stdout}\n${result.stderr}`.match(/\bwhsec_[A-Za-z0-9_-]{8,512}\b/);
+    if (result.code !== 0 || !match) {
+        throw new CliError("Stripe CLI could not provide a test webhook signing secret; authenticate Stripe CLI and try again", "stripe_cli_auth_required", cliExitCodes.dependency, { exit_code: result.code, stderr: redactText(result.stderr).slice(0, 400) });
+    }
+    return match[0];
+}
+function listenerInterrupted() {
+    return new CliError("Local webhook listener interrupted", "cli_listener_interrupted", cliExitCodes.interrupted);
+}
+function startStripeListener(inboundUrl, output) {
+    const child = spawn("stripe", ["listen", "--events", stripeEvents, "--forward-to", inboundUrl], {
+        shell: false,
+        stdio: ["pipe", "pipe", "pipe"],
+    });
+    child.stdin.end();
+    pipeSanitized(child.stdout, (line) => output.notice(`[stripe] ${line}`));
+    pipeSanitized(child.stderr, (line) => output.notice(`[stripe] ${line}`));
+    child.once("error", () => undefined);
+    return child;
+}
+function pipeSanitized(stream, writeLine) {
+    let pending = "";
+    stream.setEncoding("utf8");
+    stream.on("data", (chunk) => {
+        pending += chunk;
+        const lines = pending.split(/\r?\n/);
+        pending = lines.pop() ?? "";
+        for (const line of lines) {
+            if (line)
+                writeLine(redactText(line));
+        }
+        if (pending.length > 8_192) {
+            writeLine(redactText(pending.slice(0, 8_192)));
+            pending = "";
+        }
+    });
+    stream.on("end", () => {
+        if (pending)
+            writeLine(redactText(pending));
+    });
+}
+async function captureProcess(command, args, signal, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, { shell: false, stdio: ["pipe", "pipe", "pipe"] });
+        let stdout = "";
+        let stderr = "";
+        const timer = setTimeout(() => child.kill("SIGTERM"), timeoutMs);
+        const abort = () => child.kill("SIGTERM");
+        signal.addEventListener("abort", abort, { once: true });
+        child.stdout.setEncoding("utf8").on("data", (chunk) => {
+            stdout = `${stdout}${chunk}`.slice(-65_536);
+        });
+        child.stderr.setEncoding("utf8").on("data", (chunk) => {
+            stderr = `${stderr}${chunk}`.slice(-65_536);
+        });
+        child.on("error", (error) => {
+            clearTimeout(timer);
+            signal.removeEventListener("abort", abort);
+            if (error.code === "ENOENT") {
+                reject(new CliError("Stripe CLI is not installed or not on PATH", "stripe_cli_not_found", cliExitCodes.dependency));
+                return;
+            }
+            reject(error);
+        });
+        child.on("close", (code) => {
+            clearTimeout(timer);
+            signal.removeEventListener("abort", abort);
+            resolve({ code: code ?? 1, stderr, stdout });
+        });
+        child.stdin.end();
+    });
+}
+function validateLoopbackDestination(value) {
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        throw new CliError("Forward destination must be a valid loopback URL", "cli_forward_destination_invalid", cliExitCodes.usage);
+    }
+    const hostname = url.hostname.replace(/^\[|\]$/g, "");
+    if ((url.protocol !== "http:" && url.protocol !== "https:") ||
+        !["127.0.0.1", "::1", "localhost"].includes(hostname) ||
+        url.username ||
+        url.password ||
+        url.hash) {
+        throw new CliError("Forward destination must be an HTTP(S) loopback URL without credentials or a fragment", "cli_forward_destination_invalid", cliExitCodes.usage);
+    }
+    return url;
+}
+function formatCompletion(completion) {
+    if (completion &&
+        typeof completion === "object" &&
+        "completion" in completion &&
+        completion.completion &&
+        typeof completion.completion === "object" &&
+        "status" in completion.completion) {
+        return String(completion.completion.status);
+    }
+    return "completed";
+}
+function abortableDelay(milliseconds, signal) {
+    if (signal.aborted)
+        return Promise.resolve();
+    return new Promise((resolve) => {
+        const onAbort = () => {
+            clearTimeout(timer);
+            signal.removeEventListener("abort", onAbort);
+            resolve();
+        };
+        const timer = setTimeout(() => {
+            signal.removeEventListener("abort", onAbort);
+            resolve();
+        }, milliseconds);
+        signal.addEventListener("abort", onAbort, { once: true });
+    });
+}
+function waitForExit(child, timeoutMs) {
+    if (child.exitCode !== null || child.signalCode)
+        return Promise.resolve();
+    return new Promise((resolve) => {
+        const onExit = () => {
+            clearTimeout(timer);
+            resolve();
+        };
+        const timer = setTimeout(() => {
+            child.removeListener("exit", onExit);
+            resolve();
+        }, timeoutMs);
+        child.once("exit", onExit);
+        if (child.exitCode !== null || child.signalCode)
+            onExit();
+    });
+}