@blaxel/core 0.2.10-dev.85 → 0.2.10-dev1

package/dist/sandbox/filesystem/filesystem.js

@@ -9,7 +9,6 @@ const node_js_1 = require("../../common/node.js");
 const settings_js_1 = require("../../common/settings.js");
 const action_js_1 = require("../action.js");
 const index_js_1 = require("../client/index.js");
-const types_js_1 = require("./types.js");
 class SandboxFileSystem extends action_js_1.SandboxAction {
     constructor(sandbox) {
         super(sandbox);
@@ -290,155 +289,5 @@ class SandboxFileSystem extends action_js_1.SandboxAction {
         }
         return path;
     }
-    get toolsWithoutExecute() {
-        return {
-            cp: {
-                description: "Copy a file or directory",
-                parameters: types_js_1.CpParamsSchema,
-            },
-            mkdir: {
-                description: "Create a directory",
-                parameters: types_js_1.MkdirParamsSchema,
-            },
-            ls: {
-                description: "List a directory",
-                parameters: types_js_1.LsParamsSchema,
-            },
-            rm: {
-                description: "Remove a file or directory",
-                parameters: types_js_1.RmParamsSchema,
-            },
-            read: {
-                description: "Read a file",
-                parameters: types_js_1.ReadParamsSchema,
-            },
-            write: {
-                description: "Write a file",
-                parameters: types_js_1.WriteParamsSchema,
-            }
-        };
-    }
-    get tools() {
-        return {
-            cp: {
-                description: "Copy a file or directory",
-                parameters: types_js_1.CpParamsSchema,
-                execute: async (args) => {
-                    try {
-                        const result = await this.cp(args.source, args.destination);
-                        return JSON.stringify(result);
-                    }
-                    catch (e) {
-                        if (e instanceof Error) {
-                            return JSON.stringify({
-                                message: e.message,
-                                source: args.source,
-                                destination: args.destination
-                            });
-                        }
-                        return "An unknown error occurred";
-                    }
-                }
-            },
-            mkdir: {
-                description: "Create a directory",
-                parameters: types_js_1.MkdirParamsSchema,
-                execute: async (args) => {
-                    try {
-                        const result = await this.mkdir(args.path, args.permissions);
-                        return JSON.stringify(result);
-                    }
-                    catch (e) {
-                        if (e instanceof Error) {
-                            return JSON.stringify({
-                                message: e.message,
-                                path: args.path,
-                                permissions: args.permissions
-                            });
-                        }
-                        return "An unknown error occurred";
-                    }
-                }
-            },
-            ls: {
-                description: "List a directory",
-                parameters: types_js_1.LsParamsSchema,
-                execute: async (args) => {
-                    try {
-                        const result = await this.ls(args.path);
-                        return JSON.stringify(result);
-                    }
-                    catch (e) {
-                        if (e instanceof Error) {
-                            return JSON.stringify({
-                                message: e.message,
-                                path: args.path
-                            });
-                        }
-                        return "An unknown error occurred";
-                    }
-                }
-            },
-            rm: {
-                description: "Remove a file or directory",
-                parameters: types_js_1.RmParamsSchema,
-                execute: async (args) => {
-                    try {
-                        const result = await this.rm(args.path, args.recursive);
-                        return JSON.stringify(result);
-                    }
-                    catch (e) {
-                        if (e instanceof Error) {
-                            return JSON.stringify({
-                                message: e.message,
-                                path: args.path,
-                                recursive: args.recursive
-                            });
-                        }
-                        return "An unknown error occurred";
-                    }
-                }
-            },
-            read: {
-                description: "Read a file",
-                parameters: types_js_1.ReadParamsSchema,
-                execute: async (args) => {
-                    try {
-                        const result = await this.read(args.path);
-                        return JSON.stringify(result);
-                    }
-                    catch (e) {
-                        if (e instanceof Error) {
-                            return JSON.stringify({
-                                message: e.message,
-                                path: args.path
-                            });
-                        }
-                        return "An unknown error occurred";
-                    }
-                }
-            },
-            write: {
-                description: "Write a file",
-                parameters: types_js_1.WriteParamsSchema,
-                execute: async (args) => {
-                    try {
-                        const result = await this.write(args.path, args.content);
-                        return JSON.stringify(result);
-                    }
-                    catch (e) {
-                        if (e instanceof Error) {
-                            return JSON.stringify({
-                                message: e.message,
-                                path: args.path,
-                                content: args.content
-                            });
-                        }
-                        return "An unknown error occurred";
-                    }
-                }
-            }
-        };
-    }
 }
 exports.SandboxFileSystem = SandboxFileSystem;

package/dist/sandbox/filesystem/types.d.ts

