@blaxel/core 0.2.10-dev.79 → 0.2.10-dev.80

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

@@ -14,107 +14,115 @@ 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: z.ZodObject<{
-            source: z.ZodString;
-            destination: z.ZodString;
-        }>;
+        parameters: typeof CpParamsSchema;
     };
     mkdir: {
         description: string;
-        parameters: z.ZodObject<{
-            path: z.ZodString;
-            permissions: z.ZodDefault<z.ZodOptional<z.ZodString>>;
-        }>;
+        parameters: typeof MkdirParamsSchema;
     };
     ls: {
         description: string;
-        parameters: z.ZodObject<{
-            path: z.ZodString;
-        }>;
+        parameters: typeof LsParamsSchema;
     };
     rm: {
         description: string;
-        parameters: z.ZodObject<{
-            path: z.ZodString;
-        }>;
+        parameters: typeof RmParamsSchema;
     };
     read: {
         description: string;
-        parameters: z.ZodObject<{
-            path: z.ZodString;
-        }>;
+        parameters: typeof ReadParamsSchema;
     };
     write: {
         description: string;
-        parameters: z.ZodObject<{
-            path: z.ZodString;
-        }>;
+        parameters: typeof WriteParamsSchema;
     };
 };
 export type ToolWithExecute = {
     cp: {
         description: string;
-        parameters: z.ZodObject<{
-            source: z.ZodString;
-            destination: z.ZodString;
-        }>;
-        execute: (args: {
-            source: string;
-            destination: string;
-        }) => Promise<string>;
+        parameters: typeof CpParamsSchema;
+        execute: (args: z.infer<typeof CpParamsSchema>) => Promise<string>;
     };
     mkdir: {
         description: string;
-        parameters: z.ZodObject<{
-            path: z.ZodString;
-            permissions: z.ZodDefault<z.ZodOptional<z.ZodString>>;
-        }>;
-        execute: (args: {
-            path: string;
-            permissions: string;
-        }) => Promise<string>;
+        parameters: typeof MkdirParamsSchema;
+        execute: (args: z.infer<typeof MkdirParamsSchema>) => Promise<string>;
     };
     ls: {
         description: string;
-        parameters: z.ZodObject<{
-            path: z.ZodString;
-        }>;
-        execute: (args: {
-            path: string;
-        }) => Promise<string>;
+        parameters: typeof LsParamsSchema;
+        execute: (args: z.infer<typeof LsParamsSchema>) => Promise<string>;
     };
     rm: {
         description: string;
-        parameters: z.ZodObject<{
-            path: z.ZodString;
-            recursive: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-        }>;
-        execute: (args: {
-            path: string;
-            recursive: boolean;
-        }) => Promise<string>;
+        parameters: typeof RmParamsSchema;
+        execute: (args: z.infer<typeof RmParamsSchema>) => Promise<string>;
     };
     read: {
         description: string;
-        parameters: z.ZodObject<{
-            path: z.ZodString;
-        }>;
-        execute: (args: {
-            path: string;
-        }) => Promise<string>;
+        parameters: typeof ReadParamsSchema;
+        execute: (args: z.infer<typeof ReadParamsSchema>) => Promise<string>;
     };
     write: {
         description: string;
-        parameters: z.ZodObject<{
-            path: z.ZodString;
-            content: z.ZodString;
-        }>;
-        execute: (args: {
-            path: string;
-            content: string;
-        }) => Promise<string>;
+        parameters: typeof WriteParamsSchema;
+        execute: (args: z.infer<typeof WriteParamsSchema>) => Promise<string>;
     };
 };

package/dist/sandbox/filesystem/types.js

@@ -1,2 +1,26 @@
 "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/network/index.d.ts

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

package/dist/sandbox/network/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("./network.js"), exports);

package/dist/sandbox/network/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 → network/network.js}

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

package/dist/sandbox/preview.d.ts

