@boxrouter/sdk 0.0.0-stage → 0.12.190

package/dist/server-timing.js

@@ -0,0 +1,421 @@
+"use strict";
+/** Safe, opt-in Server-Timing measurements for a BoxRouter fetch hook. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withClientTiming = withClientTiming;
+exports.connectionSegmentRecorder = connectionSegmentRecorder;
+exports.connectionSegmentStart = connectionSegmentStart;
+exports.parseServerTiming = parseServerTiming;
+exports.usesClientOwnedFetch = usesClientOwnedFetch;
+exports.usesClientTimingFetch = usesClientTimingFetch;
+exports.useClientOwnedFetch = useClientOwnedFetch;
+exports.createServerTimingFetch = createServerTimingFetch;
+const server_timing_gen_1 = require("./server-timing.gen");
+const durationPattern = /^[0-9]+(?:\.[0-9]+)?$/;
+const signedPattern = /^[+-]?[0-9]+(?:\.[0-9]+)?$/;
+const integerPattern = /^[0-9]+$/;
+const operationName = new RegExp(server_timing_gen_1.timingContract[server_timing_gen_1.timingContract.operationGrammar.namePattern]);
+const aggregateMetrics = new Set(server_timing_gen_1.aggregateBindings.map(binding => binding.metric));
+let textEncoder;
+let timingRuntimePromise;
+let timingRuntime;
+const requestStates = new WeakMap();
+function nodeRuntime() {
+    return typeof globalThis.process?.versions?.node === 'string';
+}
+function record(state, field, value) {
+    if (state && state.values[field] === null)
+        state.values[field] = value;
+}
+function publish(state) {
+    if (state.published || !state.callEnded || !state.fetchEnded || !state.callback || !state.serverTiming ||
+        state.clientMs === undefined)
+        return;
+    state.published = true;
+    const metrics = Object.fromEntries(server_timing_gen_1.aggregateBindings.map(({ metric, field }) => [field, state.serverTiming.aggregates[metric].durationMs]));
+    try {
+        state.callback({ clientMs: state.clientMs,
+            networkMs: metrics.cloudMs === null ? null : Math.round(Math.max(0, state.clientMs - metrics.cloudMs) * 1000) / 1000,
+            ...metrics, ...state.values, serverTiming: state.serverTiming });
+    }
+    catch { /* An observability callback must not change the request result. */ }
+}
+function currentState() {
+    return timingRuntime?.storage.getStore();
+}
+async function ensureTimingRuntime() {
+    if (!nodeRuntime())
+        return undefined;
+    if (!timingRuntimePromise)
+        timingRuntimePromise = Promise.all([
+            import('node:async_hooks'), import('node:diagnostics_channel'),
+        ]).then(([asyncHooks, diagnostics]) => {
+            const runtime = {
+                AsyncLocalStorage: asyncHooks.AsyncLocalStorage,
+                channel: diagnostics.channel,
+            };
+            const storage = new runtime.AsyncLocalStorage();
+            const current = () => storage.getStore();
+            runtime.channel('undici:client:connected').subscribe(message => {
+                const socket = message?.socket;
+                if (socket)
+                    connectedSockets.add(socket);
+            });
+            runtime.channel('undici:client:sendHeaders').subscribe(message => {
+                const state = current();
+                const ended = timingClock();
+                if (!state || ended === null)
+                    return;
+                const request = message?.request;
+                if (request)
+                    requestStates.set(request, state);
+                const socket = message?.socket;
+                if (socket) {
+                    record(state, 'connectionReused', !connectedSockets.has(socket));
+                    connectedSockets.delete(socket);
+                }
+                state.requestSentStarted = ended;
+            });
+            runtime.channel('undici:request:bodySent').subscribe(message => {
+                const request = message?.request;
+                const state = (request && requestStates.get(request)) ?? current();
+                const ended = timingClock();
+                if (state && ended !== null && state.requestSentStarted !== undefined) {
+                    record(state, 'requestSentMs', ended - state.requestSentStarted);
+                    state.firstByteAt = ended;
+                }
+            });
+            runtime.channel('undici:request:headers').subscribe(message => {
+                const request = message?.request;
+                const state = (request && requestStates.get(request)) ?? current();
+                const ended = timingClock();
+                if (state && ended !== null && state.firstByteAt !== undefined) {
+                    record(state, 'firstByteMs', ended - state.firstByteAt);
+                    state.bodyReadEnded = ended;
+                }
+            });
+            runtime.channel('undici:request:trailers').subscribe(message => {
+                const request = message?.request;
+                const state = (request && requestStates.get(request)) ?? current();
+                const ended = timingClock();
+                if (state && ended !== null && state.bodyReadEnded !== undefined) {
+                    record(state, 'bodyReadMs', ended - state.bodyReadEnded);
+                    state.bodyReadEnded = ended;
+                }
+            });
+            timingRuntime = { storage, runtime };
+            return timingRuntime;
+        }).catch(() => undefined);
+    return timingRuntimePromise;
+}
+/** Carry opt-in timing across the generated API call, fetch and response validation. */
+async function withClientTiming(run, enabled) {
+    if (!enabled || !nodeRuntime())
+        return run();
+    const installed = await ensureTimingRuntime();
+    if (!installed)
+        return run();
+    const state = {
+        callStarted: timingClock() ?? 0,
+        values: Object.fromEntries(server_timing_gen_1.clientTimingBindings.map(({ field }) => [field, null])),
+    };
+    return installed.storage.run(state, async () => {
+        try {
+            return await run();
+        }
+        finally {
+            const ended = timingClock();
+            const decodeStarted = state.bodyReadEnded;
+            if (ended !== null && decodeStarted !== undefined && ended >= decodeStarted) {
+                record(state, 'sdkDecodeMs', ended - decodeStarted);
+            }
+            state.callEnded = true;
+            publish(state);
+        }
+    });
+}
+/** Mark TCP and TLS separately when the SDK's owned connector exposes both events. */
+/** Capture the current operation before Undici invokes its asynchronous connector callbacks. */
+function connectionSegmentRecorder(field) {
+    const state = currentState();
+    const recordCaptured = (started, ended) => {
+        if (state && Number.isFinite(started) && Number.isFinite(ended) && ended >= started) {
+            record(state, field, ended - started);
+            if (field === 'dnsMs')
+                state.dnsEndedAt = ended;
+        }
+    };
+    return Object.assign(recordCaptured, { dnsEndedAt: () => state?.dnsEndedAt });
+}
+/** Timestamp after DNS, used by the owned Undici connector to isolate TCP time. */
+function connectionSegmentStart() {
+    return currentState()?.dnsEndedAt;
+}
+const connectedSockets = new WeakSet();
+function splitQuoted(value, separator) {
+    const parts = [];
+    let start = 0;
+    let quoted = false;
+    let escaped = false;
+    for (let index = 0; index < value.length; index++) {
+        const character = value[index];
+        if (escaped) {
+            escaped = false;
+        }
+        else if (character === '\\' && quoted) {
+            escaped = true;
+        }
+        else if (character === '"') {
+            quoted = !quoted;
+        }
+        else if (character === separator && !quoted) {
+            parts.push(value.slice(start, index));
+            start = index + 1;
+        }
+    }
+    parts.push(value.slice(start));
+    return parts;
+}
+function text(value) {
+    if (value === undefined || !value.startsWith('"'))
+        return value;
+    if (!value.endsWith('"') || value.length < 2)
+        return undefined;
+    let decoded = '';
+    for (let index = 1; index < value.length - 1; index++) {
+        const character = value[index];
+        if (character === '\\') {
+            if (++index >= value.length - 1)
+                return undefined;
+            decoded += value[index];
+        }
+        else if (character === '"') {
+            return undefined;
+        }
+        else {
+            decoded += character;
+        }
+    }
+    return decoded;
+}
+function numberValue(value, signed = false, minimum = 0) {
+    if (value === undefined || !(signed ? signedPattern : durationPattern).test(value))
+        return null;
+    const parsed = Number(value);
+    return Number.isFinite(parsed) && (signed || parsed >= minimum) ? parsed : null;
+}
+/** Parse bounded, independent measurements without inferring complete coverage. */
+function parseServerTiming(header) {
+    const aggregates = Object.fromEntries(server_timing_gen_1.aggregateBindings.map(({ metric }) => [metric, { durationMs: null, state: server_timing_gen_1.timingContract.aggregateGrammar.missingMeans }]));
+    const result = {
+        aggregates, operations: [], omissions: null,
+        operationCoverage: server_timing_gen_1.timingContract.coverageGrammar.absentState, parseLimited: false,
+    };
+    if (header === null)
+        return result;
+    if (header.length > server_timing_gen_1.timingContract.maxHeaderBytes ||
+        (textEncoder ??= new TextEncoder()).encode(header).length > server_timing_gen_1.timingContract.maxHeaderBytes) {
+        result.parseLimited = true;
+        return result;
+    }
+    for (const entry of splitQuoted(header, ',')) {
+        const [rawName, ...rawParameters] = splitQuoted(entry.trim(), ';');
+        const name = rawName.trim();
+        const parameters = new Map();
+        for (const parameter of rawParameters) {
+            const separator = parameter.indexOf('=');
+            const key = (separator < 0 ? parameter : parameter.slice(0, separator)).trim().toLowerCase();
+            if (!parameters.has(key)) {
+                parameters.set(key, separator < 0 ? undefined : parameter.slice(separator + 1).trim());
+            }
+        }
+        const first = (key) => text(parameters.get(key.toLowerCase()));
+        const duration = (key, minimum) => numberValue(first(key), false, minimum);
+        if (aggregateMetrics.has(name)) {
+            const grammar = server_timing_gen_1.timingContract.aggregateGrammar;
+            if (first(grammar.descriptionParameter) === grammar.unknownDescription) {
+                aggregates[name] = { durationMs: null, state: grammar.unknownDescription };
+            }
+            else {
+                const measured = duration(grammar.duration.parameter, grammar.duration.minimum);
+                if (measured !== null)
+                    aggregates[name] = { durationMs: measured, state: 'measured' };
+            }
+        }
+        else if (name === server_timing_gen_1.timingContract.operationGrammar.metric) {
+            const grammar = server_timing_gen_1.timingContract.operationGrammar;
+            const label = first(grammar.nameParameter);
+            const start = numberValue(first(grammar.start.parameter), true);
+            const measured = duration(grammar.duration.parameter, grammar.duration.minimum);
+            const outcome = first(grammar.outcomeParameter);
+            if (label !== undefined && operationName.test(label) && start !== null && measured !== null &&
+                outcome !== undefined && grammar.outcomes.includes(outcome)) {
+                if (result.operations.length < server_timing_gen_1.timingContract.maxOperationRows) {
+                    result.operations.push({ name: label, startMs: start, durationMs: measured, outcome: outcome });
+                }
+                else {
+                    result.parseLimited = true;
+                }
+            }
+        }
+        else if (name === server_timing_gen_1.timingContract.omissionGrammar.metric) {
+            const grammar = server_timing_gen_1.timingContract.omissionGrammar;
+            const rawCount = first(grammar.count.parameter);
+            const measured = duration(grammar.duration.parameter, grammar.duration.minimum);
+            if (rawCount !== undefined && integerPattern.test(rawCount) && measured !== null) {
+                const exact = BigInt(rawCount);
+                if (exact >= BigInt(grammar.count.minimum)) {
+                    result.omissions = {
+                        count: exact <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(exact) : exact.toString(),
+                        durationMs: measured,
+                    };
+                }
+            }
+        }
+        else if (name === server_timing_gen_1.timingContract.coverageGrammar.metric) {
+            const grammar = server_timing_gen_1.timingContract.coverageGrammar;
+            if (first(grammar.descriptionParameter) === grammar.unknownValue) {
+                result.operationCoverage = grammar.unknownValue;
+            }
+        }
+    }
+    return result;
+}
+function timingClock() {
+    try {
+        const value = performance.now();
+        return typeof value === 'number' && Number.isFinite(value) ? value : null;
+    }
+    catch {
+        return null;
+    }
+}
+function decorateResponse(response, source) {
+    Object.defineProperties(response, {
+        url: { configurable: true, value: source.url },
+        redirected: { configurable: true, value: source.redirected },
+        type: { configurable: true, value: source.type },
+    });
+    const clone = response.clone.bind(response);
+    Object.defineProperty(response, 'clone', {
+        configurable: true,
+        value: () => decorateResponse(clone(), source),
+    });
+    return response;
+}
+/**
+ * Wrap a fetch implementation to report bounded timing fields after each body is read.
+ * Pass the result as `BoxRouter({ fetch })`; the default client has no callback overhead.
+ */
+const timingFetchConfigurations = new WeakMap();
+function usesClientOwnedFetch(fetch) {
+    return fetch !== undefined && timingFetchConfigurations.get(fetch)?.usesDefaultFetch === true;
+}
+function usesClientTimingFetch(fetch) {
+    return fetch !== undefined && timingFetchConfigurations.has(fetch);
+}
+/** Use the BoxRouter-owned Node pool behind a timing hook created without a custom fetch. */
+function useClientOwnedFetch(fetch, clientFetch) {
+    if (!fetch || !clientFetch)
+        return fetch;
+    const configuration = timingFetchConfigurations.get(fetch);
+    return configuration?.usesDefaultFetch ? createServerTimingFetch(configuration.callback, clientFetch) : fetch;
+}
+function createServerTimingFetch(onTiming, fetchImpl) {
+    const usesDefaultFetch = fetchImpl === undefined;
+    const timedFetch = async (input, init) => {
+        const installed = await ensureTimingRuntime();
+        const state = installed?.storage.getStore();
+        const started = timingClock();
+        if (state && started !== null) {
+            record(state, 'sdkBuildMs', Math.max(0, started - state.callStarted));
+        }
+        const response = await (fetchImpl ?? globalThis.fetch)(input, init);
+        if (started === null)
+            return response;
+        let serverTiming;
+        try {
+            serverTiming = parseServerTiming(response.headers.get('Server-Timing'));
+        }
+        catch {
+            // Optional parsing must preserve the native response, including its body.
+            return response;
+        }
+        let finished = false;
+        const finish = () => {
+            if (finished)
+                return;
+            finished = true;
+            const ended = timingClock();
+            if (ended === null)
+                return;
+            const elapsed = ended - started;
+            if (!Number.isFinite(elapsed) || elapsed < 0)
+                return;
+            const clientMs = Math.round(elapsed * 1000) / 1000;
+            if (!Number.isFinite(clientMs))
+                return;
+            if (state) {
+                state.clientMs = clientMs;
+                state.serverTiming = serverTiming;
+                state.callback = onTiming;
+                state.fetchEnded = true;
+                publish(state);
+            }
+            else {
+                const metrics = Object.fromEntries(server_timing_gen_1.aggregateBindings.map(({ metric, field }) => [field, serverTiming.aggregates[metric].durationMs]));
+                const clientFields = Object.fromEntries(server_timing_gen_1.clientTimingBindings.map(({ field }) => [field, null]));
+                const serviceMs = serverTiming.aggregates[server_timing_gen_1.timingContract.serviceAggregateMetric].durationMs;
+                try {
+                    onTiming({ clientMs,
+                        networkMs: serviceMs === null ? null : Math.round(Math.max(0, clientMs - serviceMs) * 1000) / 1000,
+                        ...metrics, ...clientFields, serverTiming });
+                }
+                catch { /* An observability callback must not change the request result. */ }
+            }
+        };
+        const sourceBody = response.body;
+        if (sourceBody === null || response.status === 0 || [204, 205, 304].includes(response.status)) {
+            finish();
+            return response;
+        }
+        let reader;
+        const timedBody = new ReadableStream({
+            async pull(controller) {
+                reader ??= sourceBody.getReader();
+                try {
+                    const result = await reader.read();
+                    if (result.done) {
+                        controller.close();
+                        finish();
+                        reader.releaseLock();
+                    }
+                    else {
+                        controller.enqueue(result.value);
+                    }
+                }
+                catch (error) {
+                    controller.error(error);
+                    finish();
+                    reader.releaseLock();
+                }
+            },
+            async cancel(reason) {
+                reader ??= sourceBody.getReader();
+                try {
+                    await reader.cancel(reason);
+                }
+                finally {
+                    finish();
+                    reader.releaseLock();
+                }
+            },
+        }, { highWaterMark: 0 });
+        return decorateResponse(new Response(timedBody, {
+            status: response.status,
+            statusText: response.statusText,
+            headers: response.headers,
+        }), response);
+    };
+    timingFetchConfigurations.set(timedFetch, { callback: onTiming, usesDefaultFetch });
+    return timedFetch;
+}