@@ -1,4 +1,3 @@
-import { z } from "zod";
 export type CopyResponse = {
     message: string;
     source: string;
@@ -14,115 +13,3 @@ export type SandboxFilesystemFile = {
     path: string;
     content: string;
 };
-export declare const CpParamsSchema: z.ZodObject<{
-    source: z.ZodString;
-    destination: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    source: string;
-    destination: string;
-}, {
-    source: string;
-    destination: string;
-}>;
-export declare const MkdirParamsSchema: z.ZodObject<{
-    path: z.ZodString;
-    permissions: z.ZodDefault<z.ZodOptional<z.ZodString>>;
-}, "strip", z.ZodTypeAny, {
-    path: string;
-    permissions: string;
-}, {
-    path: string;
-    permissions?: string | undefined;
-}>;
-export declare const LsParamsSchema: z.ZodObject<{
-    path: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    path: string;
-}, {
-    path: string;
-}>;
-export declare const RmParamsSchema: z.ZodObject<{
-    path: z.ZodString;
-    recursive: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-}, "strip", z.ZodTypeAny, {
-    path: string;
-    recursive: boolean;
-}, {
-    path: string;
-    recursive?: boolean | undefined;
-}>;
-export declare const ReadParamsSchema: z.ZodObject<{
-    path: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    path: string;
-}, {
-    path: string;
-}>;
-export declare const WriteParamsSchema: z.ZodObject<{
-    path: z.ZodString;
-    content: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    path: string;
-    content: string;
-}, {
-    path: string;
-    content: string;
-}>;
-export type ToolWithoutExecute = {
-    cp: {
-        description: string;
-        parameters: typeof CpParamsSchema;
-    };
-    mkdir: {
-        description: string;
-        parameters: typeof MkdirParamsSchema;
-    };
-    ls: {
-        description: string;
-        parameters: typeof LsParamsSchema;
-    };
-    rm: {
-        description: string;
-        parameters: typeof RmParamsSchema;
-    };
-    read: {
-        description: string;
-        parameters: typeof ReadParamsSchema;
-    };
-    write: {
-        description: string;
-        parameters: typeof WriteParamsSchema;
-    };
-};
-export type ToolWithExecute = {
-    cp: {
-        description: string;
-        parameters: typeof CpParamsSchema;
-        execute: (args: z.infer<typeof CpParamsSchema>) => Promise<string>;
-    };
-    mkdir: {
-        description: string;
-        parameters: typeof MkdirParamsSchema;
-        execute: (args: z.infer<typeof MkdirParamsSchema>) => Promise<string>;
-    };
-    ls: {
-        description: string;
-        parameters: typeof LsParamsSchema;
-        execute: (args: z.infer<typeof LsParamsSchema>) => Promise<string>;
-    };
-    rm: {
-        description: string;
-        parameters: typeof RmParamsSchema;
-        execute: (args: z.infer<typeof RmParamsSchema>) => Promise<string>;
-    };
-    read: {
-        description: string;
-        parameters: typeof ReadParamsSchema;
-        execute: (args: z.infer<typeof ReadParamsSchema>) => Promise<string>;
-    };
-    write: {
-        description: string;
-        parameters: typeof WriteParamsSchema;
-        execute: (args: z.infer<typeof WriteParamsSchema>) => Promise<string>;
-    };
-};

package/dist/sandbox/filesystem/types.js

@@ -1,26 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WriteParamsSchema = exports.ReadParamsSchema = exports.RmParamsSchema = exports.LsParamsSchema = exports.MkdirParamsSchema = exports.CpParamsSchema = void 0;
-const zod_1 = require("zod");
-exports.CpParamsSchema = zod_1.z.object({
-    source: zod_1.z.string().describe("Source file or directory path"),
-    destination: zod_1.z.string().describe("Destination file or directory path"),
-}).describe("Parameters for copying a file or directory");
-exports.MkdirParamsSchema = zod_1.z.object({
-    path: zod_1.z.string().describe("Directory path to create"),
-    permissions: zod_1.z.string().optional().default("0755").describe("Permissions for the new directory (default 0755)"),
-}).describe("Parameters for creating a directory");
-exports.LsParamsSchema = zod_1.z.object({
-    path: zod_1.z.string().describe("Directory path to list"),
-}).describe("Parameters for listing a directory");
-exports.RmParamsSchema = zod_1.z.object({
-    path: zod_1.z.string().describe("File or directory path to remove"),
-    recursive: zod_1.z.boolean().optional().default(false).describe("Whether to remove recursively (default false)"),
-}).describe("Parameters for removing a file or directory");
-exports.ReadParamsSchema = zod_1.z.object({
-    path: zod_1.z.string().describe("File path to read"),
-}).describe("Parameters for reading a file");
-exports.WriteParamsSchema = zod_1.z.object({
-    path: zod_1.z.string().describe("File path to write to"),
-    content: zod_1.z.string().describe("Content to write to the file"),
-}).describe("Parameters for writing to a file");

package/dist/sandbox/filesystem.d.ts

@@ -0,0 +1,30 @@
+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 type WatchEvent = {
+    op: "CREATE" | "WRITE" | "REMOVE";
+    path: string;
+    name: string;
+    content?: 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>;
+    watch(path: string, callback: (fileEvent: WatchEvent) => void | Promise<void>, options?: {
+        onError?: (error: Error) => void;
+        withContent: boolean;
+    }): {
+        close: () => void;
+    };
+    private formatPath;
+}

package/dist/sandbox/filesystem.js

@@ -0,0 +1,207 @@
+"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,
+            client: this.client,
+        });
+        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,
+            client: this.client,
+        });
+        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,
+            client: this.client,
+        });
+        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,
+            client: this.client,
+        });
+        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,
+            client: this.client,
+        });
+        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,
+            client: this.client,
+        });
+        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");
+    }
+    watch(path, callback, options) {
+        path = this.formatPath(path);
+        let closed = false;
+        let controller = new AbortController();
+        const start = async () => {
+            const { response, data, error } = await (0, index_js_1.getWatchFilesystemByPath)({
+                client: this.client,
+                path: { path },
+                baseUrl: this.url,
+                parseAs: 'stream',
+                signal: controller.signal,
+            });
+            if (error)
+                throw error;
+            const stream = data ?? response.body;
+            if (!stream)
+                throw new Error('No stream returned');
+            const reader = stream.getReader();
+            let buffer = '';
+            const decoder = new TextDecoder();
+            try {
+                while (!closed) {
+                    const { value, done } = await reader.read();
+                    if (done)
+                        break;
+                    buffer += decoder.decode(value, { stream: true });
+                    let lines = buffer.split('\n');
+                    buffer = lines.pop();
+                    for (const line of lines) {
+                        const trimmed = line.trim();
+                        if (!trimmed)
+                            continue;
+                        const fileEvent = JSON.parse(line.trim());
+                        if (options?.withContent && ["CREATE", "WRITE"].includes(fileEvent.op)) {
+                            try {
+                                let filePath = "";
+                                if (fileEvent.path.endsWith("/")) {
+                                    filePath = fileEvent.path + fileEvent.name;
+                                }
+                                else {
+                                    filePath = fileEvent.path + "/" + fileEvent.name;
+                                }
+                                const content = await this.read(filePath);
+                                await callback({ ...fileEvent, content });
+                            }
+                            catch (e) {
+                                console.log(e);
+                                await callback({ ...fileEvent, content: undefined });
+                            }
+                        }
+                        else {
+                            await callback(fileEvent);
+                        }
+                    }
+                }
+            }
+            finally {
+                reader.releaseLock();
+            }
+        };
+        start().catch((err) => {
+            // Suppress AbortError when closing
+            if (!(err && err.name === 'AbortError')) {
+                if (options?.onError) {
+                    options.onError(err);
+                }
+            }
+            closed = true;
+            controller?.abort();
+        });
+        return {
+            close: () => {
+                closed = true;
+                controller?.abort();
+            },
+        };
+    }
+    formatPath(path) {
+        if (path === "/") {
+            return path;
+        }
+        if (path.startsWith("/")) {
+            path = path.slice(1);
+        }
+        return path;
+    }
+}
+exports.SandboxFileSystem = SandboxFileSystem;

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/index.d.ts