@@ -30,6 +30,7 @@ export declare class SandboxPreviews {
     get sandboxName(): string;
     list(): Promise<SandboxPreview[]>;
     create(preview: Preview): Promise<SandboxPreview>;
+    createIfNotExists(preview: Preview): Promise<SandboxPreview>;
     get(previewName: string): Promise<SandboxPreview>;
     delete(previewName: string): Promise<Preview>;
 }

package/dist/sandbox/preview.js

@@ -109,6 +109,18 @@ class SandboxPreviews {
         });
         return new SandboxPreview(data);
     }
+    async createIfNotExists(preview) {
+        try {
+            const previewInstance = await this.get(preview.metadata?.name ?? "");
+            return previewInstance;
+        }
+        catch (e) {
+            if (typeof e === "object" && e !== null && "code" in e && e.code === 404) {
+                return this.create(preview);
+            }
+            throw e;
+        }
+    }
     async get(previewName) {
         const { data } = await (0, index_js_1.getSandboxPreview)({
             path: {

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

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

package/dist/sandbox/process/index.js

@@ -0,0 +1,18 @@
+"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("./process.js"), exports);
+__exportStar(require("./types.js"), exports);

package/dist/sandbox/{process.d.ts → process/process.d.ts}

@@ -1,6 +1,7 @@
-import { Sandbox } from "../client/types.gen.js";
-import { SandboxAction } from "./action.js";
-import { DeleteProcessByIdentifierKillResponse, DeleteProcessByIdentifierResponse, GetProcessByIdentifierResponse, GetProcessResponse, PostProcessResponse, ProcessRequest } from "./client/index.js";
+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: {
@@ -20,4 +21,6 @@ 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;
 }

package/dist/sandbox/process/process.js

@@ -0,0 +1,272 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SandboxProcess = void 0;
+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 SandboxProcess extends action_js_1.SandboxAction {
+    constructor(sandbox) {
+        super(sandbox);
+    }
+    streamLogs(identifier, options) {
+        const controller = new AbortController();
+        (async () => {
+            try {
+                const headers = this.sandbox.forceUrl ? this.sandbox.headers : settings_js_1.settings.headers;
+                const stream = await fetch(`${this.url}/process/${identifier}/logs/stream`, {
+                    method: 'GET',
+                    signal: controller.signal,
+                    headers,
+                });
+                if (stream.status !== 200) {
+                    throw new Error(`Failed to stream logs: ${await stream.text()}`);
+                }
+                if (!stream.body)
+                    throw new Error('No stream body');
+                const reader = stream.body.getReader();
+                const decoder = new TextDecoder();
+                let buffer = '';
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    buffer += decoder.decode(value, { stream: true });
+                    let lines = buffer.split(/\r?\n/);
+                    buffer = lines.pop();
+                    for (const line of lines) {
+                        if (line.startsWith('stdout:')) {
+                            options.onStdout?.(line.slice(7));
+                            options.onLog?.(line.slice(7));
+                        }
+                        else if (line.startsWith('stderr:')) {
+                            options.onStderr?.(line.slice(7));
+                            options.onLog?.(line.slice(7));
+                        }
+                        else {
+                            options.onLog?.(line);
+                        }
+                    }
+                }
+            }
+            catch (err) {
+                if (err && err.name !== 'AbortError') {
+                    console.error("Stream error:", err);
+                    throw err;
+                }
+            }
+        })();
+        return {
+            close: () => controller.abort(),
+        };
+    }
+    async exec(process) {
+        const { response, data, error } = await (0, index_js_1.postProcess)({
+            body: process,
+            baseUrl: this.url,
+            client: this.client,
+        });
+        this.handleResponseError(response, data, error);
+        return data;
+    }
+    async wait(identifier, { maxWait = 60000, interval = 1000 } = {}) {
+        const startTime = Date.now();
+        let status = "running";
+        let data = await this.get(identifier);
+        while (status === "running") {
+            await new Promise((resolve) => setTimeout(resolve, interval));
+            try {
+                data = await this.get(identifier);
+                status = data.status ?? "running";
+            }
+            catch {
+                break;
+            }
+            if (Date.now() - startTime > maxWait) {
+                throw new Error("Process did not finish in time");
+            }
+        }
+        return data;
+    }
+    async get(identifier) {
+        const { response, data, error } = await (0, index_js_1.getProcessByIdentifier)({
+            path: { identifier },
+            baseUrl: this.url,
+            client: this.client,
+        });
+        this.handleResponseError(response, data, error);
+        return data;
+    }
+    async list() {
+        const { response, data, error } = await (0, index_js_1.getProcess)({
+            baseUrl: this.url,
+            client: this.client,
+        });
+        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,
+            client: this.client,
+        });
+        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,
+            client: this.client,
+        });
+        this.handleResponseError(response, data, error);
+        return data;
+    }
+    async logs(identifier, type = "all") {
+        const { response, data, error } = await (0, index_js_1.getProcessByIdentifierLogs)({
+            path: { identifier },
+            baseUrl: this.url,
+            client: this.client,
+        });
+        this.handleResponseError(response, data, error);
+        if (type === "all") {
+            return data?.logs || "";
+        }
+        else if (type === "stdout") {
+            return data?.stdout || "";
+        }
+        else if (type === "stderr") {
+            return data?.stderr || "";
+        }
+        throw new Error("Unsupported log type");
+    }
+    get toolsWithoutExecute() {
+        return {
+            exec: {
+                description: "Execute a process in the sandbox",
+                parameters: types_js_1.ExecParamsSchema,
+            },
+            wait: {
+                description: "Wait for a process to finish by identifier",
+                parameters: types_js_1.WaitParamsSchema,
+            },
+            get: {
+                description: "Get process info by identifier",
+                parameters: types_js_1.GetParamsSchema,
+            },
+            list: {
+                description: "List all processes in the sandbox",
+                parameters: types_js_1.ListParamsSchema,
+            },
+            stop: {
+                description: "Stop a process by identifier",
+                parameters: types_js_1.StopParamsSchema,
+            },
+            kill: {
+                description: "Kill a process by identifier",
+                parameters: types_js_1.KillParamsSchema,
+            },
+            logs: {
+                description: "Get logs for a process by identifier",
+                parameters: types_js_1.LogsParamsSchema,
+            },
+        };
+    }
+    get tools() {
+        return {
+            exec: {
+                description: "Execute a process in the sandbox",
+                parameters: types_js_1.ExecParamsSchema,
+                execute: async (args) => {
+                    try {
+                        const result = await this.exec(args.process);
+                        return JSON.stringify(result);
+                    }
+                    catch (e) {
+                        return JSON.stringify({ message: e.message, process: args.process });
+                    }
+                },
+            },
+            wait: {
+                description: "Wait for a process to finish by identifier",
+                parameters: types_js_1.WaitParamsSchema,
+                execute: async (args) => {
+                    try {
+                        const result = await this.wait(args.identifier, { maxWait: args.maxWait, interval: args.interval });
+                        return JSON.stringify(result);
+                    }
+                    catch (e) {
+                        return JSON.stringify({ message: e.message, identifier: args.identifier });
+                    }
+                },
+            },
+            get: {
+                description: "Get process info by identifier",
+                parameters: types_js_1.GetParamsSchema,
+                execute: async (args) => {
+                    try {
+                        const result = await this.get(args.identifier);
+                        return JSON.stringify(result);
+                    }
+                    catch (e) {
+                        return JSON.stringify({ message: e.message, identifier: args.identifier });
+                    }
+                },
+            },
+            list: {
+                description: "List all processes in the sandbox",
+                parameters: types_js_1.ListParamsSchema,
+                execute: async () => {
+                    try {
+                        const result = await this.list();
+                        return JSON.stringify(result);
+                    }
+                    catch (e) {
+                        return JSON.stringify({ message: e.message });
+                    }
+                },
+            },
+            stop: {
+                description: "Stop a process by identifier",
+                parameters: types_js_1.StopParamsSchema,
+                execute: async (args) => {
+                    try {
+                        const result = await this.stop(args.identifier);
+                        return JSON.stringify(result);
+                    }
+                    catch (e) {
+                        return JSON.stringify({ message: e.message, identifier: args.identifier });
+                    }
+                },
+            },
+            kill: {
+                description: "Kill a process by identifier",
+                parameters: types_js_1.KillParamsSchema,
+                execute: async (args) => {
+                    try {
+                        const result = await this.kill(args.identifier);
+                        return JSON.stringify(result);
+                    }
+                    catch (e) {
+                        return JSON.stringify({ message: e.message, identifier: args.identifier });
+                    }
+                },
+            },
+            logs: {
+                description: "Get logs for a process by identifier",
+                parameters: types_js_1.LogsParamsSchema,
+                execute: async (args) => {
+                    try {
+                        const result = await this.logs(args.identifier, args.type || "all");
+                        return JSON.stringify({ logs: result });
+                    }
+                    catch (e) {
+                        return JSON.stringify({ message: e.message, identifier: args.identifier });
+                    }
+                },
+            },
+        };
+    }
+}
+exports.SandboxProcess = SandboxProcess;

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

