@blaxel/core 0.2.49-dev.213 → 0.2.49-dev1

package/dist/sandbox/client/types.gen.d.ts

@@ -0,0 +1,578 @@
+export type Directory = {
+    files: Array<File>;
+    name: string;
+    path: string;
+    /**
+     * @name Subdirectories
+     */
+    subdirectories: Array<Subdirectory>;
+};
+export type ErrorResponse = {
+    error: string;
+};
+export type File = {
+    group: string;
+    lastModified: string;
+    name: string;
+    owner: string;
+    path: string;
+    permissions: string;
+    size: number;
+};
+export type FileRequest = {
+    content?: string;
+    isDirectory?: boolean;
+    permissions?: string;
+};
+export type FileWithContent = {
+    content: string;
+    group: string;
+    lastModified: string;
+    name: string;
+    owner: string;
+    path: string;
+    permissions: string;
+    size: number;
+};
+export type PortMonitorRequest = {
+    /**
+     * URL to call when a new port is detected
+     */
+    callback?: string;
+};
+export type ProcessLogs = {
+    logs: string;
+    stderr: string;
+    stdout: string;
+};
+export type ProcessRequest = {
+    command: string;
+    env?: {
+        [key: string]: string;
+    };
+    name?: string;
+    timeout?: number;
+    waitForCompletion?: boolean;
+    waitForPorts?: Array<number>;
+    workingDir?: string;
+};
+export type ProcessResponse = {
+    command: string;
+    completedAt: string;
+    exitCode: number;
+    logs: string;
+    name: string;
+    pid: string;
+    startedAt: string;
+    status: 'failed' | 'killed' | 'stopped' | 'running' | 'completed';
+    workingDir: string;
+};
+export type Subdirectory = {
+    name: string;
+    path: string;
+};
+export type SuccessResponse = {
+    message: string;
+    path?: string;
+};
+export type DeleteFilesystemByPathData = {
+    body?: never;
+    path: {
+        /**
+         * File or directory path
+         */
+        path: string;
+    };
+    query?: {
+        /**
+         * Delete directory recursively
+         */
+        recursive?: boolean;
+    };
+    url: '/filesystem/{path}';
+};
+export type DeleteFilesystemByPathErrors = {
+    /**
+     * File or directory not found
+     */
+    404: ErrorResponse;
+    /**
+     * Unprocessable entity
+     */
+    422: ErrorResponse;
+    /**
+     * Internal server error
+     */
+    500: ErrorResponse;
+};
+export type DeleteFilesystemByPathError = DeleteFilesystemByPathErrors[keyof DeleteFilesystemByPathErrors];
+export type DeleteFilesystemByPathResponses = {
+    /**
+     * Success message
+     */
+    200: SuccessResponse;
+};
+export type DeleteFilesystemByPathResponse = DeleteFilesystemByPathResponses[keyof DeleteFilesystemByPathResponses];
+export type GetFilesystemByPathData = {
+    body?: never;
+    path: {
+        /**
+         * File or directory path
+         */
+        path: string;
+    };
+    query?: never;
+    url: '/filesystem/{path}';
+};
+export type GetFilesystemByPathErrors = {
+    /**
+     * File or directory not found
+     */
+    404: ErrorResponse;
+    /**
+     * Unprocessable entity
+     */
+    422: ErrorResponse;
+    /**
+     * Internal server error
+     */
+    500: ErrorResponse;
+};
+export type GetFilesystemByPathError = GetFilesystemByPathErrors[keyof GetFilesystemByPathErrors];
+export type GetFilesystemByPathResponses = {
+    /**
+     * Directory listing
+     */
+    200: Directory | FileWithContent;
+};
+export type GetFilesystemByPathResponse = GetFilesystemByPathResponses[keyof GetFilesystemByPathResponses];
+export type PutFilesystemByPathData = {
+    /**
+     * File or directory details
+     */
+    body: FileRequest;
+    path: {
+        /**
+         * File or directory path
+         */
+        path: string;
+    };
+    query?: never;
+    url: '/filesystem/{path}';
+};
+export type PutFilesystemByPathErrors = {
+    /**
+     * Bad request
+     */
+    400: ErrorResponse;
+    /**
+     * Unprocessable entity
+     */
+    422: ErrorResponse;
+    /**
+     * Internal server error
+     */
+    500: ErrorResponse;
+};
+export type PutFilesystemByPathError = PutFilesystemByPathErrors[keyof PutFilesystemByPathErrors];
+export type PutFilesystemByPathResponses = {
+    /**
+     * Success message
+     */
+    200: SuccessResponse;
+};
+export type PutFilesystemByPathResponse = PutFilesystemByPathResponses[keyof PutFilesystemByPathResponses];
+export type DeleteNetworkProcessByPidMonitorData = {
+    body?: never;
+    path: {
+        /**
+         * Process ID
+         */
+        pid: number;
+    };
+    query?: never;
+    url: '/network/process/{pid}/monitor';
+};
+export type DeleteNetworkProcessByPidMonitorErrors = {
+    /**
+     * Invalid process ID
+     */
+    400: ErrorResponse;
+    /**
+     * Unprocessable entity
+     */
+    422: ErrorResponse;
+    /**
+     * Internal server error
+     */
+    500: ErrorResponse;
+};
+export type DeleteNetworkProcessByPidMonitorError = DeleteNetworkProcessByPidMonitorErrors[keyof DeleteNetworkProcessByPidMonitorErrors];
+export type DeleteNetworkProcessByPidMonitorResponses = {
+    /**
+     * Object containing PID and success message
+     */
+    200: {
+        [key: string]: unknown;
+    };
+};
+export type DeleteNetworkProcessByPidMonitorResponse = DeleteNetworkProcessByPidMonitorResponses[keyof DeleteNetworkProcessByPidMonitorResponses];
+export type PostNetworkProcessByPidMonitorData = {
+    /**
+     * Port monitor configuration
+     */
+    body: PortMonitorRequest;
+    path: {
+        /**
+         * Process ID
+         */
+        pid: number;
+    };
+    query?: never;
+    url: '/network/process/{pid}/monitor';
+};
+export type PostNetworkProcessByPidMonitorErrors = {
+    /**
+     * Invalid request
+     */
+    400: ErrorResponse;
+    /**
+     * Unprocessable entity
+     */
+    422: ErrorResponse;
+    /**
+     * Internal server error
+     */
+    500: ErrorResponse;
+};
+export type PostNetworkProcessByPidMonitorError = PostNetworkProcessByPidMonitorErrors[keyof PostNetworkProcessByPidMonitorErrors];
+export type PostNetworkProcessByPidMonitorResponses = {
+    /**
+     * Object containing PID and success message
+     */
+    200: {
+        [key: string]: unknown;
+    };
+};
+export type PostNetworkProcessByPidMonitorResponse = PostNetworkProcessByPidMonitorResponses[keyof PostNetworkProcessByPidMonitorResponses];
+export type GetNetworkProcessByPidPortsData = {
+    body?: never;
+    path: {
+        /**
+         * Process ID
+         */
+        pid: number;
+    };
+    query?: never;
+    url: '/network/process/{pid}/ports';
+};
+export type GetNetworkProcessByPidPortsErrors = {
+    /**
+     * Invalid process ID
+     */
+    400: ErrorResponse;
+    /**
+     * Unprocessable entity
+     */
+    422: ErrorResponse;
+    /**
+     * Internal server error
+     */
+    500: ErrorResponse;
+};
+export type GetNetworkProcessByPidPortsError = GetNetworkProcessByPidPortsErrors[keyof GetNetworkProcessByPidPortsErrors];
+export type GetNetworkProcessByPidPortsResponses = {
+    /**
+     * Object containing PID and array of network.PortInfo
+     */
+    200: {
+        [key: string]: unknown;
+    };
+};
+export type GetNetworkProcessByPidPortsResponse = GetNetworkProcessByPidPortsResponses[keyof GetNetworkProcessByPidPortsResponses];
+export type GetProcessData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/process';
+};
+export type GetProcessResponses = {
+    /**
+     * Process list
+     */
+    200: Array<ProcessResponse>;
+};
+export type GetProcessResponse = GetProcessResponses[keyof GetProcessResponses];
+export type PostProcessData = {
+    /**
+     * Process execution request
+     */
+    body: ProcessRequest;
+    path?: never;
+    query?: never;
+    url: '/process';
+};
+export type PostProcessErrors = {
+    /**
+     * Invalid request
+     */
+    400: ErrorResponse;
+    /**
+     * Unprocessable entity
+     */
+    422: ErrorResponse;
+    /**
+     * Internal server error
+     */
+    500: ErrorResponse;
+};
+export type PostProcessError = PostProcessErrors[keyof PostProcessErrors];
+export type PostProcessResponses = {
+    /**
+     * Process information
+     */
+    200: ProcessResponse;
+};
+export type PostProcessResponse = PostProcessResponses[keyof PostProcessResponses];
+export type DeleteProcessByIdentifierData = {
+    body?: never;
+    path: {
+        /**
+         * Process identifier (PID or name)
+         */
+        identifier: string;
+    };
+    query?: never;
+    url: '/process/{identifier}';
+};
+export type DeleteProcessByIdentifierErrors = {
+    /**
+     * Process not found
+     */
+    404: ErrorResponse;
+    /**
+     * Unprocessable entity
+     */
+    422: ErrorResponse;
+    /**
+     * Internal server error
+     */
+    500: ErrorResponse;
+};
+export type DeleteProcessByIdentifierError = DeleteProcessByIdentifierErrors[keyof DeleteProcessByIdentifierErrors];
+export type DeleteProcessByIdentifierResponses = {
+    /**
+     * Process stopped
+     */
+    200: SuccessResponse;
+};
+export type DeleteProcessByIdentifierResponse = DeleteProcessByIdentifierResponses[keyof DeleteProcessByIdentifierResponses];
+export type GetProcessByIdentifierData = {
+    body?: never;
+    path: {
+        /**
+         * Process identifier (PID or name)
+         */
+        identifier: string;
+    };
+    query?: never;
+    url: '/process/{identifier}';
+};
+export type GetProcessByIdentifierErrors = {
+    /**
+     * Process not found
+     */
+    404: ErrorResponse;
+};
+export type GetProcessByIdentifierError = GetProcessByIdentifierErrors[keyof GetProcessByIdentifierErrors];
+export type GetProcessByIdentifierResponses = {
+    /**
+     * Process information
+     */
+    200: ProcessResponse;
+};
+export type GetProcessByIdentifierResponse = GetProcessByIdentifierResponses[keyof GetProcessByIdentifierResponses];
+export type DeleteProcessByIdentifierKillData = {
+    body?: never;
+    path: {
+        /**
+         * Process identifier (PID or name)
+         */
+        identifier: string;
+    };
+    query?: never;
+    url: '/process/{identifier}/kill';
+};
+export type DeleteProcessByIdentifierKillErrors = {
+    /**
+     * Process not found
+     */
+    404: ErrorResponse;
+    /**
+     * Unprocessable entity
+     */
+    422: ErrorResponse;
+    /**
+     * Internal server error
+     */
+    500: ErrorResponse;
+};
+export type DeleteProcessByIdentifierKillError = DeleteProcessByIdentifierKillErrors[keyof DeleteProcessByIdentifierKillErrors];
+export type DeleteProcessByIdentifierKillResponses = {
+    /**
+     * Process killed
+     */
+    200: SuccessResponse;
+};
+export type DeleteProcessByIdentifierKillResponse = DeleteProcessByIdentifierKillResponses[keyof DeleteProcessByIdentifierKillResponses];
+export type GetProcessByIdentifierLogsData = {
+    body?: never;
+    path: {
+        /**
+         * Process identifier (PID or name)
+         */
+        identifier: string;
+    };
+    query?: never;
+    url: '/process/{identifier}/logs';
+};
+export type GetProcessByIdentifierLogsErrors = {
+    /**
+     * Process not found
+     */
+    404: ErrorResponse;
+    /**
+     * Unprocessable entity
+     */
+    422: ErrorResponse;
+    /**
+     * Internal server error
+     */
+    500: ErrorResponse;
+};
+export type GetProcessByIdentifierLogsError = GetProcessByIdentifierLogsErrors[keyof GetProcessByIdentifierLogsErrors];
+export type GetProcessByIdentifierLogsResponses = {
+    /**
+     * Process logs
+     */
+    200: ProcessLogs;
+};
+export type GetProcessByIdentifierLogsResponse = GetProcessByIdentifierLogsResponses[keyof GetProcessByIdentifierLogsResponses];
+export type GetProcessByIdentifierLogsStreamData = {
+    body?: never;
+    path: {
+        /**
+         * Process identifier (PID or name)
+         */
+        identifier: string;
+    };
+    query?: never;
+    url: '/process/{identifier}/logs/stream';
+};
+export type GetProcessByIdentifierLogsStreamErrors = {
+    /**
+     * Process not found
+     */
+    404: ErrorResponse;
+    /**
+     * Unprocessable entity
+     */
+    422: ErrorResponse;
+    /**
+     * Internal server error
+     */
+    500: ErrorResponse;
+};
+export type GetProcessByIdentifierLogsStreamError = GetProcessByIdentifierLogsStreamErrors[keyof GetProcessByIdentifierLogsStreamErrors];
+export type GetProcessByIdentifierLogsStreamResponses = {
+    /**
+     * Stream of process logs, one line per log (prefixed with stdout:/stderr:)
+     */
+    200: string;
+};
+export type GetProcessByIdentifierLogsStreamResponse = GetProcessByIdentifierLogsStreamResponses[keyof GetProcessByIdentifierLogsStreamResponses];
+export type GetWatchFilesystemByPathData = {
+    body?: never;
+    path: {
+        /**
+         * Directory path to watch
+         */
+        path: string;
+    };
+    query?: {
+        /**
+         * Ignore patterns (comma-separated)
+         */
+        ignore?: string;
+    };
+    url: '/watch/filesystem/{path}';
+};
+export type GetWatchFilesystemByPathErrors = {
+    /**
+     * Invalid path
+     */
+    400: ErrorResponse;
+    /**
+     * Internal server error
+     */
+    500: ErrorResponse;
+};
+export type GetWatchFilesystemByPathError = GetWatchFilesystemByPathErrors[keyof GetWatchFilesystemByPathErrors];
+export type GetWatchFilesystemByPathResponses = {
+    /**
+     * Stream of modified file paths, one per line
+     */
+    200: string;
+};
+export type GetWatchFilesystemByPathResponse = GetWatchFilesystemByPathResponses[keyof GetWatchFilesystemByPathResponses];
+export type GetWsProcessByIdentifierLogsStreamData = {
+    body?: never;
+    path: {
+        /**
+         * Process identifier (PID or name)
+         */
+        identifier: string;
+    };
+    query?: never;
+    url: '/ws/process/{identifier}/logs/stream';
+};
+export type GetWsProcessByIdentifierLogsStreamErrors = {
+    /**
+     * Process not found
+     */
+    404: ErrorResponse;
+    /**
+     * Unprocessable entity
+     */
+    422: ErrorResponse;
+    /**
+     * Internal server error
+     */
+    500: ErrorResponse;
+};
+export type GetWsProcessByIdentifierLogsStreamError = GetWsProcessByIdentifierLogsStreamErrors[keyof GetWsProcessByIdentifierLogsStreamErrors];
+export type GetWsWatchFilesystemByPathData = {
+    body?: never;
+    path: {
+        /**
+         * Directory path to watch
+         */
+        path: string;
+    };
+    query?: never;
+    url: '/ws/watch/filesystem/{path}';
+};
+export type GetWsWatchFilesystemByPathErrors = {
+    /**
+     * Invalid path
+     */
+    400: ErrorResponse;
+    /**
+     * Internal server error
+     */
+    500: ErrorResponse;
+};
+export type GetWsWatchFilesystemByPathError = GetWsWatchFilesystemByPathErrors[keyof GetWsWatchFilesystemByPathErrors];
+export type ClientOptions = {
+    baseUrl: 'https://run.blaxel.ai/{workspace_id}/sandboxes/{sandbox_id}' | (string & {});
+};

