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

package/dist/esm/client/responseInterceptor.js

@@ -0,0 +1,49 @@
+/**
+ * Response interceptor that enhances authentication error messages (401/403)
+ * with a link to the authentication documentation.
+ */
+/**
+ * Intercepts HTTP responses and adds authentication documentation
+ * to 401/403 error responses
+ */
+export const authenticationErrorInterceptor = async (response) => {
+    // Only process authentication errors (401/403)
+    if (response.status !== 401 && response.status !== 403) {
+        return response;
+    }
+    // Clone the response so we can modify it
+    const clonedResponse = response.clone();
+    try {
+        // Read the original response body
+        const bodyText = await clonedResponse.text();
+        // Try to parse as JSON
+        let enhancedBody;
+        try {
+            const originalError = JSON.parse(bodyText);
+            // Create enhanced error with authentication documentation
+            const authError = {
+                ...originalError,
+                documentation: "For more information on authentication, visit: https://docs.blaxel.ai/sdk-reference/introduction#how-authentication-works",
+            };
+            enhancedBody = JSON.stringify(authError);
+        }
+        catch {
+            // If not JSON, just append the documentation as text
+            enhancedBody = `${bodyText}\nFor more information on authentication, visit: https://docs.blaxel.ai/sdk-reference/introduction#how-authentication-works`;
+        }
+        // Create a new response with the enhanced body
+        return new Response(enhancedBody, {
+            status: response.status,
+            statusText: response.statusText,
+            headers: response.headers,
+        });
+    }
+    catch (error) {
+        // If anything fails, return the original response
+        console.error("Error processing authentication error response:", error);
+        return response;
+    }
+};
+export const responseInterceptors = [
+    authenticationErrorInterceptor,
+];

package/dist/esm/client/sdk.gen.js

@@ -310,6 +310,70 @@ export const listFunctionRevisions = (options) => {
         ...options
     });
 };