@@ -0,0 +1,120 @@
+import { z } from "zod";
+export declare const ExecParamsSchema: z.ZodObject<{
+    process: z.ZodAny;
+}, "strip", z.ZodTypeAny, {
+    process?: any;
+}, {
+    process?: any;
+}>;
+export declare const WaitParamsSchema: z.ZodObject<{
+    identifier: z.ZodString;
+    maxWait: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    interval: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    identifier: string;
+    maxWait: number;
+    interval: number;
+}, {
+    identifier: string;
+    maxWait?: number | undefined;
+    interval?: number | undefined;
+}>;
+export declare const GetParamsSchema: z.ZodObject<{
+    identifier: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    identifier: string;
+}, {
+    identifier: string;
+}>;
+export declare const ListParamsSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export declare const StopParamsSchema: z.ZodObject<{
+    identifier: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    identifier: string;
+}, {
+    identifier: string;
+}>;
+export declare const KillParamsSchema: z.ZodObject<{
+    identifier: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    identifier: string;
+}, {
+    identifier: string;
+}>;
+export declare const LogsParamsSchema: z.ZodObject<{
+    identifier: z.ZodString;
+    type: z.ZodDefault<z.ZodOptional<z.ZodEnum<["stdout", "stderr", "all"]>>>;
+}, "strip", z.ZodTypeAny, {
+    type: "stdout" | "stderr" | "all";
+    identifier: string;
+}, {
+    identifier: string;
+    type?: "stdout" | "stderr" | "all" | undefined;
+}>;
+export type ProcessToolWithoutExecute = {
+    exec: {
+        description: string;
+        parameters: typeof ExecParamsSchema;
+    };
+    wait: {
+        description: string;
+        parameters: typeof WaitParamsSchema;
+    };
+    get: {
+        description: string;
+        parameters: typeof GetParamsSchema;
+    };
+    list: {
+        description: string;
+        parameters: typeof ListParamsSchema;
+    };
+    stop: {
+        description: string;
+        parameters: typeof StopParamsSchema;
+    };
+    kill: {
+        description: string;
+        parameters: typeof KillParamsSchema;
+    };
+    logs: {
+        description: string;
+        parameters: typeof LogsParamsSchema;
+    };
+};
+export type ProcessToolWithExecute = {
+    exec: {
+        description: string;
+        parameters: typeof ExecParamsSchema;
+        execute: (args: z.infer<typeof ExecParamsSchema>) => Promise<string>;
+    };
+    wait: {
+        description: string;
+        parameters: typeof WaitParamsSchema;
+        execute: (args: z.infer<typeof WaitParamsSchema>) => Promise<string>;
+    };
+    get: {
+        description: string;
+        parameters: typeof GetParamsSchema;
+        execute: (args: z.infer<typeof GetParamsSchema>) => Promise<string>;
+    };
+    list: {
+        description: string;
+        parameters: typeof ListParamsSchema;
+        execute: (args: z.infer<typeof ListParamsSchema>) => Promise<string>;
+    };
+    stop: {
+        description: string;
+        parameters: typeof StopParamsSchema;
+        execute: (args: z.infer<typeof StopParamsSchema>) => Promise<string>;
+    };
+    kill: {
+        description: string;
+        parameters: typeof KillParamsSchema;
+        execute: (args: z.infer<typeof KillParamsSchema>) => Promise<string>;
+    };
+    logs: {
+        description: string;
+        parameters: typeof LogsParamsSchema;
+        execute: (args: z.infer<typeof LogsParamsSchema>) => Promise<string>;
+    };
+};

