tensorlake 0.4.40 → 0.4.42

package/dist/sandbox-image-DKPhc4Lv.d.ts

@@ -0,0 +1,375 @@
+declare enum SandboxStatus {
+    PENDING = "pending",
+    RUNNING = "running",
+    SNAPSHOTTING = "snapshotting",
+    SUSPENDING = "suspending",
+    SUSPENDED = "suspended",
+    TERMINATED = "terminated"
+}
+declare enum SnapshotStatus {
+    IN_PROGRESS = "in_progress",
+    COMPLETED = "completed",
+    FAILED = "failed"
+}
+declare enum ProcessStatus {
+    RUNNING = "running",
+    EXITED = "exited",
+    SIGNALED = "signaled"
+}
+declare enum StdinMode {
+    CLOSED = "closed",
+    PIPE = "pipe"
+}
+declare enum OutputMode {
+    CAPTURE = "capture",
+    DISCARD = "discard"
+}
+declare enum ContainerState {
+    IDLE = "Idle",
+    RUNNING = "Running"
+}
+interface ContainerResourcesInfo {
+    cpus: number;
+    memoryMb: number;
+    ephemeralDiskMb: number;
+}
+interface NetworkConfig {
+    allowInternetAccess: boolean;
+    allowOut: string[];
+    denyOut: string[];
+}
+interface CreateSandboxOptions {
+    /** Optional sandbox image name, such as `ubuntu-minimal` or a registered Sandbox Image. When omitted, Tensorlake uses the default managed environment. */
+    image?: string;
+    cpus?: number;
+    memoryMb?: number;
+    ephemeralDiskMb?: number;
+    secretNames?: string[];
+    timeoutSecs?: number;
+    entrypoint?: string[];
+    allowInternetAccess?: boolean;
+    allowOut?: string[];
+    denyOut?: string[];
+    snapshotId?: string;
+    /** Optional name for the sandbox. Named sandboxes support suspend/resume. When absent the sandbox is ephemeral. */
+    name?: string;
+}
+interface UpdateSandboxOptions {
+    /** New name for the sandbox. Naming an ephemeral sandbox enables suspend/resume. */
+    name?: string;
+    /** Whether exposed user ports should be reachable without TensorLake auth. */
+    allowUnauthenticatedAccess?: boolean;
+    /** User ports that should be routable through the sandbox proxy. Port 9501 is reserved. */
+    exposedPorts?: number[];
+}
+interface CreateSandboxResponse {
+    sandboxId: string;
+    status: SandboxStatus;
+}
+interface SandboxInfo {
+    sandboxId: string;
+    namespace: string;
+    status: SandboxStatus;
+    /** Resolved sandbox image name. */
+    image?: string;
+    resources: ContainerResourcesInfo;
+    secretNames: string[];
+    timeoutSecs?: number;
+    entrypoint?: string[];
+    network?: NetworkConfig;
+    poolId?: string;
+    outcome?: string;
+    createdAt?: Date;
+    terminatedAt?: Date;
+    name?: string;
+    allowUnauthenticatedAccess?: boolean;
+    exposedPorts?: number[];
+    sandboxUrl?: string;
+}
+interface SandboxPortAccess {
+    allowUnauthenticatedAccess: boolean;
+    exposedPorts: number[];
+    sandboxUrl?: string;
+}
+interface CreateSnapshotResponse {
+    snapshotId: string;
+    status: SnapshotStatus;
+}
+interface SnapshotInfo {
+    snapshotId: string;
+    namespace: string;
+    sandboxId: string;
+    baseImage: string;
+    status: SnapshotStatus;
+    error?: string;
+    snapshotUri?: string;
+    sizeBytes?: number;
+    createdAt?: Date;
+}
+interface SnapshotAndWaitOptions {
+    timeout?: number;
+    pollInterval?: number;
+}
+interface CreatePoolOptions {
+    /** Sandbox image name, such as `ubuntu-minimal` or a registered Sandbox Image. */
+    image: string;
+    cpus?: number;
+    memoryMb?: number;
+    ephemeralDiskMb?: number;
+    secretNames?: string[];
+    timeoutSecs?: number;
+    entrypoint?: string[];
+    maxContainers?: number;
+    warmContainers?: number;
+}
+interface UpdatePoolOptions {
+    /** Sandbox image name, such as `ubuntu-minimal` or a registered Sandbox Image. */
+    image: string;
+    cpus?: number;
+    memoryMb?: number;
+    ephemeralDiskMb?: number;
+    secretNames?: string[];
+    timeoutSecs?: number;
+    entrypoint?: string[];
+    maxContainers?: number;
+    warmContainers?: number;
+}
+interface CreateSandboxPoolResponse {
+    poolId: string;
+    namespace: string;
+}
+interface PoolContainerInfo {
+    id: string;
+    state: string;
+    sandboxId?: string;
+    executorId: string;
+}
+interface SandboxPoolInfo {
+    poolId: string;
+    namespace: string;
+    /** Sandbox image name backing the pool. */
+    image: string;
+    resources: ContainerResourcesInfo;
+    secretNames: string[];
+    timeoutSecs: number;
+    entrypoint?: string[];
+    maxContainers?: number;
+    warmContainers?: number;
+    containers?: PoolContainerInfo[];
+    createdAt?: Date;
+    updatedAt?: Date;
+}
+interface StartProcessOptions {
+    args?: string[];
+    env?: Record<string, string>;
+    workingDir?: string;
+    stdinMode?: StdinMode;
+    stdoutMode?: OutputMode;
+    stderrMode?: OutputMode;
+}
+interface ProcessInfo {
+    pid: number;
+    status: ProcessStatus;
+    exitCode?: number;
+    signal?: number;
+    stdinWritable: boolean;
+    command: string;
+    args: string[];
+    startedAt: Date;
+    endedAt?: Date;
+}
+interface SendSignalResponse {
+    success: boolean;
+}
+interface OutputResponse {
+    pid: number;
+    lines: string[];
+    lineCount: number;
+}
+interface OutputEvent {
+    line: string;
+    timestamp: Date;
+    stream?: string;
+}
+interface RunOptions {
+    args?: string[];
+    env?: Record<string, string>;
+    workingDir?: string;
+    timeout?: number;
+}
+interface CommandResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}
+interface DirectoryEntry {
+    name: string;
+    isDir: boolean;
+    size?: number;
+    modifiedAt?: Date;
+}
+interface ListDirectoryResponse {
+    path: string;
+    entries: DirectoryEntry[];
+}
+interface CreatePtySessionOptions {
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+    workingDir?: string;
+    rows?: number;
+    cols?: number;
+}
+interface PtySessionInfo {
+    sessionId: string;
+    token: string;
+}
+interface HealthResponse {
+    healthy: boolean;
+}
+interface DaemonInfo {
+    version: string;
+    uptimeSecs: number;
+    runningProcesses: number;
+    totalProcesses: number;
+}
+interface SandboxClientOptions {
+    apiUrl?: string;
+    apiKey?: string;
+    organizationId?: string;
+    projectId?: string;
+    namespace?: string;
+    maxRetries?: number;
+    retryBackoffMs?: number;
+}
+interface SandboxOptions {
+    sandboxId: string;
+    proxyUrl?: string;
+    apiKey?: string;
+    organizationId?: string;
+    projectId?: string;
+}
+interface CreateAndConnectOptions extends CreateSandboxOptions {
+    poolId?: string;
+    proxyUrl?: string;
+    startupTimeout?: number;
+}
+
+declare const ImageBuildOperationType: {
+    readonly ADD: "ADD";
+    readonly COPY: "COPY";
+    readonly ENV: "ENV";
+    readonly RUN: "RUN";
+    readonly WORKDIR: "WORKDIR";
+};
+type ImageBuildOperationType = (typeof ImageBuildOperationType)[keyof typeof ImageBuildOperationType];
+interface ImageBuildOperation {
+    type: ImageBuildOperationType;
+    args: string[];
+    options: Record<string, string>;
+}
+interface ImageOptions {
+    name?: string;
+    tag?: string;
+    baseImage?: string | null;
+}
+declare class Image {
+    readonly _id: string;
+    readonly _name: string;
+    readonly _tag: string;
+    readonly _baseImage: string | null;
+    readonly _buildOperations: ImageBuildOperation[];
+    constructor();
+    constructor(name: string, tag?: string, baseImage?: string | null);
+    constructor(options: ImageOptions);
+    get name(): string;
+    get tag(): string;
+    get baseImage(): string | null;
+    get buildOperations(): ImageBuildOperation[];
+    add(src: string, dest: string, options?: Record<string, string> | undefined): this;
+    copy(src: string, dest: string, options?: Record<string, string> | undefined): this;
+    env(key: string, value: string): this;
+    run(commands: string | string[], options?: Record<string, string> | undefined): this;
+    workdir(directory: string): this;
+    private _addOperation;
+}
+declare function dockerfileContent(image: Image): string;
+
+interface DockerfileInstruction {
+    keyword: string;
+    value: string;
+    lineNumber: number;
+}
+interface DockerfileBuildPlan {
+    dockerfilePath: string;
+    contextDir: string;
+    registeredName: string;
+    dockerfileText: string;
+    baseImage?: string;
+    instructions: DockerfileInstruction[];
+}
+interface CreateSandboxImageOptions {
+    registeredName?: string;
+    cpus?: number;
+    memoryMb?: number;
+    isPublic?: boolean;
+    contextDir?: string;
+}
+type SandboxImageSource = string | Image;
+interface BuildContext {
+    apiUrl: string;
+    apiKey?: string;
+    personalAccessToken?: string;
+    namespace: string;
+    organizationId?: string;
+    projectId?: string;
+    debug: boolean;
+}
+interface BuildSandbox {
+    sandboxId: string;
+    run(command: string, options?: {
+        args?: string[];
+        env?: Record<string, string>;
+        workingDir?: string;
+        timeout?: number;
+    }): Promise<CommandResult>;
+    startProcess(command: string, options?: {
+        args?: string[];
+        env?: Record<string, string>;
+        workingDir?: string;
+    }): Promise<ProcessInfo>;
+    getStdout(pid: number): Promise<OutputResponse>;
+    getStderr(pid: number): Promise<OutputResponse>;
+    getProcess(pid: number): Promise<ProcessInfo>;
+    writeFile(path: string, content: Uint8Array): Promise<void>;
+    terminate(): Promise<void>;
+}
+interface BuildClient {
+    createAndConnect(options: {
+        image?: string;
+        cpus?: number;
+        memoryMb?: number;
+    }): Promise<BuildSandbox>;
+    snapshotAndWait(sandboxId: string, options?: {
+        timeout?: number;
+        pollInterval?: number;
+    }): Promise<SnapshotInfo>;
+    close(): void;
+}
+interface CreateSandboxImageDeps {
+    emit?: (event: Record<string, unknown>) => void;
+    createClient?: (context: BuildContext) => BuildClient;
+    registerImage?: (context: BuildContext, name: string, dockerfile: string, snapshotId: string, snapshotUri: string, isPublic: boolean) => Promise<Record<string, unknown>>;
+    sleep?: (ms: number) => Promise<void>;
+}
+declare function defaultRegisteredName(dockerfilePath: string): string;
+declare function logicalDockerfileLines(dockerfileText: string): Array<{
+    lineNumber: number;
+    line: string;
+}>;
+declare function loadDockerfilePlan(dockerfilePath: string, registeredName?: string): Promise<DockerfileBuildPlan>;
+declare function loadImagePlan(image: Image, options?: Pick<CreateSandboxImageOptions, "registeredName" | "contextDir">): DockerfileBuildPlan;
+declare function createSandboxImage(source: SandboxImageSource, options?: CreateSandboxImageOptions, deps?: CreateSandboxImageDeps): Promise<Record<string, unknown>>;
+declare function runCreateSandboxImageCli(argv?: string[]): Promise<void>;
+
+export { type ImageOptions as A, OutputMode as B, type CreatePtySessionOptions as C, type DaemonInfo as D, type PoolContainerInfo as E, ProcessStatus as F, type SandboxImageSource as G, type HealthResponse as H, Image as I, SandboxStatus as J, SnapshotStatus as K, type ListDirectoryResponse as L, StdinMode as M, type NetworkConfig as N, type OutputResponse as O, type ProcessInfo as P, createSandboxImage as Q, type RunOptions as R, type SandboxOptions as S, dockerfileContent as T, type UpdateSandboxOptions as U, defaultRegisteredName as V, loadDockerfilePlan as W, loadImagePlan as X, logicalDockerfileLines as Y, runCreateSandboxImageCli as Z, type CommandResult as a, type StartProcessOptions as b, type SendSignalResponse as c, type OutputEvent as d, type PtySessionInfo as e, type SandboxClientOptions as f, type CreateSandboxOptions as g, type CreateSandboxResponse as h, type SandboxInfo as i, type SandboxPortAccess as j, type CreateSnapshotResponse as k, type SnapshotInfo as l, type SnapshotAndWaitOptions as m, type CreatePoolOptions as n, type CreateSandboxPoolResponse as o, type SandboxPoolInfo as p, type UpdatePoolOptions as q, type CreateAndConnectOptions as r, type ContainerResourcesInfo as s, ContainerState as t, type CreateSandboxImageOptions as u, type DirectoryEntry as v, type DockerfileBuildPlan as w, type DockerfileInstruction as x, type ImageBuildOperation as y, ImageBuildOperationType as z };