+/**
+ * List images
+ * Returns a list of all images in the workspace grouped by repository with tags.
+ */
+export const listImages = (options) => {
+    return (options?.client ?? _heyApiClient).get({
+        security: [
+            {
+                scheme: 'bearer',
+                type: 'http'
+            }
+        ],
+        url: '/images',
+        ...options
+    });
+};
+/**
+ * Delete image by name
+ * Deletes an image by name.
+ */
+export const deleteImage = (options) => {
+    return (options.client ?? _heyApiClient).delete({
+        security: [
+            {
+                scheme: 'bearer',
+                type: 'http'
+            }
+        ],
+        url: '/images/{resourceType}/{imageName}',
+        ...options
+    });
+};
+/**
+ * Get image by name
+ * Returns an image by name.
+ */
+export const getImage = (options) => {
+    return (options.client ?? _heyApiClient).get({
+        security: [
+            {
+                scheme: 'bearer',
+                type: 'http'
+            }
+        ],
+        url: '/images/{resourceType}/{imageName}',
+        ...options
+    });
+};
+/**
+ * Delete image tag
+ * Deletes a specific tag from an image.
+ */
+export const deleteImageTag = (options) => {
+    return (options.client ?? _heyApiClient).delete({
+        security: [
+            {
+                scheme: 'bearer',
+                type: 'http'
+            }
+        ],
+        url: '/images/{resourceType}/{imageName}/tags/{tagName}',
+        ...options
+    });
+};
 /**
  * List integrations connections
  * Returns integration information by name.
@@ -550,6 +614,74 @@ export const updateJob = (options) => {
         }
     });
 };
+/**
+ * List job executions
+ * Returns a list of all executions for a job by name.
+ */
+export const listJobExecutions = (options) => {
+    return (options.client ?? _heyApiClient).get({
+        security: [
+            {
+                scheme: 'bearer',
+                type: 'http'
+            }
+        ],
+        url: '/jobs/{jobId}/executions',
+        ...options
+    });
+};
+/**
+ * Create job execution
+ * Creates a new execution for a job by name.
+ */
+export const createJobExecution = (options) => {
+    return (options.client ?? _heyApiClient).post({
+        security: [
+            {
+                scheme: 'bearer',
+                type: 'http'
+            }
+        ],
+        url: '/jobs/{jobId}/executions',
+        ...options,
+        headers: {
+            'Content-Type': 'application/json',
+            ...options?.headers
+        }
+    });
+};
+/**
+ * Delete job execution
+ * Stop an execution for a job by name.
+ */
+export const deleteJobExecution = (options) => {
+    return (options.client ?? _heyApiClient).delete({
+        security: [
+            {
+                scheme: 'bearer',
+                type: 'http'
+            }
+        ],
+        url: '/jobs/{jobId}/executions/{executionId}',
+        ...options
+    });
+};
+/**
+ * Get job execution
+ * Returns an execution for a job by name.
+ */
+export const getJobExecution = (options) => {
+    return (options.client ?? _heyApiClient).get({
+        security: [
+            {
+                scheme: 'bearer',
+                type: 'http'
+            }
+        ],
+        url: '/jobs/{jobId}/executions/{executionId}',
+        ...options
+    });
+};
 /**
  * List job revisions
  * Returns revisions for a job by name.

package/dist/esm/common/autoload.js

@@ -1,16 +1,23 @@
 import { client } from "../client/client.gen.js";
 import { interceptors } from "../client/interceptors.js";
+import { responseInterceptors } from "../client/responseInterceptor.js";
 import { client as clientSandbox } from "../sandbox/client/client.gen.js";
 import { settings } from "./settings.js";
 client.setConfig({
     baseUrl: settings.baseUrl,
 });
+// Register request interceptors
 for (const interceptor of interceptors) {
     // @ts-expect-error - Interceptor is not typed
     client.interceptors.request.use(interceptor);
     // @ts-expect-error - Interceptor is not typed
     clientSandbox.interceptors.request.use(interceptor);
 }
+// Register response interceptors for authentication error handling
+for (const interceptor of responseInterceptors) {
+    client.interceptors.response.use(interceptor);
+    clientSandbox.interceptors.response.use(interceptor);
+}
 // Allow to set custom configuration for browser environment
 export function initialize(config) {
     settings.setConfig(config);

package/dist/esm/common/env.js

@@ -8,6 +8,7 @@ if (fs !== null) {
         const configInfos = toml.parse(configFile);
         for (const key in configInfos.env) {
             configEnv[key] = configInfos.env[key];
+            process.env[key] = configInfos.env[key];
         }
     }
     catch {
@@ -18,6 +19,7 @@ if (fs !== null) {
         if (dotenv) {
             const parsed = dotenv.parse(secretFile);
             Object.assign(secretEnv, parsed);
+            Object.assign(process.env, parsed);
         }
         else {
             // Simple .env parsing fallback when dotenv is not available
@@ -26,6 +28,7 @@ if (fs !== null) {
                 const match = line.match(/^([^=]+)=(.*)$/);
                 if (match) {
                     secretEnv[match[1].trim()] = match[2].trim();
+                    process.env[match[1].trim()] = match[2].trim();
                 }
             }
         }

package/dist/esm/common/internal.js

@@ -180,41 +180,3 @@ export function getForcedUrl(type, name) {
     }
     return null;
 }
-export function getWorkloadTypeShort(type) {
-    const lowerType = type.toLowerCase();
-    switch (lowerType) {
-        case 'agent':
-        case 'agents':
-            return 'agt';
-        case 'mcp':
-        case 'mcps':
-        case 'function':
-        case 'functions':
-            return 'mcp';
-        case 'sandbox':
-        case 'sandboxes':
-            return 'sbx';
-        case 'job':
-        case 'jobs':
-            return 'job';
-        case 'model':
-        case 'models':
-            return 'mdl';
-        default:
-            // fallback to first 3 letters of type
-            return lowerType.substring(0, 3);
-    }
-}
-export function generateInternalUrl(workspace, type, name, env, protocol, hostname, blCloud, workspaceId) {
-    if (blCloud && workspaceId) {
-        // New cloud format: bl-ENV-WORKLOAD_CALLED_NAME-WORKLOAD_TYPE_SHORT-WORKSPACE_ID
-        const workloadTypeShort = getWorkloadTypeShort(type);
-        const subdomain = `bl-${env}-${name}-${workloadTypeShort}-${workspaceId}`;
-        return `${protocol}://${subdomain}.${hostname}`;
-    }
-    else {
-        // Legacy format: bl-ENV-HASH.internalhostname
-        const hash = getGlobalUniqueHash(workspace, type, name);
-        return `${protocol}://bl-${env}-${hash}.${hostname}`;
-    }
-}

package/dist/esm/common/settings.js

@@ -7,7 +7,7 @@ function getPackageVersion() {
         if (typeof require !== "undefined") {
             // Try to require package.json (Node.js only, gracefully fails in browser)
             // eslint-disable-next-line @typescript-eslint/no-require-imports
-            const packageJson = {"version":"0.2.49-dev.214","commit":"3cd25c395e498b34304684d4d76a906f2cef14a9"};
+            const packageJson = {"version":"0.2.49","commit":"3523e3d6b67057292fade1b12e304be6456fd2bc"};
             return packageJson.version || "unknown";
         }
         else {
@@ -59,7 +59,7 @@ function getCommitHash() {
         if (typeof require !== "undefined") {
             // Try to require package.json and look for commit field (set during build)
             // eslint-disable-next-line @typescript-eslint/no-require-imports
-            const packageJson = {"version":"0.2.49-dev.214","commit":"3cd25c395e498b34304684d4d76a906f2cef14a9"};
+            const packageJson = {"version":"0.2.49","commit":"3523e3d6b67057292fade1b12e304be6456fd2bc"};
             // Check for commit in various possible locations
             const commit = packageJson.commit || packageJson.buildInfo?.commit;
             if (commit) {
@@ -162,9 +162,6 @@ class Settings {
     get blCloud() {
         return env.BL_CLOUD === "true";
     }
-    get workspaceId() {
-        return env.BL_WORKSPACE_ID || "";
-    }
     get generation() {
         return env.BL_GENERATION || "";
     }

package/dist/esm/common/version.js

@@ -0,0 +1,3 @@
+// This file is auto-generated during build. Do not edit manually.
+export const PACKAGE_VERSION = "0.2.49";
+export const PACKAGE_COMMIT = "4548518514109c742457451a6eb36fa8d054eb9b";

package/dist/esm/common/webhook.js

@@ -0,0 +1,97 @@
+import { createHmac, timingSafeEqual } from 'crypto';
+/**
+ * Verify the HMAC-SHA256 signature of a webhook callback from async-sidecar
+ *
+ * @example
+ * ```typescript
+ * import { verifyWebhookSignature } from '@blaxel/core';
+ *
+ * // In your Express endpoint
+ * app.post('/webhook', express.text({ type: 'application/json' }), (req, res) => {
+ *   const isValid = verifyWebhookSignature({
+ *     body: req.body,
+ *     signature: req.headers['x-blaxel-signature'] as string,
+ *     secret: process.env.CALLBACK_SECRET!
+ *   });
+ *
+ *   if (!isValid) {
+ *     return res.status(401).json({ error: 'Invalid signature' });
+ *   }
+ *
+ *   const data = JSON.parse(req.body);
+ *   // Process callback...
+ * });
+ * ```
+ *
+ * @param options - Verification options
+ * @returns true if the signature is valid, false otherwise
+ */
+export function verifyWebhookSignature(options) {
+    const { body, signature, secret, timestamp, maxAge = 300 } = options;
+    if (!body || !signature || !secret) {
+        return false;
+    }
+    try {
+        // Verify timestamp if provided (prevents replay attacks)
+        if (timestamp) {
+            const requestTime = parseInt(timestamp, 10);
+            const currentTime = Math.floor(Date.now() / 1000);
+            const age = Math.abs(currentTime - requestTime);
+            if (isNaN(requestTime) || age > maxAge) {
+                return false;
+            }
+        }
+        // Extract hex signature from "sha256=<hex>" format
+        const expectedSignature = signature.replace('sha256=', '');
+        // Compute HMAC-SHA256 signature
+        const hmac = createHmac('sha256', secret);
+        hmac.update(body);
+        const computedSignature = hmac.digest('hex');
+        // Timing-safe comparison to prevent timing attacks
+        return timingSafeEqual(Buffer.from(expectedSignature, 'hex'), Buffer.from(computedSignature, 'hex'));
+    }
+    catch {
+        // Invalid signature format or other error
+        return false;
+    }
+}
+/**
+ * Helper to verify webhook from Express request object
+ *
+ * @example
+ * ```typescript
+ * import { verifyWebhookFromRequest } from '@blaxel/core';
+ * import express from 'express';
+ *
+ * app.use(express.text({ type: 'application/json' }));
+ *
+ * app.post('/webhook', (req, res) => {
+ *   if (!verifyWebhookFromRequest(req, process.env.CALLBACK_SECRET!)) {
+ *     return res.status(401).json({ error: 'Invalid signature' });
+ *   }
+ *
+ *   const data = JSON.parse(req.body);
+ *   console.log('Received callback:', data);
+ *   res.json({ received: true });
+ * });
+ * ```
+ *
+ * @param request - Express request object (must use express.text() middleware)
+ * @param secret - The callback secret
+ * @param maxAge - Optional maximum age in seconds (default: 300)
+ * @returns true if the signature is valid, false otherwise
+ */
+export function verifyWebhookFromRequest(request, secret, maxAge) {
+    const signature = request.headers['x-blaxel-signature'];
+    const timestamp = request.headers['x-blaxel-timestamp'];
+    if (typeof signature !== 'string') {
+        return false;
+    }
+    return verifyWebhookSignature({
+        body: request.body,
+        signature,
+        secret,
+        timestamp: typeof timestamp === 'string' ? timestamp : undefined,
+        maxAge
+    });
+}

