@tarkahq/sdk 0.0.0-stage → 0.3.0

package/dist/cjs/generated/tarka/provisioning/v1/sandbox.d.ts

@@ -0,0 +1,431 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import { JobResources } from "./job.js";
+export declare const protobufPackage = "tarka.provisioning.v1";
+/** SandboxRuntime is a supported source-code runtime family. */
+export declare enum SandboxRuntime {
+    /** SANDBOX_RUNTIME_UNSPECIFIED - SANDBOX_RUNTIME_UNSPECIFIED is invalid for creation. */
+    SANDBOX_RUNTIME_UNSPECIFIED = 0,
+    SANDBOX_RUNTIME_PYTHON = 1,
+    SANDBOX_RUNTIME_NODE = 2,
+    UNRECOGNIZED = -1
+}
+export declare function sandboxRuntimeFromJSON(object: any): SandboxRuntime;
+export declare function sandboxRuntimeToJSON(object: SandboxRuntime): string;
+/** SandboxTemplateStatus is the lifecycle of a reusable sandbox template. */
+export declare enum SandboxTemplateStatus {
+    SANDBOX_TEMPLATE_STATUS_UNSPECIFIED = 0,
+    SANDBOX_TEMPLATE_STATUS_PENDING = 1,
+    SANDBOX_TEMPLATE_STATUS_BUILDING = 2,
+    SANDBOX_TEMPLATE_STATUS_READY = 3,
+    SANDBOX_TEMPLATE_STATUS_FAILED = 4,
+    SANDBOX_TEMPLATE_STATUS_DELETING = 5,
+    SANDBOX_TEMPLATE_STATUS_DELETED = 6,
+    UNRECOGNIZED = -1
+}
+export declare function sandboxTemplateStatusFromJSON(object: any): SandboxTemplateStatus;
+export declare function sandboxTemplateStatusToJSON(object: SandboxTemplateStatus): string;
+/** CodeSandboxStatus is the lifecycle of an isolated sandbox instance. */
+export declare enum CodeSandboxStatus {
+    CODE_SANDBOX_STATUS_UNSPECIFIED = 0,
+    CODE_SANDBOX_STATUS_STARTING = 1,
+    CODE_SANDBOX_STATUS_READY = 2,
+    CODE_SANDBOX_STATUS_BUSY = 3,
+    CODE_SANDBOX_STATUS_STOPPING = 4,
+    CODE_SANDBOX_STATUS_STOPPED = 5,
+    CODE_SANDBOX_STATUS_FAILED = 6,
+    CODE_SANDBOX_STATUS_EXPIRED = 7,
+    CODE_SANDBOX_STATUS_DELETED = 8,
+    /**
+     * CODE_SANDBOX_STATUS_QUEUED - Capacity has been reserved but the runtime is not ready. Queue/setup time
+     * does not consume the requested sandbox lifetime or incur compute usage.
+     */
+    CODE_SANDBOX_STATUS_QUEUED = 9,
+    UNRECOGNIZED = -1
+}
+export declare function codeSandboxStatusFromJSON(object: any): CodeSandboxStatus;
+export declare function codeSandboxStatusToJSON(object: CodeSandboxStatus): string;
+/** ExecutionStatus is the terminal or in-progress state of one execution. */
+export declare enum ExecutionStatus {
+    EXECUTION_STATUS_UNSPECIFIED = 0,
+    EXECUTION_STATUS_RUNNING = 1,
+    EXECUTION_STATUS_SUCCEEDED = 2,
+    EXECUTION_STATUS_FAILED = 3,
+    EXECUTION_STATUS_TIMED_OUT = 4,
+    EXECUTION_STATUS_CANCELLED = 5,
+    UNRECOGNIZED = -1
+}
+export declare function executionStatusFromJSON(object: any): ExecutionStatus;
+export declare function executionStatusToJSON(object: ExecutionStatus): string;
+/** SandboxTemplate is a reusable runtime plus an immutable dependency revision. */
+export interface SandboxTemplate {
+    /** id is the immutable template identifier. */
+    id: string;
+    /** org_id is empty for a platform built-in template. */
+    orgId: string;
+    /** alias is the stable organization-scoped or built-in template name. */
+    alias: string;
+    displayName: string;
+    runtime: SandboxRuntime;
+    /** runtime_version is the resolved interpreter/runtime version. */
+    runtimeVersion: string;
+    /** base_template_alias identifies the built-in base used for this template. */
+    baseTemplateAlias: string;
+    isBuiltin: boolean;
+    status: SandboxTemplateStatus;
+    /** dependency_file_type identifies the selected dependency manifest format. */
+    dependencyFileType: string;
+    /** dependency_manifest_sha256 is the normalized manifest digest. */
+    dependencyManifestSha256: string;
+    /** image_digest is the immutable built image digest once ready. */
+    imageDigest: string;
+    /** build_error_code is a stable machine-readable failure code. */
+    buildErrorCode: string;
+    createdAt: Date | undefined;
+    updatedAt: Date | undefined;
+}
+/**
+ * ListSandboxTemplatesRequest selects an organization. Results also include
+ * visible platform built-ins.
+ */
+export interface ListSandboxTemplatesRequest {
+    orgId: string;
+}
+/** ListSandboxTemplatesResponse contains visible reusable templates. */
+export interface ListSandboxTemplatesResponse {
+    templates: SandboxTemplate[];
+}
+/** CreateSandboxTemplateRequest creates one dependency-pinned template. */
+export interface CreateSandboxTemplateRequest {
+    orgId: string;
+    /** alias is an organization-scoped, URL-safe template name. */
+    alias: string;
+    displayName: string;
+    /** base_template_alias selects a supported built-in Python or Node base. */
+    baseTemplateAlias: string;
+    /** dependency_file supplies exactly one supported dependency manifest. */
+    dependencyFile: {
+        $case: "requirementsTxt";
+        value: string;
+    } | {
+        $case: "packageJson";
+        value: string;
+    } | {
+        $case: "pyprojectToml";
+        value: string;
+    } | undefined;
+    /**
+     * idempotency_key safely retries this mutation for 24 hours. The same key
+     * cannot be reused with different request content.
+     */
+    idempotencyKey: string;
+}
+/** GetSandboxTemplateRequest selects one organization-visible template. */
+export interface GetSandboxTemplateRequest {
+    orgId: string;
+    templateId: string;
+}
+/** DeleteSandboxTemplateRequest selects an organization-owned template. */
+export interface DeleteSandboxTemplateRequest {
+    orgId: string;
+    templateId: string;
+}
+/** CodeSandbox is an isolated, time-bounded execution environment. */
+export interface CodeSandbox {
+    id: string;
+    orgId: string;
+    templateId: string;
+    templateAlias: string;
+    runtime: SandboxRuntime;
+    status: CodeSandboxStatus;
+    /** timeout_seconds is the requested maximum sandbox lifetime. */
+    timeoutSeconds: number;
+    /**
+     * expires_at is the enforced sandbox lifetime deadline. Queued admission
+     * leaves it unset until readiness; then it is ready_at + timeout_seconds.
+     */
+    expiresAt: Date | undefined;
+    createdAt: Date | undefined;
+    readyAt: Date | undefined;
+    stoppedAt: Date | undefined;
+    /** failure_code is a stable machine-readable lifecycle failure code. */
+    failureCode: string;
+    /** location is where the sandbox runs, such as "eu-1" or "us-1". */
+    location: string;
+    /**
+     * queue_deadline bounds the capacity/setup wait, default ten minutes.
+     * Expiry fails the request and releases its unused reservation.
+     */
+    queueDeadline: Date | undefined;
+}
+/** ListSandboxesRequest selects one organization. */
+export interface ListSandboxesRequest {
+    orgId: string;
+}
+/** ListSandboxesResponse contains non-deleted sandboxes in newest-first order. */
+export interface ListSandboxesResponse {
+    sandboxes: CodeSandbox[];
+}
+/** CreateCodeSandboxRequest starts a sandbox from a ready template. */
+export interface CreateCodeSandboxRequest {
+    orgId: string;
+    /** template accepts a visible template identifier or alias. */
+    template: string;
+    /** timeout_seconds is the sandbox lifetime within platform bounds. */
+    timeoutSeconds: number;
+    /**
+     * idempotency_key safely retries this mutation for 24 hours. The same key
+     * cannot be reused with different request content.
+     */
+    idempotencyKey: string;
+    /**
+     * location selects where the sandbox runs, such as "eu-1" or "us-1" (see
+     * ProvisioningService.ListLocations). Omission selects eu-1. US East requires
+     * explicit us-1 placement and an accepted quote; no automatic fallback.
+     * Explicit location is a hard constraint. Once selected it never changes,
+     * including after a failed launch. Location is part of the fingerprint.
+     */
+    location: string;
+    /** Required for us-1; optional for legacy EU clients. */
+    acceptedQuoteId: string;
+    /** US East allocation; EU sandboxes retain their fixed 1 vCPU / 1 GiB profile. */
+    resources: JobResources | undefined;
+    /** US East omission defaults to 1 GiB; zero disables outbound networking. */
+    maxNetworkBytes?: bigint | undefined;
+}
+/** GetCodeSandboxRequest selects one organization sandbox. */
+export interface GetCodeSandboxRequest {
+    orgId: string;
+    sandboxId: string;
+}
+/** DeleteCodeSandboxRequest selects one organization sandbox to stop and delete. */
+export interface DeleteCodeSandboxRequest {
+    orgId: string;
+    sandboxId: string;
+}
+/** ExecuteRequest runs source code in an existing ready sandbox. */
+export interface ExecuteRequest {
+    orgId: string;
+    sandboxId: string;
+    /** code is interpreted according to the sandbox template's runtime. */
+    code: string;
+    /** stdin is supplied verbatim to the program's standard input. */
+    stdin: string;
+    /** timeout_seconds is the execution limit within platform bounds. */
+    timeoutSeconds: number;
+    /**
+     * idempotency_key safely retries this mutation for 24 hours. The same key
+     * cannot be reused with different request content.
+     */
+    idempotencyKey: string;
+}
+/** GetExecutionRequest selects one execution within an organization sandbox. */
+export interface GetExecutionRequest {
+    orgId: string;
+    sandboxId: string;
+    executionId: string;
+}
+/** Execution is one source-code run and its retained output. */
+export interface Execution {
+    id: string;
+    sandboxId: string;
+    status: ExecutionStatus;
+    /** stdout is empty after its retention deadline. */
+    stdout: string;
+    /** stderr is empty after its retention deadline. */
+    stderr: string;
+    exitCode: number;
+    durationMs: number;
+    /** output_truncated indicates that stdout or stderr exceeded platform limits. */
+    outputTruncated: boolean;
+    /** error_code is a stable machine-readable platform/runtime failure code. */
+    errorCode: string;
+    createdAt: Date | undefined;
+    completedAt: Date | undefined;
+    /**
+     * output_expires_at is the output retention deadline. Execution metadata
+     * remains available after output expires.
+     */
+    outputExpiresAt: Date | undefined;
+}
+export declare const SandboxTemplate: MessageFns<SandboxTemplate>;
+export declare const ListSandboxTemplatesRequest: MessageFns<ListSandboxTemplatesRequest>;
+export declare const ListSandboxTemplatesResponse: MessageFns<ListSandboxTemplatesResponse>;
+export declare const CreateSandboxTemplateRequest: MessageFns<CreateSandboxTemplateRequest>;
+export declare const GetSandboxTemplateRequest: MessageFns<GetSandboxTemplateRequest>;
+export declare const DeleteSandboxTemplateRequest: MessageFns<DeleteSandboxTemplateRequest>;
+export declare const CodeSandbox: MessageFns<CodeSandbox>;
+export declare const ListSandboxesRequest: MessageFns<ListSandboxesRequest>;
+export declare const ListSandboxesResponse: MessageFns<ListSandboxesResponse>;
+export declare const CreateCodeSandboxRequest: MessageFns<CreateCodeSandboxRequest>;
+export declare const GetCodeSandboxRequest: MessageFns<GetCodeSandboxRequest>;
+export declare const DeleteCodeSandboxRequest: MessageFns<DeleteCodeSandboxRequest>;
+export declare const ExecuteRequest: MessageFns<ExecuteRequest>;
+export declare const GetExecutionRequest: MessageFns<GetExecutionRequest>;
+export declare const Execution: MessageFns<Execution>;
+/**
+ * SandboxService exposes deliberately narrow code execution. It does not
+ * accept container images, commands, ports, mounts, shell sessions, browsers,
+ * or persistent volumes.
+ */
+export type SandboxServiceDefinition = typeof SandboxServiceDefinition;
+export declare const SandboxServiceDefinition: {
+    readonly name: "SandboxService";
+    readonly fullName: "tarka.provisioning.v1.SandboxService";
+    readonly methods: {
+        /**
+         * ListSandboxTemplates returns built-in and organization-owned templates
+         * visible to the caller.
+         */
+        readonly listSandboxTemplates: {
+            readonly name: "ListSandboxTemplates";
+            readonly requestType: typeof ListSandboxTemplatesRequest;
+            readonly requestStream: false;
+            readonly responseType: typeof ListSandboxTemplatesResponse;
+            readonly responseStream: false;
+            readonly options: {
+                readonly _unknownFields: {
+                    readonly 578365826: readonly [Buffer<ArrayBufferLike>];
+                };
+            };
+        };
+        /**
+         * CreateSandboxTemplate builds an immutable dependency revision and
+         * idempotently returns the resulting template.
+         */
+        readonly createSandboxTemplate: {
+            readonly name: "CreateSandboxTemplate";
+            readonly requestType: typeof CreateSandboxTemplateRequest;
+            readonly requestStream: false;
+            readonly responseType: typeof SandboxTemplate;
+            readonly responseStream: false;
+            readonly options: {
+                readonly _unknownFields: {
+                    readonly 578365826: readonly [Buffer<ArrayBufferLike>];
+                };
+            };
+        };
+        /** GetSandboxTemplate returns a template by identifier. */
+        readonly getSandboxTemplate: {
+            readonly name: "GetSandboxTemplate";
+            readonly requestType: typeof GetSandboxTemplateRequest;
+            readonly requestStream: false;
+            readonly responseType: typeof SandboxTemplate;
+            readonly responseStream: false;
+            readonly options: {
+                readonly _unknownFields: {
+                    readonly 578365826: readonly [Buffer<ArrayBufferLike>];
+                };
+            };
+        };
+        /** DeleteSandboxTemplate retires a template that has no active sandboxes. */
+        readonly deleteSandboxTemplate: {
+            readonly name: "DeleteSandboxTemplate";
+            readonly requestType: typeof DeleteSandboxTemplateRequest;
+            readonly requestStream: false;
+            readonly responseType: typeof SandboxTemplate;
+            readonly responseStream: false;
+            readonly options: {
+                readonly _unknownFields: {
+                    readonly 578365826: readonly [Buffer<ArrayBufferLike>];
+                };
+            };
+        };
+        /** ListSandboxes returns non-deleted sandboxes for an organization. */
+        readonly listSandboxes: {
+            readonly name: "ListSandboxes";
+            readonly requestType: typeof ListSandboxesRequest;
+            readonly requestStream: false;
+            readonly responseType: typeof ListSandboxesResponse;
+            readonly responseStream: false;
+            readonly options: {
+                readonly _unknownFields: {
+                    readonly 578365826: readonly [Buffer<ArrayBufferLike>];
+                };
+            };
+        };
+        /** CreateSandbox starts an isolated sandbox from a ready template. */
+        readonly createSandbox: {
+            readonly name: "CreateSandbox";
+            readonly requestType: typeof CreateCodeSandboxRequest;
+            readonly requestStream: false;
+            readonly responseType: typeof CodeSandbox;
+            readonly responseStream: false;
+            readonly options: {
+                readonly _unknownFields: {
+                    readonly 578365826: readonly [Buffer<ArrayBufferLike>];
+                };
+            };
+        };
+        /** GetSandbox returns a sandbox by identifier. */
+        readonly getSandbox: {
+            readonly name: "GetSandbox";
+            readonly requestType: typeof GetCodeSandboxRequest;
+            readonly requestStream: false;
+            readonly responseType: typeof CodeSandbox;
+            readonly responseStream: false;
+            readonly options: {
+                readonly _unknownFields: {
+                    readonly 578365826: readonly [Buffer<ArrayBufferLike>];
+                };
+            };
+        };
+        /** DeleteSandbox stops and deletes a sandbox. Repeated deletion is safe. */
+        readonly deleteSandbox: {
+            readonly name: "DeleteSandbox";
+            readonly requestType: typeof DeleteCodeSandboxRequest;
+            readonly requestStream: false;
+            readonly responseType: typeof CodeSandbox;
+            readonly responseStream: false;
+            readonly options: {
+                readonly _unknownFields: {
+                    readonly 578365826: readonly [Buffer<ArrayBufferLike>];
+                };
+            };
+        };
+        /** Execute runs one source-code payload in a ready sandbox. */
+        readonly execute: {
+            readonly name: "Execute";
+            readonly requestType: typeof ExecuteRequest;
+            readonly requestStream: false;
+            readonly responseType: typeof Execution;
+            readonly responseStream: false;
+            readonly options: {
+                readonly _unknownFields: {
+                    readonly 578365826: readonly [Buffer<ArrayBufferLike>];
+                };
+            };
+        };
+        /** GetExecution returns execution status and retained output. */
+        readonly getExecution: {
+            readonly name: "GetExecution";
+            readonly requestType: typeof GetExecutionRequest;
+            readonly requestStream: false;
+            readonly responseType: typeof Execution;
+            readonly responseStream: false;
+            readonly options: {
+                readonly _unknownFields: {
+                    readonly 578365826: readonly [Buffer<ArrayBufferLike>];
+                };
+            };
+        };
+    };
+};
+type Builtin = Date | Function | Uint8Array | string | number | boolean | bigint | undefined;
+export type DeepPartial<T> = T extends bigint ? string | number | bigint : T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {
+    $case: string;
+    value: unknown;
+} ? {
+    $case: T["$case"];
+    value?: DeepPartial<T["value"]>;
+} : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+export interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    fromJSON(object: any): T;
+    toJSON(message: T): unknown;
+    create(base?: DeepPartial<T>): T;
+    fromPartial(object: DeepPartial<T>): T;
+}
+export {};