package/dist/spend-limits.d.ts

@@ -0,0 +1,17 @@
+import type { BoxRouterApi } from './sdk.gen';
+import type { SpendLimit, SpendLimitList, SpendLimitRecord } from './types.gen';
+import type { RequestOptions } from './sandboxes';
+/**
+ * Cap what the workspace can spend on BoxRouter-billed sandboxes.
+ * `'workspace'` is the only scope.
+ */
+export declare class SpendLimitResources {
+    private readonly spendLimits;
+    constructor(api: BoxRouterApi);
+    /** The workspace cap (`workspace` is `null` without one). */
+    list(options?: RequestOptions): Promise<SpendLimitList>;
+    /** Set a cap, replacing the scope's current one. `limit_period` is `'daily'`, `'monthly'` or `'total'`. */
+    set(scope: 'workspace', limit: SpendLimit, options?: RequestOptions): Promise<SpendLimitRecord>;
+    /** Remove the scope's cap. Clearing a scope with no cap succeeds. */
+    clear(scope: 'workspace', options?: RequestOptions): Promise<SpendLimitRecord>;
+}

package/dist/spend-limits.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpendLimitResources = void 0;
+/**
+ * Cap what the workspace can spend on BoxRouter-billed sandboxes.
+ * `'workspace'` is the only scope.
+ */
+class SpendLimitResources {
+    spendLimits;
+    constructor(api) {
+        this.spendLimits = api.spendLimits;
+    }
+    /** The workspace cap (`workspace` is `null` without one). */
+    async list(options = {}) {
+        return this.spendLimits.list({ signal: options.signal });
+    }
+    /** Set a cap, replacing the scope's current one. `limit_period` is `'daily'`, `'monthly'` or `'total'`. */
+    async set(scope, limit, options = {}) {
+        return this.spendLimits.set({ path: { scope }, body: limit, signal: options.signal });
+    }
+    /** Remove the scope's cap. Clearing a scope with no cap succeeds. */
+    async clear(scope, options = {}) {
+        return this.spendLimits.clear({ path: { scope }, signal: options.signal });
+    }
+}
+exports.SpendLimitResources = SpendLimitResources;