package/dist/esm/jobs/executions.js

@@ -0,0 +1,114 @@
+import { createJobExecution, getJobExecution, listJobExecutions, deleteJobExecution } from "../client/sdk.gen.js";
+import { logger } from "../common/logger.js";
+import { settings } from "../common/settings.js";
+/**
+ * JobExecutionHelper provides convenient methods for working with job executions
+ */
+export class JobExecutionHelper {
+    jobName;
+    constructor(jobName) {
+        this.jobName = jobName;
+    }
+    /**
+     * Create a new job execution and return the execution ID
+     */
+    async create(request) {
+        logger.debug(`Creating execution for job: ${this.jobName}`);
+        const response = await createJobExecution({
+            path: {
+                jobId: this.jobName,
+            },
+            body: request,
+            headers: settings.headers,
+        });
+        if (!response.data) {
+            throw new Error("No response data returned from create job execution");
+        }
+        const execution = response.data;
+        if (!execution.metadata?.id) {
+            throw new Error("No execution ID returned from create job execution");
+        }
+        logger.debug(`Created execution: ${execution.metadata.id}`);
+        return execution.metadata.id;
+    }
+    /**
+     * Get a specific job execution by ID
+     */
+    async get(executionId) {
+        logger.debug(`Getting execution ${executionId} for job: ${this.jobName}`);
+        const response = await getJobExecution({
+            path: {
+                jobId: this.jobName,
+                executionId: executionId,
+            },
+            headers: settings.headers,
+        });
+        if (!response.data) {
+            throw new Error(`Execution '${executionId}' not found for job '${this.jobName}'`);
+        }
+        return response.data;
+    }
+    /**
+     * List all executions for the job
+     */
+    async list() {
+        logger.debug(`Listing executions for job: ${this.jobName}`);
+        const response = await listJobExecutions({
+            path: {
+                jobId: this.jobName,
+            },
+            headers: settings.headers,
+        });
+        return response.data ?? [];
+    }
+    /**
+     * Get the status of a specific execution
+     */
+    async getStatus(executionId) {
+        const execution = await this.get(executionId);
+        return execution.status ?? "UNKNOWN";
+    }
+    /**
+     * Delete a specific job execution
+     */
+    async delete(executionId) {
+        logger.debug(`Deleting execution ${executionId} for job: ${this.jobName}`);
+        await deleteJobExecution({
+            path: {
+                jobId: this.jobName,
+                executionId: executionId,
+            },
+            headers: settings.headers,
+        });
+    }
+    /**
+     * Wait for an execution to complete
+     * @param executionId The execution ID to wait for
+     * @param options.maxWait Maximum time to wait in milliseconds (default: 5 minutes)
+     * @param options.interval Polling interval in milliseconds (default: 2 seconds)
+     */
+    async waitForCompletion(executionId, options = {}) {
+        const maxWait = options.maxWait ?? 300000; // 5 minutes default
+        const interval = options.interval ?? 2000; // 2 seconds default
+        const startTime = Date.now();
+        logger.debug(`Waiting for execution ${executionId} to complete (max ${maxWait}ms)`);
+        while (Date.now() - startTime < maxWait) {
+            const execution = await this.get(executionId);
+            const status = execution.status;
+            // Terminal states
+            if (status === "COMPLETED" || status === "FAILED" || status === "CANCELLED") {
+                logger.debug(`Execution ${executionId} finished with status: ${status}`);
+                return execution;
+            }
+            // Wait before polling again
+            await new Promise(resolve => setTimeout(resolve, interval));
+        }
+        throw new Error(`Execution ${executionId} did not complete within ${maxWait}ms`);
+    }
+}
+/**
+ * Factory function to create a JobExecutionHelper
+ */
+export const jobExecutions = (jobName) => {
+    return new JobExecutionHelper(jobName);
+};

