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

package/dist/sandbox/process/process.js

@@ -4,7 +4,6 @@ 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);
@@ -141,132 +140,5 @@ class SandboxProcess extends action_js_1.SandboxAction {
         }
         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.d.ts

@@ -0,0 +1,23 @@
+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);
+    streamLogs(identifier: string, options: {
+        onLog?: (log: string) => void;
+        onStdout?: (stdout: string) => void;
+        onStderr?: (stderr: string) => void;
+    }): {
+        close: () => void;
+    };
+    exec(process: ProcessRequest): Promise<PostProcessResponse>;
+    wait(identifier: string, { maxWait, interval }?: {
+        maxWait?: number;
+        interval?: number;
+    }): Promise<GetProcessByIdentifierResponse>;
+    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,138 @@
+"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 = "stdout") {
+        const { response, data, error } = await (0, index_js_1.getProcessByIdentifierLogs)({
+            path: { identifier },
+            baseUrl: this.url,
+            client: this.client,
+        });
+        this.handleResponseError(response, data, error);
+        if (data && type in data) {
+            return data[type];
+        }
+        throw new Error("Unsupported log type");
+    }
+}
+exports.SandboxProcess = SandboxProcess;

package/dist/tools/index.d.ts

@@ -1,6 +1,6 @@
 import { Function } from "../client/client.js";
 import { Tool } from "./types.js";
-export declare const getTool: (name: string) => Promise<Tool[]>;
+export declare const getTool: (name: string, ms?: number) => Promise<Tool[]>;
 export declare class BLTools {
     toolNames: string[];
     constructor(toolNames: string[]);

package/dist/tools/index.js

@@ -5,8 +5,8 @@ const index_js_1 = require("../cache/index.js");
 const client_js_1 = require("../client/client.js");
 const env_js_1 = require("../common/env.js");
 const mcpTool_js_1 = require("./mcpTool.js");
-const getTool = async (name) => {
-    return await (0, mcpTool_js_1.getMcpTool)(name);
+const getTool = async (name, ms) => {
+    return await (0, mcpTool_js_1.getMcpTool)(name, ms);
 };
 exports.getTool = getTool;
 class BLTools {

package/dist/tools/mcpTool.d.ts

@@ -1,6 +1,8 @@
 import { Tool } from "./types.js";
 export declare class McpTool {
     private name;
+    private type;
+    private pluralType;
     private client;
     private transport?;
     private timer?;
@@ -18,4 +20,4 @@ export declare class McpTool {
     listTools(): Promise<Tool[]>;
     call(toolName: string, args: Record<string, unknown> | undefined): Promise<unknown>;
 }
-export declare const getMcpTool: (name: string) => Promise<Tool[]>;
+export declare const getMcpTool: (name: string, ms?: number) => Promise<Tool[]>;

package/dist/tools/mcpTool.js

@@ -13,6 +13,8 @@ const zodSchema_js_1 = require("./zodSchema.js");
 const McpToolCache = new Map();
 class McpTool {
     name;
+    type;
+    pluralType;
     client;
     transport;
     timer;
@@ -20,6 +22,13 @@ class McpTool {
     startPromise;
     constructor(name, ms = 5000) {
         this.name = name;
+        this.type = "function";
+        this.pluralType = "functions";
+        if (name.startsWith("sandbox/") || name.startsWith("sandboxes/")) {
+            this.name = name.split("/")[1];
+            this.type = "sandbox";
+            this.pluralType = "sandboxes";
+        }
         if (env_js_1.env.BL_CLOUD) {
             this.ms = 0;
         }
@@ -42,16 +51,16 @@ class McpTool {
         return null;
     }
     get externalUrl() {
-        return new URL(`${settings_js_1.settings.runUrl}/${settings_js_1.settings.workspace}/functions/${this.name}`);
+        return new URL(`${settings_js_1.settings.runUrl}/${settings_js_1.settings.workspace}/${this.pluralType}/${this.name}`);
     }
     get internalUrl() {
-        const hash = (0, internal_js_1.getGlobalUniqueHash)(settings_js_1.settings.workspace, "function", this.name);
+        const hash = (0, internal_js_1.getGlobalUniqueHash)(settings_js_1.settings.workspace, this.type, this.name);
         return new URL(`${settings_js_1.settings.runInternalProtocol}://bl-${settings_js_1.settings.env}-${hash}.${settings_js_1.settings.runInternalHostname}`);
     }
     get forcedUrl() {
         const envVar = this.name.replace(/-/g, "_").toUpperCase();
-        if (env_js_1.env[`BL_FUNCTION_${envVar}_URL`]) {
-            return new URL(env_js_1.env[`BL_FUNCTION_${envVar}_URL`]);
+        if (env_js_1.env[`BL_${this.pluralType.toUpperCase()}_${envVar}_URL`]) {
+            return new URL(env_js_1.env[`BL_${this.pluralType.toUpperCase()}_${envVar}_URL`]);
         }
         return null;
     }
@@ -68,7 +77,7 @@ class McpTool {
         this.startPromise = this.startPromise || (async () => {
             await (0, index_js_2.authenticate)();
             try {
-                logger_js_1.logger.debug(`MCP:${this.name}:Connecting`);
+                logger_js_1.logger.debug(`MCP:${this.name}:Connecting::${this.url.toString()}`);
                 this.transport = new client_js_1.BlaxelMcpClientTransport(this.url.toString(), settings_js_1.settings.headers);
                 await this.client.connect(this.transport);
                 logger_js_1.logger.debug(`MCP:${this.name}:Connected`);
@@ -121,7 +130,6 @@ class McpTool {
             logger_js_1.logger.debug(`MCP:${this.name}:Listing tools`);
             await this.start();
             const { tools } = (await this.client.listTools());
-            logger_js_1.logger.debug(`MCP:${this.name}:Listed tools result`, tools);
             await this.close();
             const result = tools.map((tool) => {
                 return {
@@ -181,11 +189,11 @@ class McpTool {
     }
 }
 exports.McpTool = McpTool;
-const getMcpTool = async (name) => {
+const getMcpTool = async (name, ms) => {
     let tool = McpToolCache.get(name);
     if (!tool) {
         logger_js_1.logger.debug(`MCP:${name}:Creating new tool`);
-        tool = new McpTool(name);
+        tool = new McpTool(name, ms);
         McpToolCache.set(name, tool);
     }
     return await tool.listTools();

package/package.json

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