@@ -1,2 +1 @@
 export * from "./process.js";
-export * from "./types.js";

package/dist/sandbox/process/index.js

@@ -15,4 +15,3 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./process.js"), exports);
-__exportStar(require("./types.js"), exports);

package/dist/sandbox/process/process.d.ts

@@ -1,7 +1,6 @@
 import { Sandbox } from "../../client/types.gen.js";
 import { SandboxAction } from "../action.js";
 import { DeleteProcessByIdentifierKillResponse, DeleteProcessByIdentifierResponse, GetProcessByIdentifierResponse, GetProcessResponse, PostProcessResponse, ProcessRequest } from "../client/index.js";
-import { ProcessToolWithExecute, ProcessToolWithoutExecute } from "./types.js";
 export declare class SandboxProcess extends SandboxAction {
     constructor(sandbox: Sandbox);
     streamLogs(identifier: string, options: {
@@ -21,6 +20,4 @@ export declare class SandboxProcess extends SandboxAction {
     stop(identifier: string): Promise<DeleteProcessByIdentifierResponse>;
     kill(identifier: string): Promise<DeleteProcessByIdentifierKillResponse>;
     logs(identifier: string, type?: "stdout" | "stderr" | "all"): Promise<string>;
-    get toolsWithoutExecute(): ProcessToolWithoutExecute;
-    get tools(): ProcessToolWithExecute;
 }