withruntime 0.8.4 → 0.9.0

package/dist/sprites/index.d.ts

@@ -0,0 +1,251 @@
+import { EventEmitter } from "node:events";
+import { PassThrough, Writable } from "node:stream";
+import type { Runtime } from "../client.js";
+import type { Sandbox } from "../sandbox.js";
+import { CompatibilityError, type ClientOptions as RuntimeClientOptions } from "../compat/core.js";
+export { CompatibilityError };
+export interface ClientOptions extends RuntimeClientOptions {
+    baseURL?: string;
+    timeout?: number;
+    controlMode?: boolean;
+}
+export interface SpriteConfig {
+    ramMB?: number;
+    cpus?: number;
+    region?: string;
+    storageGB?: number;
+}
+export interface CreateSpriteOptions {
+    config?: SpriteConfig;
+    environment?: Record<string, string>;
+    labels?: string[];
+    urlSettings?: {
+        auth?: string;
+        privateAccess?: string;
+    };
+    runtime?: "default" | "dev";
+    waitForCapacity?: boolean;
+}
+export interface SpawnOptions {
+    cwd?: string;
+    env?: Record<string, string>;
+    tty?: boolean;
+    rows?: number;
+    cols?: number;
+    detachable?: boolean;
+    sessionId?: string;
+    controlMode?: boolean;
+}
+export interface ExecOptions extends SpawnOptions {
+    encoding?: BufferEncoding;
+    maxBuffer?: number;
+    signal?: AbortSignal;
+    timeout?: number;
+}
+export interface ExecResult {
+    stdout: string | Buffer;
+    stderr: string | Buffer;
+    exitCode: number;
+}
+export type FilesystemErrorCode = "ENOENT" | "EEXIST" | "ENOTDIR" | "EISDIR" | "EACCES" | "EPERM" | "ENOTEMPTY" | "EINVAL" | "EIO" | "UNKNOWN";
+export declare class FilesystemError extends Error {
+    readonly code: FilesystemErrorCode;
+    readonly path: string;
+    readonly syscall?: string | undefined;
+    constructor(message: string, code: FilesystemErrorCode, path: string, syscall?: string | undefined);
+}
+export interface Dirent {
+    name: string;
+    parentPath: string;
+    isDirectory(): boolean;
+    isFile(): boolean;
+    isSymbolicLink(): boolean;
+}
+export interface ReaddirOptions {
+    withFileTypes?: boolean;
+    recursive?: boolean;
+    pattern?: string;
+    encoding?: BufferEncoding;
+}
+export declare class ExecError extends Error {
+    readonly exitCode: number;
+    readonly stdout: string | Buffer;
+    readonly stderr: string | Buffer;
+    constructor(message: string, exitCode: number, stdout: string | Buffer, stderr: string | Buffer);
+}
+export declare class SpritesClient {
+    readonly runtime: Runtime;
+    constructor(token?: string, options?: ClientOptions);
+    sprite(name: string): Sprite;
+    createSprite(name: string, input?: SpriteConfig | CreateSpriteOptions, extra?: Omit<CreateSpriteOptions, "config">): Promise<Sprite>;
+    getSprite(name: string): Promise<Sprite>;
+    deleteSprite(name: string): Promise<void>;
+    listSprites(options?: {
+        prefix?: string;
+        maxResults?: number;
+        continuationToken?: string;
+        bulkLoad?: boolean;
+    }): Promise<{
+        sprites: {
+            id: string;
+            name: string;
+            status: "paused" | "stopped" | "stopping" | "starting" | "running" | "pausing" | "resuming";
+            createdAt: Date;
+            updatedAt: Date;
+            config: {
+                cpus: number;
+                ramMB: number;
+                storageGB: number;
+                region: string;
+            };
+        }[];
+        hasMore: boolean;
+        nextContinuationToken: string | undefined;
+    }>;
+    listAllSprites(prefix?: string): Promise<Sprite[]>;
+    restartSprite(name: string): Promise<{
+        spriteName: string;
+        machineId: string;
+        message: string;
+    }>;
+    updateURLSettings(name: string, settings: {
+        auth?: string;
+        privateAccess?: string;
+    }): Promise<void>;
+}
+export declare class Sprite {
+    readonly name: string;
+    readonly client: SpritesClient;
+    id?: string;
+    status?: string;
+    config?: SpriteConfig;
+    createdAt?: Date;
+    updatedAt?: Date;
+    url?: string;
+    labels: string[];
+    constructor(name: string, client: SpritesClient);
+    hydrate(s: Sandbox): void;
+    native(): Promise<Sandbox>;
+    spawn(command: string, args?: string[], options?: SpawnOptions): SpriteCommand;
+    exec(command: string, options?: ExecOptions): Promise<ExecResult>;
+    execFile(file: string, args?: string[], options?: ExecOptions): Promise<ExecResult>;
+    execFileHTTP(file: string, args?: string[], options?: ExecOptions): Promise<ExecResult>;
+    createSession(command: string, args?: string[], options?: SpawnOptions): SpriteCommand;
+    attachSession(sessionId: string, options?: SpawnOptions): SpriteCommand;
+    listSessions(): Promise<{
+        id: string;
+        command: string;
+        created: Date;
+        workdir: string;
+        isActive: boolean;
+        tty: boolean;
+    }[]>;
+    delete(): Promise<void>;
+    destroy(): Promise<void>;
+    restart(): Promise<{
+        spriteName: string;
+        machineId: string;
+        message: string;
+    }>;
+    filesystem(workingDir?: string): SpriteFilesystem;
+    createCheckpoint(_comment?: string): Promise<never>;
+    listCheckpoints(): Promise<never>;
+    getCheckpoint(_id: string): Promise<never>;
+    updateURLSettings(settings: {
+        auth?: string;
+        privateAccess?: string;
+    }): Promise<void>;
+    update(options: {
+        labels?: string[];
+        urlSettings?: {
+            auth?: string;
+            privateAccess?: string;
+        };
+    }): Promise<this>;
+}
+export declare class SpriteCommand extends EventEmitter {
+    readonly stdout: PassThrough;
+    readonly stderr: PassThrough;
+    readonly stdin: Writable;
+    private readonly process;
+    private readonly completion;
+    private code;
+    private readonly controller;
+    constructor(sprite: Sprite, command: string, args?: string[], options?: SpawnOptions);
+    private follow;
+    start(): Promise<void>;
+    wait(): Promise<number>;
+    kill(signal?: string): void;
+    signal(signal: string): void;
+    resize(cols: number, rows: number): void;
+    close(): void;
+    exitCode(): number;
+}
+export declare class SpriteFilesystem {
+    private readonly get;
+    private readonly files;
+    constructor(get: () => Promise<Sandbox>, cwd?: string);
+    readFile(path: string, encoding: "utf8"): Promise<string>;
+    readFile(path: string, encoding?: null): Promise<Buffer>;
+    writeFile(path: string, data: string | Uint8Array, options?: {
+        mode?: number;
+    }): Promise<void>;
+    readdir(path: string, options?: ReaddirOptions & {
+        withFileTypes?: false;
+    }): Promise<string[]>;
+    readdir(path: string, options: ReaddirOptions & {
+        withFileTypes: true;
+    }): Promise<Dirent[]>;
+    mkdir(path: string, options?: {
+        recursive?: boolean;
+        mode?: number;
+    }): Promise<void>;
+    rm(path: string, options?: {
+        recursive?: boolean;
+        force?: boolean;
+    }): Promise<void>;
+    stat(path: string): Promise<{
+        size: number;
+        mode: number;
+        mtime: Date;
+        atime: Date;
+        birthtime: Date;
+        isDirectory: () => boolean;
+        isFile: () => boolean;
+        isSymbolicLink: () => boolean;
+    }>;
+    rename(from: string, to: string): Promise<void>;
+    copyFile(from: string, to: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    chmod(path: string, mode: number, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    exists(path: string): Promise<boolean>;
+    appendFile(path: string, data: string | Uint8Array): Promise<void>;
+    readJSON<T = unknown>(path: string): Promise<T>;
+    writeJSON(path: string, data: unknown, options?: {
+        spaces?: number;
+    }): Promise<void>;
+}
+export declare class CheckpointStream {
+    private readonly messages;
+    private index;
+    constructor(messages: {
+        type: "complete" | "error" | "info";
+        data?: string;
+        error?: string;
+    }[]);
+    next(): Promise<{
+        type: "complete" | "error" | "info";
+        data?: string;
+        error?: string;
+    } | null>;
+    processAll(handler: (message: (typeof this.messages)[number]) => void | Promise<void>): Promise<void>;
+    close(): void;
+    [Symbol.asyncIterator](): AsyncGenerator<{
+        type: "complete" | "error" | "info";
+        data?: string;
+        error?: string;
+    }, void, unknown>;
+}