package/dist/telemetry.d.ts

@@ -0,0 +1,51 @@
+import { type Context, type Span } from '@opentelemetry/api';
+export declare function isTimeoutError(error: unknown): boolean;
+export type RequestPhaseObservation = {
+    phase: 'request_preparation' | 'response_headers' | 'response_processing' | 'stream_lifetime';
+    outcome: 'success' | 'http_error' | 'network_error' | 'cancelled' | 'parse_error' | 'stream_error' | 'stream_cancelled' | 'unknown';
+    durationMs: number;
+};
+export type RequestPhaseObserver = (observation: RequestPhaseObservation) => void;
+/** Opt in to bounded, payload-free request phase observations. */
+export declare function setRequestPhaseObserver(observer?: RequestPhaseObserver): void;
+/** The application owns providers, sampling, propagation and export. */
+export declare class RequestTrace {
+    readonly span: Span;
+    readonly context: Context;
+    streaming: boolean;
+    private timingEnabled;
+    private requestPreparationStarted;
+    private requestPreparationDuration;
+    private requestPreparationMeasured;
+    private responseHeadersDuration;
+    private responseProcessingStarted;
+    private responseProcessingDuration;
+    private responseProcessingMeasured;
+    private phaseObserver;
+    private streamLifetimeStarted;
+    private requestPreparationOutcomeSent;
+    private responseProcessingOutcomeSent;
+    private responseHeadersOutcomeSent;
+    private responseHeadersSpanWritten;
+    private responseStatus;
+    private responseWasHttpError;
+    constructor(method: string | undefined, path: string | undefined, parent?: Context);
+    inject(headers: Headers): void;
+    fetchResponse<T extends Response>(fetchCallback: () => Promise<T>): Promise<T>;
+    finishBufferedResponse(): void;
+    recordResponseHeadersSpan(): void;
+    finishRequestPreparationOutcome(outcome: RequestPhaseObservation['outcome']): void;
+    finishResponseHeadersOutcome(outcome: RequestPhaseObservation['outcome']): void;
+    finishResponseOutcome(outcome: RequestPhaseObservation['outcome']): void;
+    startStreamLifetime(): void;
+    finishStreamLifetime(outcome: RequestPhaseObservation['outcome']): void;
+    finishResponseProcessing(): void;
+    finishObserverOutcome(outcome: RequestPhaseObservation['outcome']): void;
+    finishFailureOutcomes(error: unknown): void;
+    response(response: Response): void;
+    error(error: unknown): void;
+    responseOutcome(error: unknown): RequestPhaseObservation['outcome'];
+    successfulResponseOutcome(): RequestPhaseObservation['outcome'];
+    private setTiming;
+}
+export declare function tracedRequest<T>(method: string | undefined, path: string, run: (telemetry: RequestTrace) => Promise<T>): Promise<T>;

