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

package/dist/cjs-browser/types/common/internal.d.ts

@@ -2,5 +2,3 @@ export declare function getAlphanumericLimitedHash(input: string, maxSize?: numb
 export declare function getGlobalUniqueHash(workspace: string, type: string, name: string): string;
 export declare function pluralize(type: string): string;
 export declare function getForcedUrl(type: string, name: string): import("url").URL | null;
-export declare function getWorkloadTypeShort(type: string): string;
-export declare function generateInternalUrl(workspace: string, type: string, name: string, env: string, protocol: string, hostname: string, blCloud: boolean, workspaceId: string): string;

package/dist/cjs-browser/types/common/settings.d.ts

@@ -23,7 +23,6 @@ declare class Settings {
     get runInternalHostname(): string;
     get runInternalProtocol(): string;
     get blCloud(): boolean;
-    get workspaceId(): string;
     get generation(): string;
     get loggerType(): string;
     authenticate(): Promise<void>;

package/dist/cjs-browser/types/common/version.d.ts

@@ -0,0 +1,2 @@
+export declare const PACKAGE_VERSION = "0.2.49";
+export declare const PACKAGE_COMMIT = "4548518514109c742457451a6eb36fa8d054eb9b";

package/dist/cjs-browser/types/common/webhook.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Webhook signature verification for async-sidecar callbacks
+ */
+export interface WebhookVerificationOptions {
+    /**
+     * The raw request body as a string
+     */
+    body: string;
+    /**
+     * The X-Blaxel-Signature header value (format: "sha256=<hex_digest>")
+     */
+    signature: string;
+    /**
+     * The secret key used to sign the webhook (same as CALLBACK_SECRET in async-sidecar)
+     */
+    secret: string;
+    /**
+     * Optional: The X-Blaxel-Timestamp header value for replay attack prevention
+     */
+    timestamp?: string;
+    /**
+     * Optional: Maximum age of the webhook in seconds (default: 300 = 5 minutes)
+     */
+    maxAge?: number;
+}
+export interface AsyncSidecarCallback {
+    status_code: number;
+    response_body: string;
+    response_length: number;
+    timestamp: number;
+}
+/**
+ * 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 declare function verifyWebhookSignature(options: WebhookVerificationOptions): boolean;
+/**
+ * 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 declare function verifyWebhookFromRequest(request: {
+    body: string;
+    headers: Record<string, string | string[] | undefined>;
+}, secret: string, maxAge?: number): boolean;

package/dist/cjs-browser/types/jobs/executions.d.ts

@@ -0,0 +1,42 @@
+import type { CreateJobExecutionRequest, JobExecution } from "../client/types.gen.js";
+/**
+ * JobExecutionHelper provides convenient methods for working with job executions
+ */
+export declare class JobExecutionHelper {
+    private jobName;
+    constructor(jobName: string);
+    /**
+     * Create a new job execution and return the execution ID
+     */
+    create(request: CreateJobExecutionRequest): Promise<string>;
+    /**
+     * Get a specific job execution by ID
+     */
+    get(executionId: string): Promise<JobExecution>;
+    /**
+     * List all executions for the job
+     */
+    list(): Promise<JobExecution[]>;
+    /**
+     * Get the status of a specific execution
+     */
+    getStatus(executionId: string): Promise<string>;
+    /**
+     * Delete a specific job execution
+     */
+    delete(executionId: string): Promise<void>;
+    /**
+     * 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)
+     */
+    waitForCompletion(executionId: string, options?: {
+        maxWait?: number;
+        interval?: number;
+    }): Promise<JobExecution>;
+}
+/**
+ * Factory function to create a JobExecutionHelper
+ */
+export declare const jobExecutions: (jobName: string) => JobExecutionHelper;

package/dist/cjs-browser/types/sandbox/client/sdk.gen.d.ts

@@ -123,7 +123,7 @@ export declare const deleteFilesystemByPath: <ThrowOnError extends boolean = fal
  * Get file or directory information
  * Get content of a file or listing of a directory. Use Accept header to control response format for files.
  */
-export declare const getFilesystemByPath: <ThrowOnError extends boolean = false>(options: Options<GetFilesystemByPathData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<import("./types.gen").File | import("./types.gen").Directory | import("./types.gen").FileWithContent | Blob, import("./types.gen").ErrorResponse, ThrowOnError>;
+export declare const getFilesystemByPath: <ThrowOnError extends boolean = false>(options: Options<GetFilesystemByPathData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<import("./types.gen").Directory | import("./types.gen").FileWithContent | Blob | import("./types.gen").File, import("./types.gen").ErrorResponse, ThrowOnError>;
 /**
  * Create or update a file or directory
  * Create or update a file or directory

package/dist/cjs-browser/types/sandbox/index.d.ts

@@ -3,3 +3,4 @@ export * from "./filesystem/index.js";
 export * from "./codegen/index.js";
 export * from "./sandbox.js";
 export * from "./types.js";
+export * from "./interpreter.js";

package/dist/cjs-browser/types/sandbox/interpreter.d.ts

@@ -0,0 +1,71 @@
+import { Sandbox, SandboxLifecycle, Port } from "../client/types.gen.js";
+import { SandboxInstance } from "./sandbox.js";
+import { SandboxConfiguration, SandboxCreateConfiguration } from "./types.js";
+export declare class CodeInterpreter extends SandboxInstance {
+    static readonly DEFAULT_IMAGE = "blaxel/jupyter-server";
+    static readonly DEFAULT_PORTS: Port[];
+    static readonly DEFAULT_LIFECYCLE: SandboxLifecycle;
+    private _sandboxConfig;
+    constructor(sandbox: SandboxConfiguration);
+    static get(sandboxName: string): Promise<CodeInterpreter>;
+    static create(sandbox?: Sandbox | SandboxCreateConfiguration | Record<string, any> | null, { safe }?: {
+        safe?: boolean;
+    }): Promise<CodeInterpreter>;
+    get _jupyterUrl(): string;
+    static OutputMessage: {
+        new (text: string, timestamp: number | null, isStderr: boolean): {
+            text: string;
+            timestamp: number | null;
+            isStderr: boolean;
+        };
+    };
+    static Result: {
+        new (kwargs?: Record<string, unknown>): {
+            [key: string]: unknown;
+        };
+    };
+    static ExecutionError: {
+        new (name: string, value: any, traceback: any): {
+            name: string;
+            value: any;
+            traceback: any;
+        };
+    };
+    static Logs: {
+        new (): {
+            stdout: string[];
+            stderr: string[];
+        };
+    };
+    static Execution: {
+        new (): {
+            results: InstanceType<typeof CodeInterpreter.Result>[];
+            logs: InstanceType<typeof CodeInterpreter.Logs>;
+            error: InstanceType<typeof CodeInterpreter.ExecutionError> | null;
+            executionCount: number | null;
+        };
+    };
+    static Context: {
+        new (id: string): {
+            id: string;
+        };
+        fromJson(data: Record<string, any>): InstanceType<typeof CodeInterpreter.Context>;
+    };
+    private _parseOutput;
+    runCode(code: string, options?: {
+        language?: string | null;
+        context?: InstanceType<typeof CodeInterpreter.Context> | null;
+        onStdout?: (msg: InstanceType<typeof CodeInterpreter.OutputMessage>) => void;
+        onStderr?: (msg: InstanceType<typeof CodeInterpreter.OutputMessage>) => void;
+        onResult?: (result: InstanceType<typeof CodeInterpreter.Result>) => void;
+        onError?: (error: InstanceType<typeof CodeInterpreter.ExecutionError>) => void;
+        envs?: Record<string, string> | null;
+        timeout?: number | null;
+        requestTimeout?: number | null;
+    }): Promise<InstanceType<typeof CodeInterpreter.Execution>>;
+    createCodeContext(options?: {
+        cwd?: string | null;
+        language?: string | null;
+        requestTimeout?: number | null;
+    }): Promise<InstanceType<typeof CodeInterpreter.Context>>;
+}

package/dist/cjs-browser/types/sandbox/sandbox.d.ts

@@ -1,24 +1,19 @@
 import { Sandbox as SandboxModel } from "../client/index.js";
 import { SandboxFileSystem } from "./filesystem/index.js";
-import { SandboxFileSystemWebSocket } from "./filesystem/filesystem-ws.js";
 import { SandboxNetwork } from "./network/index.js";
-import { SandboxNetworkWebSocket } from "./network/network-ws.js";
 import { SandboxPreviews } from "./preview.js";
 import { SandboxProcess } from "./process/index.js";
-import { SandboxProcessWebSocket } from "./process/process-ws.js";
 import { SandboxCodegen } from "./codegen/index.js";
-import { SandboxCodegenWebSocket } from "./codegen/codegen-ws.js";
 import { SandboxSessions } from "./session.js";
 import { SandboxConfiguration, SandboxCreateConfiguration, SandboxUpdateMetadata, SessionWithToken } from "./types.js";
 export declare class SandboxInstance {
     private sandbox;
-    fs: SandboxFileSystem | SandboxFileSystemWebSocket;
-    network: SandboxNetwork | SandboxNetworkWebSocket;
-    process: SandboxProcess | SandboxProcessWebSocket;
+    fs: SandboxFileSystem;
+    network: SandboxNetwork;
+    process: SandboxProcess;
     previews: SandboxPreviews;
     sessions: SandboxSessions;
-    codegen: SandboxCodegen | SandboxCodegenWebSocket;
-    private wsClient?;
+    codegen: SandboxCodegen;
     constructor(sandbox: SandboxConfiguration);
     get metadata(): import("../client/types.gen.js").Metadata | undefined;
     get status(): string | undefined;
@@ -28,13 +23,12 @@ export declare class SandboxInstance {
         maxWait?: number;
         interval?: number;
     }): Promise<this>;
-    closeConnection(): void;
     static create(sandbox?: SandboxModel | SandboxCreateConfiguration, { safe }?: {
         safe?: boolean;
     }): Promise<SandboxInstance>;
-    static get(sandboxName: string, connectionType?: "http" | "websocket"): Promise<SandboxInstance>;
+    static get(sandboxName: string): Promise<SandboxInstance>;
     static list(): Promise<SandboxInstance[]>;
-    static delete(sandboxName: string, instance?: SandboxInstance): Promise<SandboxModel>;
+    static delete(sandboxName: string): Promise<SandboxModel>;
     static updateMetadata(sandboxName: string, metadata: SandboxUpdateMetadata): Promise<SandboxInstance>;
     static createIfNotExists(sandbox: SandboxModel | SandboxCreateConfiguration): Promise<SandboxInstance>;
     static fromSession(session: SessionWithToken): Promise<SandboxInstance>;

package/dist/cjs-browser/types/sandbox/types.d.ts

@@ -20,12 +20,10 @@ export interface VolumeBinding {
     mountPath: string;
     readOnly?: boolean;
 }
-export type ConnectionType = "http" | "websocket";
 export type SandboxConfiguration = {
     forceUrl?: string;
     headers?: Record<string, string>;
     params?: Record<string, string>;
-    connectionType?: ConnectionType;
 } & Sandbox;
 export type SandboxUpdateMetadata = {
     labels?: Record<string, string>;
@@ -43,7 +41,6 @@ export type SandboxCreateConfiguration = {
     region?: string;
     lifecycle?: SandboxLifecycle;
     snapshotEnabled?: boolean;
-    connectionType?: ConnectionType;
 };
 export declare function normalizePorts(ports?: (Port | Record<string, any>)[]): Port[] | undefined;
 export declare function normalizeEnvs(envs?: EnvVar[]): EnvVar[] | undefined;

package/dist/client/authentication.d.ts

@@ -0,0 +1,25 @@
+import { OptionsLegacyParser } from "@hey-api/client-fetch";
+type OauthTokenData = {
+    body: {
+        grant_type: 'client_credentials' | 'refresh_token' | 'device_code';
+        client_id?: string;
+        client_secret?: string;
+        device_code?: string;
+        refresh_token?: string;
+    };
+    authenticated?: boolean;
+};
+type OauthTokenResponse = {
+    access_token: string;
+    refresh_token: string;
+    expires_in: number;
+    token_type: string;
+};
+type OauthTokenError = {
+    error: string;
+};
+/**
+ * Get a new oauth token
+ */
+export declare const oauthToken: <ThrowOnError extends boolean = false>(options: OptionsLegacyParser<OauthTokenData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<OauthTokenResponse, OauthTokenError, ThrowOnError>;
+export {};

package/dist/client/authentication.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.oauthToken = void 0;
+const client_gen_js_1 = require("./client.gen.js");
+/**
+ * Get a new oauth token
+ */
+const oauthToken = (options) => {
+    options.authenticated = false;
+    return client_gen_js_1.client.post({
+        ...options,
+        url: '/oauth/token',
+    });
+};
+exports.oauthToken = oauthToken;

package/dist/client/client.d.ts

@@ -0,0 +1,2 @@
+export * from './index.js';
+export { _Function as Function } from './types.gen.js';

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

@@ -0,0 +1,12 @@
+import type { ClientOptions } from './types.gen';
+import { type Config, type ClientOptions as DefaultClientOptions } from '@hey-api/client-fetch';
+/**
+ * The `createClientConfig()` function will be called on client initialization
+ * and the returned object will become the client's initial configuration.
+ *
+ * You may want to initialize your client this way instead of calling
+ * `setConfig()`. This is useful for example if you're using Next.js
+ * to ensure your client always has the correct values.
+ */
+export type CreateClientConfig<T extends DefaultClientOptions = ClientOptions> = (override?: Config<DefaultClientOptions & T>) => Config<Required<DefaultClientOptions> & T>;
+export declare const client: import("@hey-api/client-fetch").Client;

package/dist/client/client.gen.js

@@ -0,0 +1,8 @@
+"use strict";
+// This file is auto-generated by @hey-api/openapi-ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.client = void 0;
+const client_fetch_1 = require("@hey-api/client-fetch");
+exports.client = (0, client_fetch_1.createClient)((0, client_fetch_1.createConfig)({
+    baseUrl: 'https://api.blaxel.ai/v0'
+}));

package/dist/{cjs/sandbox/websocket/index.js → client/client.js}

@@ -14,4 +14,4 @@ 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("./client.js"), exports);
+__exportStar(require("./index.js"), exports);

package/dist/client/index.d.ts

@@ -0,0 +1,2 @@
+export * from './types.gen.js';
+export * from './sdk.gen.js';

package/dist/client/index.js

@@ -0,0 +1,19 @@
+"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 });
+// This file is auto-generated by @hey-api/openapi-ts
+__exportStar(require("./types.gen.js"), exports);
+__exportStar(require("./sdk.gen.js"), exports);

package/dist/client/interceptors.d.ts

@@ -0,0 +1,3 @@
+type Interceptor = (request: Request, options: Record<string, unknown>) => Promise<Request | Response>;
+export declare const interceptors: Interceptor[];
+export {};

package/dist/client/interceptors.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.interceptors = void 0;
+const settings_js_1 = require("../common/settings.js");
+exports.interceptors = [
+    // Authentication interceptor
+    async (request, options) => {
+        if (options.authenticated === false) {
+            return request;
+        }
+        await settings_js_1.settings.authenticate();
+        for (const header in settings_js_1.settings.headers) {
+            request.headers.set(header, settings_js_1.settings.headers[header]);
+        }
+        return request;
+    },
+];