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

package/dist/cjs/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/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/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/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/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/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/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/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/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/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;