package/dist/telemetry.gen.d.ts

@@ -0,0 +1 @@
+export declare const operationNames: Map<string, string>;

package/dist/telemetry.gen.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.operationNames = void 0;
+// Canonical operation names, never substituted resource IDs or query values.
+exports.operationNames = new Map([["GET /agents", "listAgents"], ["GET /agents/{name}", "getAgent"], ["POST /launches", "createLaunch"], ["GET /launches/{operation_id}", "getLaunchOperation"], ["GET /launches/{operation_id}/settings", "getLaunchSettings"], ["GET /launches/{operation_id}/command", "getLaunchCommand"], ["GET /launch-runs", "listLaunchRuns"], ["POST /launch-runs", "createLaunchRun"], ["GET /launch-runs/{run_id}", "getLaunchRun"], ["POST /launch-runs/{run_id}/stop", "stopLaunchRun"], ["POST /launch-runs/{run_id}/copies/{copy_index}/destroy", "destroyLaunchRunCopy"], ["GET /repositories/{owner}/{repo}/access", "checkRepositoryAccess"], ["GET /github/installations", "listGithubInstallations"], ["DELETE /github/installations/{installation_id}", "unlinkGithubInstallation"], ["GET /github/repositories", "listGithubRepositories"], ["GET /actions/repositories/{repository_id}", "getActionsRepository"], ["PUT /actions/repositories/{repository_id}", "updateActionsRepository"], ["GET /routing/settings", "getRoutingSettings"], ["PUT /routing/settings", "updateRoutingSettings"], ["GET /routing/preview", "getRoutingPreview"], ["GET /actions/readiness", "getActionsReadiness"], ["GET /actions/runner-catalog", "getActionsRunnerCatalog"], ["GET /actions/policies", "listActionsPolicies"], ["POST /actions/policies", "createActionsPolicy"], ["GET /actions/policies/{policy_id}", "getActionsPolicy"], ["PUT /actions/policies/{policy_id}", "updateActionsPolicy"], ["DELETE /actions/policies/{policy_id}", "deleteActionsPolicy"], ["POST /actions/preview", "previewActions"], ["GET /actions/runs", "listActionsRuns"], ["GET /actions/runs/facets", "listActionsRunFacets"], ["GET /actions/pool-idle-time", "getActionsPoolIdleTime"], ["GET /actions/runs/{run_id}", "getActionsRun"], ["GET /actions/runs/{run_id}/jobs", "listActionsRunJobs"], ["GET /actions/runs/{run_id}/placements", "listActionsRunPlacements"], ["GET /actions/jobs/{job_id}", "getActionsJob"], ["GET /actions/jobs/{job_id}/steps", "getActionsJobSteps"], ["GET /actions/jobs/{job_id}/logs", "getActionsJobLogs"], ["GET /actions/jobs/{job_id}/steps/{step_position}/logs", "getActionsJobStepLogs"], ["GET /actions/jobs/{job_id}/events", "getActionsJobEvents"], ["GET /actions/placements/{placement_id}", "getActionsPlacement"], ["POST /actions/runs/{run_id}/cancel", "cancelActionsRun"], ["POST /actions/runs/{run_id}/rerun", "rerunActionsRun"], ["POST /actions/runs/{run_id}/rerun-failed-jobs", "rerunActionsRunFailedJobs"], ["GET /operations", "listOperations"], ["POST /artifacts", "uploadArtifact"], ["GET /artifacts/{artifact_id}", "getArtifact"], ["DELETE /artifacts/{artifact_id}", "deleteArtifact"], ["POST /images/prepare", "prepareImage"], ["GET /images/preparations", "getImagePreparations"], ["POST /images/unprepare", "unprepareImage"], ["POST /sandboxes/{sandbox_id}/processes", "startProcess"], ["GET /sandboxes/{sandbox_id}/processes/{process_id}", "readProcess"], ["DELETE /sandboxes/{sandbox_id}/processes/{process_id}", "removeProcess"], ["POST /sandboxes/{sandbox_id}/processes/{process_id}/stdin", "writeProcessStdin"], ["POST /sandboxes/{sandbox_id}/processes/{process_id}/stdin/close", "closeProcessStdin"], ["POST /sandboxes/{sandbox_id}/processes/{process_id}/cancel", "cancelProcess"], ["GET /credits", "getCredits"], ["GET /spend-limits", "listSpendLimits"], ["PUT /spend-limits/{scope}", "setSpendLimit"], ["DELETE /spend-limits/{scope}", "clearSpendLimit"], ["POST /credits/purchases", "createCreditPurchase"], ["GET /credits/purchases", "listCreditPurchases"], ["POST /credits/purchases/quote", "quoteCreditPurchase"], ["GET /credits/usage", "listCreditUsage"], ["GET /usage", "listUsageReport"], ["GET /usage.csv", "exportUsageReportCsv"], ["GET /credits/purchases/{purchase_id}", "getCreditPurchase"], ["POST /credits/purchases/{purchase_id}/cancel", "cancelCreditPurchase"], ["POST /credits/promotions", "redeemCreditPromotion"], ["GET /credits/promotions", "listCreditPromotions"], ["GET /credits/billing-details", "getCreditBillingDetails"], ["PUT /credits/billing-details", "updateCreditBillingDetails"], ["GET /credits/alerts", "getCreditAlerts"], ["PUT /credits/alerts", "updateCreditAlerts"], ["GET /credits/payment-methods", "listCreditPaymentMethods"], ["POST /credits/payment-methods/setup", "createCreditPaymentMethodSetup"], ["POST /credits/payment-methods/setup-intent", "createCreditPaymentMethodSetupIntent"], ["PUT /credits/payment-methods/order", "reorderCreditPaymentMethods"], ["GET /credits/payment-method-setups/{setup_id}", "getCreditPaymentMethodSetup"], ["DELETE /credits/payment-methods/{payment_method_id}", "deleteCreditPaymentMethod"], ["POST /credits/payment-methods/{payment_method_id}/default", "setCreditDefaultPaymentMethod"], ["GET /credits/auto-top-up", "getCreditAutoTopUp"], ["PUT /credits/auto-top-up", "updateCreditAutoTopUp"], ["POST /sandboxes/{sandbox_id}/terminals", "openTerminal"], ["GET /sandboxes/{sandbox_id}/terminals/{terminal_id}", "getTerminal"], ["GET /sandboxes/{sandbox_id}/terminals/{terminal_id}/events", "streamTerminalEvents"], ["POST /sandboxes/{sandbox_id}/terminals/{terminal_id}/input", "writeTerminalInput"], ["POST /sandboxes/{sandbox_id}/terminals/{terminal_id}/resize", "resizeTerminal"], ["POST /sandboxes/{sandbox_id}/terminals/{terminal_id}/kill", "killTerminal"], ["GET /secrets", "listSecrets"], ["PUT /secrets/{name}", "putSecret"], ["DELETE /secrets/{name}", "deleteSecret"], ["GET /sandboxes/{sandbox_id}/previews", "listPreviews"], ["POST /sandboxes/{sandbox_id}/previews", "openPreview"], ["DELETE /sandboxes/{sandbox_id}/previews/{preview_id}", "revokePreview"], ["POST /sandboxes/{sandbox_id}/browser", "ensureBrowser"], ["POST /sandboxes/{sandbox_id}/pause", "pauseSandbox"], ["POST /sandboxes/{sandbox_id}/resume", "resumeSandbox"], ["POST /sandboxes/{sandbox_id}/lifetime", "extendSandboxLifetime"], ["POST /sandboxes/{sandbox_id}/network-policy", "updateNetworkPolicy"], ["POST /provider-accounts", "connectProviderAccount"], ["GET /provider-accounts", "listProviderAccounts"], ["POST /provider-accounts/test", "testProviderCredentials"], ["GET /provider-accounts/{account_id}", "getProviderAccount"], ["DELETE /provider-accounts/{account_id}", "disconnectProviderAccount"], ["PUT /provider-accounts/{account_id}/credentials", "replaceProviderCredentials"], ["POST /provider-accounts/{account_id}/test", "testProviderAccount"], ["POST /provider-accounts/{account_id}/standard-image/setup", "setupProviderStandardImage"], ["GET /operations/{operation_id}", "getOperation"], ["GET /volumes", "listVolumes"], ["POST /volumes", "createVolume"], ["GET /volumes/{volume_id}", "getVolume"], ["DELETE /volumes/{volume_id}", "deleteVolume"], ["GET /volumes/{volume_id}/checkpoints", "listVolumeCheckpoints"], ["POST /volumes/{volume_id}/checkpoints", "saveVolume"], ["GET /volumes/{volume_id}/checkpoints/{checkpoint}", "getVolumeCheckpoint"], ["DELETE /volumes/{volume_id}/checkpoints/{checkpoint}", "deleteVolumeCheckpoint"], ["DELETE /volumes/{volume_id}/lease", "releaseVolumeLease"], ["POST /volumes/{volume_id}/uploads", "createVolumeUpload"], ["POST /volumes/{volume_id}/uploads/{upload_id}/complete", "completeVolumeUpload"], ["DELETE /volumes/{volume_id}/uploads/{upload_id}", "abortVolumeUpload"], ["POST /volumes/{volume_id}/downloads", "createVolumeDownload"], ["GET /volumes/{volume_id}/files", "listVolumeFiles"], ["POST /sandboxes", "createSandbox"], ["GET /sandboxes", "listSandboxes"], ["POST /sandboxes/match", "matchSandbox"], ["GET /sandboxes/{sandbox_id}", "getSandbox"], ["DELETE /sandboxes/{sandbox_id}", "destroySandbox"], ["POST /sandboxes/{sandbox_id}/commands", "runCommand"], ["GET /sandboxes/{sandbox_id}/files/content", "readFile"], ["PUT /sandboxes/{sandbox_id}/files/content", "writeFile"], ["POST /sandboxes/{sandbox_id}/files/uploads", "createSandboxUpload"], ["POST /sandboxes/{sandbox_id}/files/uploads/{upload_id}/complete", "completeSandboxUpload"], ["DELETE /sandboxes/{sandbox_id}/files/uploads/{upload_id}", "abortSandboxUpload"], ["POST /sandboxes/{sandbox_id}/files/downloads", "createSandboxDownload"], ["GET /sandboxes/{sandbox_id}/files/directories", "listDirectory"], ["POST /sandboxes/{sandbox_id}/files/directories", "createDirectory"], ["GET /sandboxes/{sandbox_id}/files/exists", "pathExists"], ["POST /sandboxes/{sandbox_id}/files/remove", "removePath"], ["GET /price-versions", "listPriceVersions"], ["GET /providers", "listProviders"]]);