package/dist/sandbox/process/types.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogsParamsSchema = exports.KillParamsSchema = exports.StopParamsSchema = exports.ListParamsSchema = exports.GetParamsSchema = exports.WaitParamsSchema = exports.ExecParamsSchema = void 0;
+const zod_1 = require("zod");
+exports.ExecParamsSchema = zod_1.z.object({
+    process: zod_1.z.any().describe("ProcessRequest object to execute in the sandbox"), // Refine if you have a zod schema for ProcessRequest
+}).describe("Parameters for executing a process in the sandbox");
+exports.WaitParamsSchema = zod_1.z.object({
+    identifier: zod_1.z.string().describe("Process identifier to wait for"),
+    maxWait: zod_1.z.number().optional().default(60000).describe("Maximum wait time in milliseconds (default 60000)"),
+    interval: zod_1.z.number().optional().default(1000).describe("Polling interval in milliseconds (default 1000)"),
+}).describe("Parameters for waiting for a process to finish");
+exports.GetParamsSchema = zod_1.z.object({
+    identifier: zod_1.z.string().describe("Process identifier to get info for"),
+}).describe("Parameters for getting process info");
+exports.ListParamsSchema = zod_1.z.object({}).describe("Parameters for listing all processes (none)");
+exports.StopParamsSchema = zod_1.z.object({
+    identifier: zod_1.z.string().describe("Process identifier to stop"),
+}).describe("Parameters for stopping a process");
+exports.KillParamsSchema = zod_1.z.object({
+    identifier: zod_1.z.string().describe("Process identifier to kill"),
+}).describe("Parameters for killing a process");
+exports.LogsParamsSchema = zod_1.z.object({
+    identifier: zod_1.z.string().describe("Process identifier to get logs for"),
+    type: zod_1.z.enum(["stdout", "stderr", "all"]).optional().default("all").describe("Type of logs to retrieve: stdout, stderr, or all (default all)"),
+}).describe("Parameters for retrieving process logs");