package/dist/esm/jobs/jobs.js

@@ -1,4 +1,4 @@
-import { generateInternalUrl, getForcedUrl } from "../common/internal.js";
+import { getForcedUrl, getGlobalUniqueHash } from "../common/internal.js";
 import { logger } from "../common/logger.js";
 import { settings } from "../common/settings.js";
 import { startSpan } from '../telemetry/telemetry.js';
@@ -17,8 +17,8 @@ class BlJob {
         return new URL(`${settings.runUrl}/${settings.workspace}/jobs/${this.jobName}`);
     }
     get internalUrl() {
-        const url = generateInternalUrl(settings.workspace, "job", this.jobName, settings.env, settings.runInternalProtocol, settings.runInternalHostname, settings.blCloud, settings.workspaceId);
-        return new URL(url);
+        const hash = getGlobalUniqueHash(settings.workspace, "job", this.jobName);
+        return new URL(`${settings.runInternalProtocol}://bl-${settings.env}-${hash}.${settings.runInternalHostname}`);
     }
     get forcedUrl() {
         return getForcedUrl('job', this.jobName);

package/dist/esm/jobs/start.js

@@ -2,43 +2,12 @@ import { authenticate } from '../common/autoload.js';
 import { env } from '../common/env.js';
 import { flush } from '../telemetry/telemetry.js';
 class BlJobWrapper {
-    async fetchWithRetry(url, maxRetries = 3) {
-        let lastError;
-        for (let attempt = 0; attempt <= maxRetries; attempt++) {
-            try {
-                const response = await fetch(url);
-                // If the response is successful, return it
-                if (response.ok) {
-                    return response;
-                }
-                // If it's not the last attempt and the status is retriable, retry
-                if (attempt < maxRetries && (response.status >= 500 || response.status === 429)) {
-                    lastError = new Error(`HTTP ${response.status}: ${response.statusText}`);
-                }
-                else {
-                    // For non-retriable errors or last attempt, return the response
-                    return response;
-                }
-            }
-            catch (error) {
-                lastError = error instanceof Error ? error : new Error(String(error));
-                // If this is the last attempt, throw the error
-                if (attempt === maxRetries) {
-                    throw lastError;
-                }
-            }
-            // Calculate exponential backoff delay: 2^attempt * 1000ms (1s, 2s, 4s)
-            const delay = Math.pow(2, attempt) * 1000;
-            await new Promise(resolve => setTimeout(resolve, delay));
-        }
-        throw lastError || new Error('Failed to fetch after retries');
-    }
     async getArguments() {
         if (!env.BL_EXECUTION_DATA_URL) {
             const args = this.parseCommandLineArgs();
             return args;
         }
-        const response = await this.fetchWithRetry(env.BL_EXECUTION_DATA_URL);
+        const response = await fetch(env.BL_EXECUTION_DATA_URL);
         const data = await response.json();
         return data.tasks[this.index] ?? {};
     }

package/dist/esm/sandbox/action.js

@@ -1,5 +1,5 @@
 import { createClient } from "@hey-api/client-fetch";
-import { generateInternalUrl, getForcedUrl } from "../common/internal.js";
+import { getForcedUrl, getGlobalUniqueHash } from "../common/internal.js";
 import { settings } from "../common/settings.js";
 import { client as defaultClient } from "./client/client.gen.js";
 export class ResponseError extends Error {
@@ -44,7 +44,8 @@ export class SandboxAction {
         return this.sandbox.metadata?.url ?? `${settings.runUrl}/${settings.workspace}/sandboxes/${this.name}`;
     }
     get internalUrl() {
-        return generateInternalUrl(settings.workspace, "sandbox", this.name, settings.env, settings.runInternalProtocol, settings.runInternalHostname, settings.blCloud, settings.workspaceId);
+        const hash = getGlobalUniqueHash(settings.workspace, "sandbox", this.name);
+        return `${settings.runInternalProtocol}://bl-${settings.env}-${hash}.${settings.runInternalHostname}`;
     }
     get client() {
         if (this.sandbox.forceUrl) {

package/dist/esm/sandbox/index.js

@@ -5,4 +5,5 @@ export * from "./filesystem/index.js";
 export * from "./codegen/index.js";
 export * from "./sandbox.js";
 export * from "./types.js";
+export * from "./interpreter.js";
 // Re-export everything from client except ClientOptions to avoid conflict