tensorlake 0.4.39

package/dist/index.d.cts

@@ -0,0 +1,581 @@
+declare enum SandboxStatus {
+    PENDING = "pending",
+    RUNNING = "running",
+    SNAPSHOTTING = "snapshotting",
+    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 {
+    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;
+}
+interface CreateSandboxResponse {
+    sandboxId: string;
+    status: SandboxStatus;
+}
+interface SandboxInfo {
+    sandboxId: string;
+    namespace: string;
+    status: SandboxStatus;
+    image?: string;
+    resources: ContainerResourcesInfo;
+    secretNames: string[];
+    timeoutSecs?: number;
+    entrypoint?: string[];
+    network?: NetworkConfig;
+    poolId?: string;
+    outcome?: string;
+    createdAt?: Date;
+    terminatedAt?: Date;
+    name?: 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 {
+    image: string;
+    cpus?: number;
+    memoryMb?: number;
+    ephemeralDiskMb?: number;
+    secretNames?: string[];
+    timeoutSecs?: number;
+    entrypoint?: string[];
+    maxContainers?: number;
+    warmContainers?: number;
+}
+interface UpdatePoolOptions {
+    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;
+    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;
+}
+
+/**
+ * Client for interacting with a running sandbox.
+ *
+ * Provides process management, file operations, and I/O streaming
+ * through the sandbox proxy.
+ */
+declare class Sandbox {
+    readonly sandboxId: string;
+    private readonly http;
+    private readonly baseUrl;
+    private ownsSandbox;
+    private lifecycleClient;
+    constructor(options: SandboxOptions);
+    /** @internal Used by SandboxClient.createAndConnect to set ownership. */
+    _setOwner(client: SandboxClient): void;
+    close(): void;
+    terminate(): Promise<void>;
+    run(command: string, options?: RunOptions): Promise<CommandResult>;
+    startProcess(command: string, options?: StartProcessOptions): Promise<ProcessInfo>;
+    listProcesses(): Promise<ProcessInfo[]>;
+    getProcess(pid: number): Promise<ProcessInfo>;
+    killProcess(pid: number): Promise<void>;
+    sendSignal(pid: number, signal: number): Promise<SendSignalResponse>;
+    writeStdin(pid: number, data: Uint8Array): Promise<void>;
+    closeStdin(pid: number): Promise<void>;
+    getStdout(pid: number): Promise<OutputResponse>;
+    getStderr(pid: number): Promise<OutputResponse>;
+    getOutput(pid: number): Promise<OutputResponse>;
+    followStdout(pid: number, options?: {
+        signal?: AbortSignal;
+    }): AsyncIterable<OutputEvent>;
+    followStderr(pid: number, options?: {
+        signal?: AbortSignal;
+    }): AsyncIterable<OutputEvent>;
+    followOutput(pid: number, options?: {
+        signal?: AbortSignal;
+    }): AsyncIterable<OutputEvent>;
+    readFile(path: string): Promise<Uint8Array>;
+    writeFile(path: string, content: Uint8Array): Promise<void>;
+    deleteFile(path: string): Promise<void>;
+    listDirectory(path: string): Promise<ListDirectoryResponse>;
+    createPtySession(options: CreatePtySessionOptions): Promise<PtySessionInfo>;
+    ptyWsUrl(sessionId: string, token: string): string;
+    health(): Promise<HealthResponse>;
+    info(): Promise<DaemonInfo>;
+}
+
+/**
+ * Client for managing TensorLake sandboxes, pools, and snapshots.
+ *
+ * Use `SandboxClient.forCloud()` or `SandboxClient.forLocalhost()` for
+ * clearer construction depending on your deployment target.
+ */
+declare class SandboxClient {
+    private readonly http;
+    private readonly apiUrl;
+    private readonly apiKey;
+    private readonly organizationId;
+    private readonly projectId;
+    private readonly namespace;
+    private readonly local;
+    constructor(options?: SandboxClientOptions);
+    /** Create a client for the TensorLake cloud platform. */
+    static forCloud(options?: {
+        apiKey?: string;
+        organizationId?: string;
+        projectId?: string;
+        apiUrl?: string;
+    }): SandboxClient;
+    /** Create a client for a local Indexify server. */
+    static forLocalhost(options?: {
+        apiUrl?: string;
+        namespace?: string;
+    }): SandboxClient;
+    close(): void;
+    private path;
+    create(options?: CreateSandboxOptions): Promise<CreateSandboxResponse>;
+    get(sandboxId: string): Promise<SandboxInfo>;
+    list(): Promise<SandboxInfo[]>;
+    update(sandboxId: string, options: UpdateSandboxOptions): Promise<SandboxInfo>;
+    delete(sandboxId: string): Promise<void>;
+    claim(poolId: string): Promise<CreateSandboxResponse>;
+    snapshot(sandboxId: string): Promise<CreateSnapshotResponse>;
+    getSnapshot(snapshotId: string): Promise<SnapshotInfo>;
+    listSnapshots(): Promise<SnapshotInfo[]>;
+    deleteSnapshot(snapshotId: string): Promise<void>;
+    snapshotAndWait(sandboxId: string, options?: SnapshotAndWaitOptions): Promise<SnapshotInfo>;
+    createPool(options: CreatePoolOptions): Promise<CreateSandboxPoolResponse>;
+    getPool(poolId: string): Promise<SandboxPoolInfo>;
+    listPools(): Promise<SandboxPoolInfo[]>;
+    updatePool(poolId: string, options: UpdatePoolOptions): Promise<SandboxPoolInfo>;
+    deletePool(poolId: string): Promise<void>;
+    connect(sandboxId: string, proxyUrl?: string): Sandbox;
+    createAndConnect(options?: CreateAndConnectOptions): Promise<Sandbox>;
+}
+
+type BinaryPayload = Uint8Array | ArrayBuffer | Blob | string;
+interface CloudClientOptions {
+    apiUrl?: string;
+    apiKey?: string;
+    organizationId?: string;
+    projectId?: string;
+    namespace?: string;
+    maxRetries?: number;
+    retryBackoffMs?: number;
+}
+interface RequestInput {
+    name: string;
+    data: BinaryPayload;
+    contentType: string;
+}
+interface ApplicationSummary {
+    createdAt?: Date;
+    description: string;
+    entrypoint?: Record<string, unknown>;
+    functions?: Record<string, unknown>;
+    name: string;
+    namespace?: string;
+    state?: unknown;
+    tags: Record<string, string>;
+    tombstoned?: boolean;
+    version: string;
+}
+type ApplicationManifest = Record<string, unknown>;
+interface RequestErrorInfo {
+    functionName: string;
+    message: string;
+}
+interface RequestMetadata {
+    id: string;
+    outcome?: Record<string, unknown> | string;
+    applicationVersion: string;
+    createdAt: Date;
+    requestError?: RequestErrorInfo;
+    functionRuns?: Record<string, unknown>[];
+    progressUpdates?: Record<string, unknown>[];
+    updatesPaginationToken?: string;
+}
+interface RequestOutput {
+    serializedValue: Uint8Array;
+    contentType: string;
+}
+type ApiKeyIntrospection = Record<string, unknown>;
+interface NewSecret {
+    name: string;
+    value: string;
+}
+interface Secret {
+    id: string;
+    name: string;
+    createdAt?: Date;
+}
+interface SecretsPagination {
+    next?: string;
+    prev?: string;
+    total: number;
+}
+interface SecretsList {
+    items: Secret[];
+    pagination: SecretsPagination;
+}
+type UpsertSecretResponse = Secret | Secret[];
+interface BuildInfo {
+    id: string;
+    status: string;
+    createdAt?: Date;
+    updatedAt?: Date;
+    finishedAt?: Date;
+    errorMessage?: string;
+    imageHash?: string;
+    imageName?: string;
+}
+interface BuildLogEntry {
+    buildId: string;
+    timestamp?: Date;
+    stream: string;
+    message: string;
+    sequenceNumber: number;
+    buildStatus: string;
+}
+interface StartImageBuildRequest {
+    applicationName: string;
+    applicationVersion: string;
+    functionName: string;
+    imageName: string;
+    imageId: string;
+    buildContext: BinaryPayload;
+}
+interface CreateApplicationBuildImageRequest {
+    key: string;
+    name?: string;
+    description?: string;
+    contextTarPartName: string;
+    contextSha256: string;
+    functionNames: string[];
+}
+interface CreateApplicationBuildRequest {
+    name: string;
+    version: string;
+    images: CreateApplicationBuildImageRequest[];
+}
+interface ApplicationBuildContext {
+    contextTarPartName: string;
+    contextTarGz: BinaryPayload;
+}
+interface ApplicationBuildImageResult {
+    id: string;
+    appVersionId?: string;
+    key?: string;
+    name?: string;
+    description?: string;
+    contextSha256?: string;
+    status: string;
+    errorMessage?: string;
+    imageUri?: string;
+    imageDigest?: string;
+    createdAt?: Date;
+    updatedAt?: Date;
+    finishedAt?: Date;
+    functionNames?: string[];
+}
+interface ApplicationBuildResponse {
+    id: string;
+    organizationId: string;
+    projectId: string;
+    name: string;
+    version: string;
+    status?: string;
+    createdAt?: Date;
+    updatedAt?: Date;
+    finishedAt?: Date;
+    imageBuilds: ApplicationBuildImageResult[];
+}
+
+declare class CloudClient {
+    private readonly http;
+    private readonly organizationId?;
+    private readonly projectId?;
+    private readonly namespace;
+    constructor(options?: CloudClientOptions);
+    static forCloud(options?: CloudClientOptions): CloudClient;
+    close(): void;
+    upsertApplication(manifest: ApplicationManifest, codeZip: BinaryPayload, upgradeRunningRequests?: boolean): Promise<void>;
+    deleteApplication(applicationName: string): Promise<void>;
+    applications(): Promise<ApplicationSummary[]>;
+    applicationManifest(applicationName: string): Promise<ApplicationManifest>;
+    runRequest(applicationName: string, inputs?: RequestInput[]): Promise<string>;
+    waitOnRequestCompletion(applicationName: string, requestId: string): Promise<void>;
+    requestMetadata(applicationName: string, requestId: string): Promise<RequestMetadata>;
+    requestOutput(applicationName: string, requestId: string): Promise<RequestOutput>;
+    introspectApiKey(): Promise<ApiKeyIntrospection>;
+    listSecrets(options?: {
+        organizationId?: string;
+        projectId?: string;
+        pageSize?: number;
+    }): Promise<SecretsList>;
+    getSecret(secretId: string, options?: {
+        organizationId?: string;
+        projectId?: string;
+    }): Promise<Secret>;
+    upsertSecrets(secrets: NewSecret | NewSecret[], options?: {
+        organizationId?: string;
+        projectId?: string;
+    }): Promise<UpsertSecretResponse>;
+    deleteSecret(secretId: string, options?: {
+        organizationId?: string;
+        projectId?: string;
+    }): Promise<void>;
+    startImageBuild(buildServicePath: string, request: StartImageBuildRequest): Promise<BuildInfo>;
+    createApplicationBuild(buildServicePath: string, request: CreateApplicationBuildRequest, imageContexts: ApplicationBuildContext[]): Promise<ApplicationBuildResponse>;
+    applicationBuildInfo(buildServicePath: string, applicationBuildId: string): Promise<ApplicationBuildResponse>;
+    cancelApplicationBuild(buildServicePath: string, applicationBuildId: string): Promise<ApplicationBuildResponse>;
+    buildInfo(buildServicePath: string, buildId: string): Promise<BuildInfo>;
+    cancelBuild(buildServicePath: string, buildId: string): Promise<void>;
+    streamBuildLogs(buildServicePath: string, buildId: string, signal?: AbortSignal): AsyncIterable<BuildLogEntry>;
+    private runMultipartRequest;
+    private namespacePath;
+    private resolveScope;
+}
+
+declare class APIClient {
+    private readonly cloudClient;
+    constructor(options?: CloudClientOptions);
+    close(): void;
+    upsertApplication(manifest: ApplicationManifest, codeZip: Uint8Array | ArrayBuffer | Blob | string, upgradeRunningRequests?: boolean): Promise<void>;
+    deleteApplication(applicationName: string): Promise<void>;
+    applications(): Promise<ApplicationSummary[]>;
+    application(applicationName: string): Promise<ApplicationManifest>;
+    runRequest(applicationName: string, inputs: RequestInput[]): Promise<string>;
+    waitOnRequestCompletion(applicationName: string, requestId: string): Promise<void>;
+    requestOutput(applicationName: string, requestId: string): Promise<RequestOutput>;
+}
+
+/** Base exception for all sandbox-related errors. */
+declare class SandboxException extends Error {
+    constructor(message: string);
+}
+/** General sandbox operation error. */
+declare class SandboxError extends SandboxException {
+    constructor(message: string);
+}
+/** Raised when the client cannot connect to the API server. */
+declare class SandboxConnectionError extends SandboxError {
+    constructor(message: string);
+}
+/** Raised when a sandbox is not found. */
+declare class SandboxNotFoundError extends SandboxError {
+    readonly sandboxId: string;
+    constructor(sandboxId: string);
+}
+/** Raised when a sandbox pool is not found. */
+declare class PoolNotFoundError extends SandboxError {
+    readonly poolId: string;
+    constructor(poolId: string);
+}
+/** Raised when attempting to delete a pool that is in use. */
+declare class PoolInUseError extends SandboxError {
+    readonly poolId: string;
+    constructor(poolId: string, message?: string);
+}
+/** Raised when the remote API returns an error. */
+declare class RemoteAPIError extends SandboxError {
+    readonly statusCode: number;
+    readonly responseMessage: string;
+    constructor(statusCode: number, message: string);
+}
+/** Raised when request output is fetched before the request has completed. */
+declare class RequestNotFinishedError extends Error {
+    constructor();
+}
+/** Raised when a request completed unsuccessfully. */
+declare class RequestFailedError extends Error {
+    readonly failure: string;
+    constructor(failure: string);
+}
+/** Raised when a request surfaced an application-level error. */
+declare class RequestExecutionError extends Error {
+    readonly functionName?: string;
+    constructor(message: string, functionName?: string);
+}
+
+export { APIClient, type ApiKeyIntrospection, type ApplicationBuildContext, type ApplicationBuildImageResult, type ApplicationBuildResponse, type ApplicationManifest, type ApplicationSummary, type BinaryPayload, type BuildInfo, type BuildLogEntry, CloudClient, type CloudClientOptions, type CommandResult, type ContainerResourcesInfo, ContainerState, type CreateAndConnectOptions, type CreateApplicationBuildImageRequest, type CreateApplicationBuildRequest, type CreatePoolOptions, type CreatePtySessionOptions, type CreateSandboxOptions, type CreateSandboxPoolResponse, type CreateSandboxResponse, type CreateSnapshotResponse, type DaemonInfo, type DirectoryEntry, type HealthResponse, type ListDirectoryResponse, type NetworkConfig, type NewSecret, type OutputEvent, OutputMode, type OutputResponse, type PoolContainerInfo, PoolInUseError, PoolNotFoundError, type ProcessInfo, ProcessStatus, type PtySessionInfo, RemoteAPIError, type RequestErrorInfo, RequestExecutionError, RequestFailedError, type RequestInput, type RequestMetadata, RequestNotFinishedError, type RequestOutput, type RunOptions, Sandbox, SandboxClient, type SandboxClientOptions, SandboxConnectionError, SandboxError, SandboxException, type SandboxInfo, SandboxNotFoundError, type SandboxOptions, type SandboxPoolInfo, SandboxStatus, type Secret, type SecretsList, type SecretsPagination, type SendSignalResponse, type SnapshotAndWaitOptions, type SnapshotInfo, SnapshotStatus, type StartImageBuildRequest, type StartProcessOptions, StdinMode, type UpdatePoolOptions, type UpsertSecretResponse };