@blaxel/core 0.2.0-dev1

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

@@ -0,0 +1,410 @@
+export type ErrorResponse = {
+    error?: string;
+};
+export type File = {
+    group?: string;
+    lastModified?: string;
+    owner?: string;
+    path?: string;
+    /**
+     * swagger:strfmt string
+     */
+    permissions?: string;
+    size?: number;
+};
+export type FileRequest = {
+    content?: string;
+    isDirectory?: boolean;
+    permissions?: string;
+};
+export type PortMonitorRequest = {
+    /**
+     * URL to call when a new port is detected
+     */
+    callback?: string;
+};
+export type ProcessKillRequest = {
+    signal?: string;
+};
+export type ProcessRequest = {
+    command: string;
+    name?: string;
+    streamLogs?: boolean;
+    timeout?: number;
+    waitForCompletion?: boolean;
+    waitForPorts?: Array<number>;
+    workingDir?: string;
+};
+export type ProcessResponse = {
+    command?: string;
+    completedAt?: string;
+    exitCode?: number;
+    name?: string;
+    pid?: string;
+    startedAt?: string;
+    status?: string;
+    workingDir?: string;
+};
+export type SuccessResponse = {
+    message?: string;
+    path?: string;
+};
+export type Directory = {
+    files?: Array<File>;
+    path?: string;
+    /**
+     * @name Subdirectories
+     */
+    subdirectories?: Array<Directory>;
+};
+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;
+    /**
+     * 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;
+    /**
+     * Internal server error
+     */
+    500: ErrorResponse;
+};
+export type GetFilesystemByPathError = GetFilesystemByPathErrors[keyof GetFilesystemByPathErrors];
+export type GetFilesystemByPathResponses = {
+    /**
+     * Directory listing
+     */
+    200: Directory;
+};
+export type GetFilesystemByPathResponse = GetFilesystemByPathResponses[keyof GetFilesystemByPathResponses];
+export type PutFilesystemByPathData = {
+    /**
+     * File or directory information
+     */
+    body: FileRequest;
+    path: {
+        /**
+         * File or directory path
+         */
+        path: string;
+    };
+    query?: never;
+    url: '/filesystem/{path}';
+};
+export type PutFilesystemByPathErrors = {
+    /**
+     * Invalid request
+     */
+    400: 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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 = {
+    /**
+     * Kill options
+     */
+    body?: ProcessKillRequest;
+    path: {
+        /**
+         * Process identifier (PID or name)
+         */
+        identifier: string;
+    };
+    query?: never;
+    url: '/process/{identifier}/kill';
+};
+export type DeleteProcessByIdentifierKillErrors = {
+    /**
+     * Process not found
+     */
+    404: 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;
+    /**
+     * Internal server error
+     */
+    500: ErrorResponse;
+};
+export type GetProcessByIdentifierLogsError = GetProcessByIdentifierLogsErrors[keyof GetProcessByIdentifierLogsErrors];
+export type GetProcessByIdentifierLogsResponses = {
+    /**
+     * Process logs
+     */
+    200: {
+        [key: string]: string;
+    };
+};
+export type GetProcessByIdentifierLogsResponse = GetProcessByIdentifierLogsResponses[keyof GetProcessByIdentifierLogsResponses];
+export type ClientOptions = {
+    baseUrl: `${string}://localhost:8080` | (string & {});
+};

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

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

package/dist/sandbox/filesystem.d.ts

@@ -0,0 +1,18 @@
+import { Sandbox } from "../client/types.gen.js";
+import { SandboxAction } from "./action.js";
+import { Directory, SuccessResponse } from "./client/index.js";
+export type CopyResponse = {
+    message: string;
+    source: string;
+    destination: string;
+};
+export declare class SandboxFileSystem extends SandboxAction {
+    constructor(sandbox: Sandbox);
+    mkdir(path: string, permissions?: string): Promise<SuccessResponse>;
+    write(path: string, content: string): Promise<SuccessResponse>;
+    read(path: string): Promise<string>;
+    rm(path: string, recursive?: boolean): Promise<SuccessResponse>;
+    ls(path: string): Promise<Directory>;
+    cp(source: string, destination: string): Promise<CopyResponse>;
+    private formatPath;
+}

package/dist/sandbox/filesystem.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SandboxFileSystem = void 0;
+const action_js_1 = require("./action.js");
+const index_js_1 = require("./client/index.js");
+class SandboxFileSystem extends action_js_1.SandboxAction {
+    constructor(sandbox) {
+        super(sandbox);
+    }
+    async mkdir(path, permissions = "0755") {
+        path = this.formatPath(path);
+        const { response, data, error } = await (0, index_js_1.putFilesystemByPath)({
+            path: { path },
+            body: { isDirectory: true, permissions },
+            baseUrl: this.url,
+        });
+        this.handleResponseError(response, data, error);
+        return data;
+    }
+    async write(path, content) {
+        path = this.formatPath(path);
+        const { response, data, error } = await (0, index_js_1.putFilesystemByPath)({
+            path: { path },
+            body: { content },
+            baseUrl: this.url,
+        });
+        this.handleResponseError(response, data, error);
+        return data;
+    }
+    async read(path) {
+        path = this.formatPath(path);
+        const { response, data, error } = await (0, index_js_1.getFilesystemByPath)({
+            path: { path },
+            baseUrl: this.url,
+        });
+        this.handleResponseError(response, data, error);
+        if (data && 'content' in data) {
+            return data.content;
+        }
+        throw new Error("Unsupported file type");
+    }
+    async rm(path, recursive = false) {
+        path = this.formatPath(path);
+        const { response, data, error } = await (0, index_js_1.deleteFilesystemByPath)({
+            path: { path },
+            query: { recursive },
+            baseUrl: this.url,
+        });
+        this.handleResponseError(response, data, error);
+        return data;
+    }
+    async ls(path) {
+        path = this.formatPath(path);
+        const { response, data, error } = await (0, index_js_1.getFilesystemByPath)({
+            path: { path },
+            baseUrl: this.url,
+        });
+        this.handleResponseError(response, data, error);
+        if (!data || !('files' in data || 'subdirectories' in data)) {
+            throw new Error(JSON.stringify({ error: "Directory not found" }));
+        }
+        return data;
+    }
+    async cp(source, destination) {
+        source = this.formatPath(source);
+        destination = this.formatPath(destination);
+        const { response, data, error } = await (0, index_js_1.getFilesystemByPath)({
+            path: { path: source },
+            baseUrl: this.url,
+        });
+        this.handleResponseError(response, data, error);
+        if (data && ('files' in data || 'subdirectories' in data)) {
+            // Create destination directory
+            await this.mkdir(destination);
+            // Process subdirectories in batches of 5
+            const subdirectories = data.subdirectories || [];
+            for (let i = 0; i < subdirectories.length; i += 5) {
+                const batch = subdirectories.slice(i, i + 5);
+                await Promise.all(batch.map(async (subdir) => {
+                    const sourcePath = subdir.path || `${source}/${subdir.path}`;
+                    const destPath = `${destination}/${subdir.path}`;
+                    await this.cp(sourcePath, destPath);
+                }));
+            }
+            // Process files in batches of 10
+            const files = data.files || [];
+            for (let i = 0; i < files.length; i += 10) {
+                const batch = files.slice(i, i + 10);
+                await Promise.all(batch.map(async (file) => {
+                    const sourcePath = file.path || `${source}/${file.path}`;
+                    const destPath = `${destination}/${file.path}`;
+                    const fileContent = await this.read(sourcePath);
+                    if (typeof fileContent === 'string') {
+                        await this.write(destPath, fileContent);
+                    }
+                }));
+            }
+            return {
+                message: "Directory copied successfully",
+                source,
+                destination,
+            };
+        }
+        else if (data && 'content' in data) {
+            await this.write(destination, data.content);
+            return {
+                message: "File copied successfully",
+                source,
+                destination,
+            };
+        }
+        throw new Error("Unsupported file type");
+    }
+    formatPath(path) {
+        if (path.startsWith("/")) {
+            path = path.slice(1);
+        }
+        return path;
+    }
+}
+exports.SandboxFileSystem = SandboxFileSystem;

package/dist/sandbox/index.d.ts

@@ -0,0 +1 @@
+export * from "./sandbox.js";

package/dist/sandbox/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./sandbox.js"), exports);

package/dist/sandbox/network.d.ts

@@ -0,0 +1,5 @@
+import { Sandbox } from "../client/types.gen.js";
+import { SandboxAction } from "./action.js";
+export declare class SandboxNetwork extends SandboxAction {
+    constructor(sandbox: Sandbox);
+}

package/dist/sandbox/network.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SandboxNetwork = void 0;
+const action_js_1 = require("./action.js");
+class SandboxNetwork extends action_js_1.SandboxAction {
+    constructor(sandbox) {
+        super(sandbox);
+    }
+}
+exports.SandboxNetwork = SandboxNetwork;

package/dist/sandbox/process.d.ts

@@ -0,0 +1,12 @@
+import { Sandbox } from "../client/types.gen.js";
+import { SandboxAction } from "./action.js";
+import { DeleteProcessByIdentifierKillResponse, DeleteProcessByIdentifierResponse, GetProcessByIdentifierResponse, GetProcessResponse, PostProcessResponse, ProcessRequest } from "./client/index.js";
+export declare class SandboxProcess extends SandboxAction {
+    constructor(sandbox: Sandbox);
+    exec(process: ProcessRequest): Promise<PostProcessResponse>;
+    get(identifier: string): Promise<GetProcessByIdentifierResponse>;
+    list(): Promise<GetProcessResponse>;
+    stop(identifier: string): Promise<DeleteProcessByIdentifierResponse>;
+    kill(identifier: string): Promise<DeleteProcessByIdentifierKillResponse>;
+    logs(identifier: string, type?: "stdout" | "stderr"): Promise<string>;
+}

package/dist/sandbox/process.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SandboxProcess = void 0;
+const action_js_1 = require("./action.js");
+const index_js_1 = require("./client/index.js");
+class SandboxProcess extends action_js_1.SandboxAction {
+    constructor(sandbox) {
+        super(sandbox);
+    }
+    async exec(process) {
+        const { response, data, error } = await (0, index_js_1.postProcess)({
+            body: process,
+            baseUrl: this.url,
+        });
+        this.handleResponseError(response, data, error);
+        return data;
+    }
+    async get(identifier) {
+        const { response, data, error } = await (0, index_js_1.getProcessByIdentifier)({
+            path: { identifier },
+            baseUrl: this.url,
+        });
+        this.handleResponseError(response, data, error);
+        return data;
+    }
+    async list() {
+        const { response, data, error } = await (0, index_js_1.getProcess)({
+            baseUrl: this.url,
+        });
+        this.handleResponseError(response, data, error);
+        return data;
+    }
+    async stop(identifier) {
+        const { response, data, error } = await (0, index_js_1.deleteProcessByIdentifier)({
+            path: { identifier },
+            baseUrl: this.url,
+        });
+        this.handleResponseError(response, data, error);
+        return data;
+    }
+    async kill(identifier) {
+        const { response, data, error } = await (0, index_js_1.deleteProcessByIdentifierKill)({
+            path: { identifier },
+            baseUrl: this.url,
+        });
+        this.handleResponseError(response, data, error);
+        return data;
+    }
+    async logs(identifier, type = "stdout") {
+        const { response, data, error } = await (0, index_js_1.getProcessByIdentifierLogs)({
+            path: { identifier },
+            baseUrl: this.url,
+        });
+        this.handleResponseError(response, data, error);
+        if (data && type in data) {
+            return data[type];
+        }
+        throw new Error("Unsupported log type");
+    }
+}
+exports.SandboxProcess = SandboxProcess;

package/dist/sandbox/sandbox.d.ts

@@ -0,0 +1,23 @@
+import { Sandbox as SandboxModel } from "../client/index.js";
+import { SandboxFileSystem } from "./filesystem.js";
+import { SandboxNetwork } from "./network.js";
+import { SandboxProcess } from "./process.js";
+export declare class SandboxInstance {
+    private sandbox;
+    fs: SandboxFileSystem;
+    network: SandboxNetwork;
+    process: SandboxProcess;
+    constructor(sandbox: SandboxModel);
+    get metadata(): import("../client/types.gen.js").Metadata | undefined;
+    get status(): string | undefined;
+    get events(): import("../client/types.gen.js").CoreEvents | undefined;
+    get spec(): import("../client/types.gen.js").CoreSpec | undefined;
+    wait({ maxWait, interval }?: {
+        maxWait?: number;
+        interval?: number;
+    }): Promise<void>;
+    static create(sandbox: SandboxModel): Promise<SandboxInstance>;
+    static get(sandboxName: string): Promise<SandboxInstance>;
+    static list(): Promise<SandboxInstance[]>;
+    static delete(sandboxName: string): Promise<SandboxModel>;
+}