package/dist/sandbox/sandbox.d.ts

@@ -1,8 +1,8 @@
 import { Sandbox as SandboxModel } from "../client/index.js";
 import { SandboxFileSystem } from "./filesystem/index.js";
-import { SandboxNetwork } from "./network.js";
+import { SandboxNetwork } from "./network/index.js";
 import { SandboxPreviews } from "./preview.js";
-import { SandboxProcess } from "./process.js";
+import { SandboxProcess } from "./process/index.js";
 import { SandboxSessions } from "./session.js";
 import { SandboxConfiguration, SessionWithToken } from "./types.js";
 export declare class SandboxInstance {
@@ -25,5 +25,6 @@ export declare class SandboxInstance {
     static get(sandboxName: string): Promise<SandboxInstance>;
     static list(): Promise<SandboxInstance[]>;
     static delete(sandboxName: string): Promise<SandboxModel>;
+    static createIfNotExists(sandbox: SandboxModel): Promise<SandboxInstance>;
     static fromSession(session: SessionWithToken): Promise<SandboxInstance>;
 }

package/dist/sandbox/sandbox.js

@@ -4,9 +4,9 @@ exports.SandboxInstance = void 0;
 const index_js_1 = require("../client/index.js");
 const logger_js_1 = require("../common/logger.js");
 const index_js_2 = require("./filesystem/index.js");
-const network_js_1 = require("./network.js");
+const index_js_3 = require("./network/index.js");
 const preview_js_1 = require("./preview.js");
-const process_js_1 = require("./process.js");
+const index_js_4 = require("./process/index.js");
 const session_js_1 = require("./session.js");
 class SandboxInstance {
     sandbox;
@@ -18,8 +18,8 @@ class SandboxInstance {
     constructor(sandbox) {
         this.sandbox = sandbox;
         this.fs = new index_js_2.SandboxFileSystem(sandbox);
-        this.network = new network_js_1.SandboxNetwork(sandbox);
-        this.process = new process_js_1.SandboxProcess(sandbox);
+        this.network = new index_js_3.SandboxNetwork(sandbox);
+        this.process = new index_js_4.SandboxProcess(sandbox);
         this.previews = new preview_js_1.SandboxPreviews(sandbox);
         this.sessions = new session_js_1.SandboxSessions(sandbox);
     }
@@ -94,6 +94,18 @@ class SandboxInstance {
         });
         return data;
     }
+    static async createIfNotExists(sandbox) {
+        try {
+            const sandboxInstance = await SandboxInstance.get(sandbox.metadata?.name ?? "");
+            return sandboxInstance;
+        }
+        catch (e) {
+            if (typeof e === "object" && e !== null && "code" in e && e.code === 404) {
+                return SandboxInstance.create(sandbox);
+            }
+            throw e;
+        }
+    }
     static async fromSession(session) {
         return new SandboxInstance({ forceUrl: session.url, params: { bl_preview_token: session.token }, headers: { "X-Blaxel-Preview-Token": session.token } });
     }

package/dist/sandbox/session.d.ts

@@ -5,6 +5,12 @@ export declare class SandboxSessions {
     constructor(sandbox: Sandbox);
     get sandboxName(): string;
     create(options?: SessionCreateOptions): Promise<SessionWithToken>;
+    createIfExpired(options?: SessionCreateOptions, delta?: number): Promise<{
+        name: string;
+        url: string;
+        token: string;
+        expiresAt: string | Date;
+    }>;
     list(): Promise<{
         name: string;
         url: string;

package/dist/sandbox/session.js

@@ -41,6 +41,27 @@ class SandboxSessions {
             expiresAt: typeof tokenObj.expiresAt === 'string' ? new Date(tokenObj.expiresAt) : tokenObj.expiresAt,
         };
     }
+    async createIfExpired(options = {}, delta = 1000 * 60 * 60) {
+        // First, list all sessions
+        const allSessions = await this.list();
+        // Variable to hold our final session
+        let sessionData;
+        const now = new Date();
+        const threshold = new Date(now.getTime() + delta);
+        // If no valid session exists, create a new one
+        if (allSessions.length > 0) {
+            sessionData = allSessions[0];
+            if (sessionData.expiresAt < threshold) {
+                await this.delete(sessionData.name);
+                sessionData = await this.create(options);
+            }
+        }
+        else {
+            // Create a new session
+            sessionData = await this.create(options);
+        }
+        return sessionData;
+    }
     async list() {
         const { data } = await (0, index_js_1.listSandboxPreviews)({
             path: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blaxel/core",
-  "version": "0.2.10-dev.79",
+  "version": "0.2.10-dev.80",
   "description": "Blaxel Core SDK for TypeScript",
   "license": "MIT",
   "author": "Blaxel, INC (https://blaxel.ai)",

package/dist/sandbox/network.d.ts

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

package/dist/sandbox/process.js

@@ -1,144 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SandboxProcess = void 0;
-const settings_js_1 = require("../common/settings.js");
-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);
-    }
-    streamLogs(identifier, options) {
-        const controller = new AbortController();
-        (async () => {
-            try {
-                const headers = this.sandbox.forceUrl ? this.sandbox.headers : settings_js_1.settings.headers;
-                const stream = await fetch(`${this.url}/process/${identifier}/logs/stream`, {
-                    method: 'GET',
-                    signal: controller.signal,
-                    headers,
-                });
-                if (stream.status !== 200) {
-                    throw new Error(`Failed to stream logs: ${await stream.text()}`);
-                }
-                if (!stream.body)
-                    throw new Error('No stream body');
-                const reader = stream.body.getReader();
-                const decoder = new TextDecoder();
-                let buffer = '';
-                while (true) {
-                    const { done, value } = await reader.read();
-                    if (done)
-                        break;
-                    buffer += decoder.decode(value, { stream: true });
-                    let lines = buffer.split(/\r?\n/);
-                    buffer = lines.pop();
-                    for (const line of lines) {
-                        if (line.startsWith('stdout:')) {
-                            options.onStdout?.(line.slice(7));
-                            options.onLog?.(line.slice(7));
-                        }
-                        else if (line.startsWith('stderr:')) {
-                            options.onStderr?.(line.slice(7));
-                            options.onLog?.(line.slice(7));
-                        }
-                        else {
-                            options.onLog?.(line);
-                        }
-                    }
-                }
-            }
-            catch (err) {
-                if (err && err.name !== 'AbortError') {
-                    console.error("Stream error:", err);
-                    throw err;
-                }
-            }
-        })();
-        return {
-            close: () => controller.abort(),
-        };
-    }
-    async exec(process) {
-        const { response, data, error } = await (0, index_js_1.postProcess)({
-            body: process,
-            baseUrl: this.url,
-            client: this.client,
-        });
-        this.handleResponseError(response, data, error);
-        return data;
-    }
-    async wait(identifier, { maxWait = 60000, interval = 1000 } = {}) {
-        const startTime = Date.now();
-        let status = "running";
-        let data = await this.get(identifier);
-        while (status === "running") {
-            await new Promise((resolve) => setTimeout(resolve, interval));
-            try {
-                data = await this.get(identifier);
-                status = data.status ?? "running";
-            }
-            catch {
-                break;
-            }
-            if (Date.now() - startTime > maxWait) {
-                throw new Error("Process did not finish in time");
-            }
-        }
-        return data;
-    }
-    async get(identifier) {
-        const { response, data, error } = await (0, index_js_1.getProcessByIdentifier)({
-            path: { identifier },
-            baseUrl: this.url,
-            client: this.client,
-        });
-        this.handleResponseError(response, data, error);
-        return data;
-    }
-    async list() {
-        const { response, data, error } = await (0, index_js_1.getProcess)({
-            baseUrl: this.url,
-            client: this.client,
-        });
-        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,
-            client: this.client,
-        });
-        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,
-            client: this.client,
-        });
-        this.handleResponseError(response, data, error);
-        return data;
-    }
-    async logs(identifier, type = "all") {
-        const { response, data, error } = await (0, index_js_1.getProcessByIdentifierLogs)({
-            path: { identifier },
-            baseUrl: this.url,
-            client: this.client,
-        });
-        this.handleResponseError(response, data, error);
-        if (type === "all") {
-            return data?.logs || "";
-        }
-        else if (type === "stdout") {
-            return data?.stdout || "";
-        }
-        else if (type === "stderr") {
-            return data?.stderr || "";
-        }
-        throw new Error("Unsupported log type");
-    }
-}
-exports.SandboxProcess = SandboxProcess;