package/dist/sandbox/client/types.gen.js

@@ -0,0 +1,3 @@
+"use strict";
+// This file is auto-generated by @hey-api/openapi-ts
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/{cjs/types/sandbox/filesystem/filesystem-ws.d.ts → sandbox/filesystem/filesystem.d.ts}

@@ -1,29 +1,17 @@
+import { Sandbox } from "../../client/types.gen.js";
 import { SandboxAction } from "../action.js";
-import { WebSocketClient } from "../websocket/index.js";
 import { Directory, SuccessResponse } from "../client/index.js";
-import { SandboxProcess } from "../process/index.js";
-import { SandboxProcessWebSocket } from "../process/process-ws.js";
 import { CopyResponse, SandboxFilesystemFile, WatchEvent } from "./types.js";
-import { SandboxConfiguration } from "../types.js";
-export declare class SandboxFileSystemWebSocket extends SandboxAction {
-    private process;
-    private wsClient;
-    private httpClient;
-    constructor(sandbox: SandboxConfiguration, process: SandboxProcess | SandboxProcessWebSocket, wsClient: WebSocketClient);
+export declare class SandboxFileSystem extends SandboxAction {
+    constructor(sandbox: Sandbox);
     mkdir(path: string, permissions?: string): Promise<SuccessResponse>;
     write(path: string, content: string): Promise<SuccessResponse>;
-    writeBinary(path: string, content: Buffer | Blob | File | Uint8Array | string): Promise<SuccessResponse>;
-    writeTree(files: SandboxFilesystemFile[], destinationPath?: string | null): Promise<Directory>;
+    writeBinary(path: string, content: Buffer | Blob | File | Uint8Array): Promise<unknown>;
+    writeTree(files: SandboxFilesystemFile[], destinationPath?: string | null): Promise<Directory | undefined>;
     read(path: string): Promise<string>;
-    readBinary(path: string): Promise<Blob>;
-    download(src: string, destinationPath: string, options?: {
-        mode?: number;
-    }): Promise<void>;
     rm(path: string, recursive?: boolean): Promise<SuccessResponse>;
     ls(path: string): Promise<Directory>;
-    cp(source: string, destination: string, { maxWait }?: {
-        maxWait?: number;
-    }): Promise<CopyResponse>;
+    cp(source: string, destination: string): Promise<CopyResponse>;
     watch(path: string, callback: (fileEvent: WatchEvent) => void | Promise<void>, options?: {
         onError?: (error: Error) => void;
         withContent: boolean;